关键字
static关键字
什么是static?
static(静态)是java语言中的修饰符关键字用来修饰:成员变量、成员方法(被static修饰的成员变量,一般叫做静态变量;被static修饰的成员方法,一般叫做静态方法)static解决程序中的什么问题?
当程序中的某个数据需要共享时使用static修饰static怎么使用?
public class Student{
//成员变量
private String name;
private static String city;//静态成员变量
//静态成员方法
public static void method(){ }
}//通过类名访问静态内容(静态的私有成员变量不能访问)
static在使用中的注意细节?
1、静态内容是随着类的加载就存在了(早于对象创建)2、静态内容通常是使用: 类名.成员变量 类名.成员方法(),也可以通过对象名调用
3、静态方法中只能访问静态成员(静态变量、静态方法)
4、静态方法中不能使用this关键字
5、非静态方法中可以直接访问:静态成员
pubilc class Static2(){
//静态成员变量
public static int number = 10;
//静态成员方法
public static void send(){
System.out.println("好好休息吧");
}
}
-------------------------------------------------------------------------------
//当程序中的某个数据需要共享时使用static修饰
public class Text1 {
public static void main(String[] args) {
//创建对象
Static2 st1 = new Static2();
Static2 st2 = new Static2();
Static2 st3 = new Static2();
st1.number++;
st2.number++;
st3.number++;
System.out.println(Static2.number);//13
}
}
----------------------------------------------------------
public class Text2 {
//静态成员变量
static int a = 19;
int b=100;
private String name;//非静态成员变量
//测试:静态内容不需要创建对象,就可以使用(早于对象存在)
public static void main(String[] args) {
System.out.println(Static2.number);//10
Static2.send();//好好休息吧
show();//show //静态方法只能访问静态成员(静态变量,静态方法)
System.out.println(a);//19
// System.out.println(b);//不是静态的,会报错
//静态方法什么地方常用:在工具类中,如:Math工具类中
int a=10;
int c=90;
int g=Math.max(a,c);
System.out.println(g);//90
}
//静态方法
public static void show(){
System.out.println("show");
//在静态方法中不能使用this
// this.name="测试";
}
//非静态方法
public void show2(){
this.name="我不好!";
System.out.println("show2");
System.out.println(this.name);
show();//非静态方法可以访问静态方法,也可以访问非静态方法
System.out.println(b);
System.out.println(a);
}
}
JVM内存划分:
1. 栈-
堆
-
方法区 :是由N多个不同功能的小区域组成的
3.1 静态区域:存放静态内容
3.2非静态区域:存放非静态内容
3.3字符串常量池:存放字符串常量
-
寄存器
-
本地方法区
final关键字
什么是final关键字?
final(最终的,不可改变的)是Java语言中的修饰符关键字,用来修饰:类,变量,方法final关键字在程序中解决什么问题?
1、当某个变量不允许修改数据值时,可以使用final修饰变量2、当某个方法不允许被子类重写时,可以使用final修饰方法
3、当某个类不允许被继承时,可以使用final修饰类。 举例:String类
final关键字怎么使用?
public final class 类名{
private final int COUNT=100;
public final void method(){
}
}
关键字在使用中要注意什么细节?
final和abstract不能共存使用
权限修饰符
权限修饰符是什么?
权限修饰符是java语言中的关键字,用于修饰:类、变量、方法
权限修饰符:private 、public 、protected、默认(什么都不写)
权限修饰符号解决什么问题?
限制程序中的访问权限(类的访问权限、变量的访问权限、方法的访问权限)
权限修饰符怎么使用?
//类(权限:公开的 [没有限制])
public class 类{
//成员变量(私有权限:本类中使用)
private String name;
//默认权限(权限:当前包下的任意类)
void show(){ }
//protected(权限:同一个包下的任意类 或 不同包下的子类 )
protected void method(){ }
}
从小到大排序:
-
private //访问范围: 仅现本类中访问
-
默认 //访问范围: 只能在同一个包下的类
-
protected //访问范围: 同一个包下的任意类 或 不同包下的子类
-
public //访问范围 :没有限制
权限修饰符在使用中的注意细节?
//方法重写时:保障子类中重写访问的访问权限必须 >= 父类中方法的权限
在开发中经常会使用或开发:工具类
- 工具类的特点:-
不能被继承
-
不能让其他类创建对象
-
提供静态方法
//final保障 :工具类不能被继承
public final class 工具类{
//不能让其他类创建对象
private 工具类(){}
//给外部提供:静态方法
public static 返回值 静态方法(…){
}
}
在一个类中可以书写哪些内容?
public class 类{
//成员变量:静态、非静态
//成员方法:静态、非静态、抽象
//构造方法
//代码块
}
代码块
代码块:{
//构造代码块
}
代码块划分:
静态代码块: //开发中使用最多
书写位置:在类中方法外(和成员变量、成员方法属于同一级)在构造代码块上添加:static
特点:随着类的加载,执行1次静态代码块(类只会被加载1次)
作用:用于对静态成员数据进行初始化
import java.util.ArrayList;
/* 静态代码块 :
1 定义的位置 : 在一对大括号前加上static , 定义在类中方法外
2 执行时机 ; 随着类的加载而执行, 只加载一次
3 可以给类中的静态成员进行初始化数据
*/
public class StaticCode {
//集合
private static ArrayList<String> list = new ArrayList<String>();
//静态代码块
static {
System.out.println("静态代码块~");
//初始化数据
list.add("Java");
list.add("MySQL");
list.add("Mybatis");
list.add("html");
}
//获取数据
public static String getData(int index){
String str =list.get(index);
return str;
}
}
---------------------------
public class StaticCodeTest {
public static void main(String[] args) {
//不需要创建对象,使用静态方法获取数据
String data = StaticCode.getData(2);
System.out.println(data);
}
}
运行结果:Mybatis
构造代码块
书写位置:在类中方法外(和成员变量、成员方法属于同一级)特点:在每个构造方法执行前,都会先执行构造代码块
作用:当类中多个构造方法中有共性内容时,可能抽取到构造代码块
//构造代码块
public class ConstructorCode {
//集合对象
ArrayList<String> list = new ArrayList<String>();
//构造代码块
{
System.out.println("构造代码块~~~");
//把构造方法中共性内容书写在构造代码块中
list.add("Java");
list.add("MySQL");
list.add("HTML");
}
//构造方法
public ConstructorCode() {
//初始化集合中的元素
System.out.println("无参构造方法");
}
public ConstructorCode(String str) {
System.out.println("有参构造方法");
//初始化集合中的元素
list.add(str);
}
}
-------------------------------------
public class ConstructorCodeTest {
public static void main(String[] args) {
//创建对象
ConstructorCode c1 = new ConstructorCode();
ConstructorCode c2 = new ConstructorCode("测试");
}
}
运行结果:
构造代码块~~~
无参构造方法
构造代码块~~~
有参构造方法
局部代码块
书写位置:写在方法体中特点:在方法执行时,才会调用
作用:用于作用域
接口
什么是接口?
一个类中的所有方法都是抽象方法的时候,此类就是定义规则的类 , 我们就可以将其定义为**接口**接口也是一种引用数据类型,它比抽象类还要抽象
接口的作用:
制定规则制定规则的两种方案:
1. 定义类,类中书写抽象方法(不建议使用。 类只能单一继承)- 定义接口, 接口中书写抽象方法(接口好处:可以多实现)
接口的定义:
public interface 接口名{
//成员方法:只能是抽象方法,默认修饰符:public abstract
//成员变量:只能是常量,默认修饰符:public static final
}
接口的调用:
interface MyInterface {
void myMethod();
}
class Implementation implements MyInterface {
@Override
public void myMethod() {
System.out.println(“Implementation’s method”);
}
}
// 调用
MyInterface obj = new Implementation();
obj.myMethod();
接口的特点:
1. 接口不能实例化(不能创建对象)-
接口中没有构造方法(接口只能通过子类来实现对象创建)
-
接口可以多实现( 一个类可以实现多个接口[解决类只能单一继承的问题] )
按照接口中定义的规则开发子类:
接口的子类(实现类):
要么重写接口中的所有抽象方法要么是抽象类
编写接口实现类
public class 类名 implements 接口{
//重写接口中所有的抽象方法
}
接口的多实现:
public class 接口实现类 implements 接口1 , 接口2 , 接口3 {
//重写所实现接口中所有的抽象方法
}
在接口可以书写的内容:
public interface 接口名{
//抽象方法
//静态常量
public static final int NUMBER = 10;
}
问题:生活中有没有一些数据是固定的,且值比较单一? 示例:性别(固定、且仅有2个值)
public interface Gender{
public static final String BOY = “男”;
public static final String GIRL = “女”;
}
//程序中需要给性别赋值
String sex = Gender.BOY;
String sex = Gender.GIRL;
接口中的方法的升级:
随着JDK版本的升级在jdk1.8版本中新增:
默认方法(但是需要使用关键字default修饰)、静态方法 //有方法体代码默认方法的定义格式:
格式:public default 返回值类型 方法名(参数列表) { }
范例:public default void show() { }
静态方法的定义格式:
格式:public static 返回值类型 方法名(参数列表) { }
范例:public static void show() { }
在jdk1.9版本中新增:
私有方法 //有方法体代码私有方法的定义格式 :
格式1:private 返回值类型 方法名(参数列表) { }
范例1:private void show() { }
格式2:private static 返回值类型 方法名(参数列表) { }
范例2:private static void method() { }
作用 : 接口中的方法出现了重复的代码,还不想被其他类访问 , 可以考虑抽取出一个私有方法
接口中默认方法的注意事项:
默认方法不是抽象方法,所以不强制被重写。但是可以被重写,重写的时候去掉default关键字public可以省略,default不能省略
如果实现了多个接口,多个接口中存在相同的方法声明,子类就必须对该方法进行重写
接口中静态方法的**注意事项**:
静态方法只能通过接口名调用,不能通过实现类名或者对象名调用public可以省略,static不能省略
类和接口的概念:
类和类之间的关系: 继承 (只能单一继承)public 子类 extends 父类{
}
类和接口之间的关系:实现
public 子类 implements 接口{
}
接口和接口之间的关系:继承 (允许多继承)
public 接口1 extends 接口2 {
//问题:为什么接口可以多继承?
//答案:接口中仅仅只是定义功能(没有功能的实现,子类要自己实现功能)}
接口和抽象类的相同之处:
1. 接口和抽象类, 都不能实例化(不能创建对象)-
接口和抽象类,都具有抽象方法
-
接口和抽象类,都是做为父类型存在的
抽象类和接口的区别:
1. 抽象类:除了抽象方法外,还具有成员变量、构造方法、非抽象方法- 接口:除了抽象方法外,只有常量 (JDK8:默认方法、静态方法)(JDK9:私有方法)
选择语句:
switch( 常量表达式 ){ //只能使用:byte、short、int、char、String、枚举
case 常量值1:
语句1;
break;
… }
枚举
什么是枚举?
在java语言中,枚举是一种数据类型。枚举用来表示:固定且仅有几种取值范围的数据枚举解决程序中的什么问题?
当程序中有数据是固定且只有几种取值范围时,使用枚举类型强制设置值的范围(赋值数据有保障)枚举怎么使用?
//枚举类型
public enum Signal {
//取值范围
GREEN, YELLOW, RED;
}
public class Test {
//根据红绿灯变化,执行交通
public static void chang(Signal color) {
switch (color){
case RED:
System.out.println(“红灯停”);
break;
case GREEN:
System.out.println(“绿灯行”);
break;
case YELLOW:
System.out.println(“黄灯等一等”);
break;
}
}
public static void main(String[] args) {
//调用静态方法
chang(Signal.GREEN);
}
}
运行结果:绿灯行
枚举在使用中有哪些注意细节?
1. 枚举本质是一个类2.在枚举中除了可以书写:固定选项值外,还可以书写:成员变量、私有构造方法、成员方法
3.枚举的构造方法必须是private的,不能从外部实例化。