JAVA关键字

static

什么是stasic关键字

static关键字是静态的意思，是java中的一个修饰符，可以修饰成员方法，成员变量
被static修饰的成员变量/方法，一般叫做静态变量/方法

记忆：static是java语言中修饰符关键字
用来修饰：成员变量以及成员方法

特点

被所在类的所有对象共享
：是我们判断是否使用静态关键字的条件
随着类的加载而加载，优先于对象存在
：对象需要类被加载后，才能创建
可以通过类名调用
：也可以类对象名调用
推荐使用类名调用

staic解决什么问题？

1.当程序中的某个数据需要共享时使用static修饰

static怎么使用？

public class static01 {
    //成员变量
    String name = "lvlv";
    //静态成员
    static String city = "xian";
    static int digtal = 9;
    //成员方法
    public void show01() {
    }
    //静态成员方法
    public static void show2() {
    }
}

下面展示 测试类。

//测试：静态成员变量可以实现数据共享

public class test {
    //测试：静态成员变量可以实现数据共享
    public static void main(String[] args) {

        //创建对象
        static01 s1 = new static01();
        static01 s2 = new static01();
        static01 s3 = new static01();

        s1.digtal++;
        s2.digtal++;
        s3.digtal++;
        //静态内容，通常使用类名调用
        System.out.println(static01.digtal);
    }
}

结果：12

 //测试：静态内容是不需要创建对象，就可以使用了
        （早于对象创建）

public class test2 {
    public static void main(String[] args) {
        //测试：静态内容是不需要创建对象，就可以使用了（早于对象创建）
        System.out.println(static01.digtal);
        static01.show2();
    }
}

static在使用中的使用细节？

1.静态内容是随着类的加载就存在了(早于对象创建)
2.静态内容通常是使用：
类名.成员变量
类名.成员方法()
3.静态方法只能访问静态成员（静态成员,静态方法）
4.静态方法中不能用this关键字
原因：静态内容创建早于对象，而this指向的是当前对象本类成员
5.非静态方法可以直接访问非静态成员，也可以访问静态成员

总结：
静态方法:只能访问静态成员，不能有this关键字
非静态方法:静态/非静态成员，this都可以用

public class test03 {
    int num = 10;
    static String name = "baby";
    public static void S1(){
        System.out.println("我是静态方法");
        //show(); 
        //此处非静态成员方法不能被静态方法访问
        //num++;
        //此处非静态成员变量不能被静态方法访问
    }
    public void show2() {
        System.out.println("静态方法");
    }
    public  void show() {
        System.out.println("我是非静态方法");
        S1();
        show2();
        num++;
        System.out.println(num);
        System.out.println(name);
        //此处非静态成员变量/方法都能被非静态方法访问
        //此处静态成员变量/方法都能被非静态方法访问
    }
}

JVM内存划分

栈内存

main

方法区

• 非静态区域

存储没有static的修饰的内容

• 静态区域

存放有static修饰的内容

• 字符串常量池

堆内存

final关键字

final是什么？

final关键字是最终的意思，可以修饰方法，变量，类

特点

修饰方法：方法不能被重写,用于不能被重写
修饰变量：变量不能再次更改数据值，该变量是常量，用于该变量不想被改变，其实就是一个常量值
注意：被final修饰的变量，名字每个字母都需要大写，多个字母之间用下划线分割
修饰类：类不能被继承，即没有子类，用于所写的类不想被扩展继承，就可以使用该关键字进行修饰了。比如所定义的工具类（String类）

变量是基本类型：final修饰指的是基本类型的数据值不能改变
变量是引用类型：final修饰指的是引用类型的地址值不能改变，但是地址里面的内容是可以改变的
final修饰成员变量初始化时
直接给变量赋值 在构造方法执行完毕前赋值

final解决什么问题

关键字abstract可以和final可以共存吗？

不可以
在类中，abstract是希望子类继承，而final关键字是阻止继承
在方法中，abstract是希望子类重写，而final关键字是阻止重写

// public final class 类名{
	private final int COUNT = 10;
	public final void method(){
	}
}

权限修饰符

是什么

Java中语言关键字，用于修饰：类，方法，变量
权限修饰符：private,public,protected,默认（什么都不写）

解决什么问题？

限制程序中的访问权限（类，方法，变量）

怎么用

//类（权限。公开的[没有限制]）
public class deom01{
//private私有的只能用于本类访问
private int num =10;
//受保护的同一个包下都可以，其他包下只有子类可以访问
protected String baby ="lvlv";
//默认权限（package-private）也称作包私有
//同一个包下可以，其他包不可以
}

代码块

在一个类中可以写哪些内容

//成员变量：静态，非静态
//成员方法：静态，非静态
//构造方法
//代码块

代码块夫人分类

能够定义构造代码块，并知道执行特点

//开发中使用最多

//在类中方法外定义一个大括号（和成员变量，成员方法一个等级）
public clsaa Student{
		{
		//构造代码块
		}
} 

• 特点：会在每个构造方法执行前，执行一次
• 作用：当多个构造方法中有共性内容时，可以抽取到构造代码块中。比如可以给自己定义常量赋值，或者抽取构造方法中的共性内容

//public class common {
    //集合对象
    ArrayList<String> list = new ArrayList<>();
    //代码块

    {
//把构造方法中共性内容抽取到代码块中 下面构造方法中就不用写了
        list.add("java");
        list.add("web");
        list.add("html");
    }
    //构造方法
    public common(){
       /* list.add("java");
        list.add("web");
        list.add("html");*/
    }
    public common(String str){
        /*list.add("java");
        list.add("web");
        list.add("html");*/
        list.add(str);
    }
}

public class common {
    //集合对象
    ArrayList<String> list = new ArrayList<>();
    //代码块

    {
        System.out.println("代码块");
//把构造方法中共性内容抽取到代码块中 下面构造方法中就不用写了
        list.add("java");
        list.add("web");
        list.add("html");
    }
    //构造方法
    public common(){
        System.out.println("无参");
       /* list.add("java");
        list.add("web");
        list.add("html");*/
    }
    public common(String str){
        /*list.add("java");
        list.add("web");
        list.add("html");*/
        list.add(str);
        System.out.println("有参");
    }
}

public class test {
    public static void main(String[] args) {
        //测试 会在每个构造方法执行前，执行一次代码块
        common  t01 = new common();
        common  t02 = new common("测试");
    }
}

能够定义静态代码块，并知道执行特点

• 执行特点：在类中方法外定义一个大括号
• 在构造代码块上添加static
• 随着类加载到内存，会执行一次静态代码块。（类只会被加载一次，类加载到方法区初始化的时候就会执行静态代码块）
• 作用：可以对静态数据进行初始化

public class Student {
    static{
        System.out.println("我是静态代码块");
    }
    public Student(){
        System.out.println("无参");
    }
    public Student(int a){
        System.out.println("有参");
    }
}

public class test {
    public static void main(String[] args) {
        new Student();
        new Student(10);
    }
}

能够定义局部代码块，并知道执行特点

任意局部代码位置都可以定义局部代码块，就是一个大括号，静态/构造代码块，方法中，构造方法中都可以定义局部代码块。相比之下在方法中定义局部代码块稍多一些。

public void setStr() {
        String str;
        {
            str = "string";
          int i2 = 10;
        }
        System.out.println(i2);//不在i2作用域不能访问
    }

• 作用 可以限定变量作用域，在代码块执行完毕后及时释放内存
• 作用域就是所在那对大括号即就是作用域范围