1、static总结

1、static 可以用来修饰变量和方法 变为类变量或者类方法。
类变量和类方法 跟随类一起加载，由于类只被加载一次，所以类变量和类方法也只被加载一次。
2、类变量和类方法属于类本身，所有对象可共享，直接使用类名.类变量或者类方法名 就可以调用，也可以使用实例.来调用/
3、类方法只能访问类变量；
实例方法既可以访问实例变量也可以访问类变量；
实例方法允许使用this关键字，类方法不允许。
4、单例设计模式:
①设计模式是指解决一个问题的最优解
②单例设计模式 确保一个类只有一个对象 可以节约内存 比如任务管理器，运行时环境等，只有一个对象即可。
写法：
饿汉式单例：在拿对象时，对象就已经创建好了。

package com.cky.static_demo;

public class A {
    //2、创建一个私有的类对象
    private static A a=new A();
    //1.构造器私有
    private A(){
        
    }
    
    //3' 设计一个方法 返回类对象
    public A getA(){
        return a; //由于类对象 只加载一次 所以不论调用几次 都是一个对象
    }
}

懒汉式单例:在拿对象时，才创建对象

package com.cky.static_demo;

public class A {
    //2、创建一个类对象用来保存
    private static A a;
    //1.构造器私有
    private A(){

    }

    //3' 设计一个方法 返回类对象
    public A getA(){
        if(a==null){ //第一次
            a=new A();
        }
        return a; //由于类对象 只加载一次 所以不论调用几次 都是一个对象
    }
}

1.1 代码块

代码块分为静态代码块 和 实例代码块
代码块都在构造器之前运行。

1.1.1 静态代码块

写法:

static {}

特点：
由于类只会加载一次，所以类代码块也只会加载一次

作用:
用来完成对类的初始化 比如一些类变量 Socket 中就使用了静态代码块。

1.1.2 实例代码块

写法：
{}
特点：每次创建类对象时，都会被调用，且在构造器之前被调用

作用：
完成对类对象的初始化，例如对实例对象进行初始化赋值。

1.1.3 小例子

package com.cky.static_demo;

public class A {
    //静态代码块
    static {
        System.out.println("111");
    }
    //实例代码块
    {
        System.out.println("222");
    }
    
    //构造器
    public A(){
        System.out.println("333");
    }
}

package com.cky.static_demo;

public class Test {
    public static void main(String[] args) {
        A a = new A();
    }

}

结果：
111
222
333

2、继承

java是单继承，但是可以多层继承。

2.1 权限修饰符

2.2 方法重写

2.3 子类访问成员特点

2.4子类构造器的特点

在调用子类构造器时，都会先调用父类构造器(可以不写，会自动在上边加super()。
但是如果父类构造器 写了一个有参数构造器，
①要么在子类中显示写出调用的父类有参构造器
②要么，在父类中在添上一个无参构造器.因为如果自己写了一个有参构造器，就不会自动生成无参构造器了。

this(…) 可以被用来调用本类中的其他构造器(兄弟构造器），但是要注意：this(…)和super(…)不能写在一起，因为如果调用了兄弟构造器，则最底层的兄弟构造器是会调用父类构造器的。

3、多态

多态 分为 对象多态(比如一个人 可以是老师 也可以是母亲等)和行为多态(对于跑这个动作，对于学生来说 可能跑的快 但是老师 可能就会跑得慢)

对于属性变量 没有多态一说
对于行为 编译看左边，执行看右边。
对于属性 编译看左边，执行看左边。

多态有一个缺点：
即无法执行子类自己独有的方法，编译不同过，此时我们需要进行强转。

package com.cky.dt;

public class Test {
    public static void main(String[] args) {
        People p=new Student();
        p.run();//编译看左边，执行看右边
        System.out.println(p.name);//编译看左边，执行看左边
        People p1=new Teacher();
        p1.run();
        System.out.println(p1.name);
        go(p);
        go(p1);
    }
  //强转 因为不强转无法执行 子类独有的功能(由于编译看左边
    public static void go(People p){
        if(p instanceof Student){
            Student s=(Student)p;
            s.learn();
    }
      else {
            Teacher t=(Teacher) p;
            t.teach();
        }
    }
}
class People{
    public String name="cui";
    public void run(){
        System.out.println("people run");
    }
}
class Student extends People{
    public String name="kai";
    public void run(){
        System.out.println("Student run");
    }
    public void learn(){
        System.out.println("Student learn");
    }

}
class Teacher extends People{
    public String name="yue";
    public void run(){
        System.out.println("Teacher run");
    }
    public void teach(){
        System.out.println("Teacher teach");
    }

}

结果：
Student run
cui
Teacher run
cui
Student learn
Teacher teach

4、final、常量

4.1 final

final 可以用来修饰类，方法和属性

修饰类即表示该类不能被继承或者实现了。
修饰方法，证明该方法不能被重写。
修饰变量，证明该变量只能被赋予一次值，不能二次赋值。
变量:局部变量和全局变量 全局变量又分为静态成员变量和实例成员变量。

final 修饰基本数据类型，即该值不能被二次修改。
final修饰引用数据类型是指其地址不能被修改，比如数组，但是我们还是可以修改其值的。

4.2 常量

java中的常量通常被 static final修饰
比如 public static final String ADDRESS="上海";
在编译时 直接就被宏替换了 而不用通过ADDRESS 再去找到"上海这个值"，节约时间。

5 抽象类

5.1 概念

5.2 模板设计方法

6、接口

接口案例：

分析：
在这里我们首先可以先 定义一个学生类 用来保存学生的信息，之后定义一个班级类 用来保存所有学生信息以及进行一个操作，比如打印学生信息等等。
但是由于打印学生信息有两套方案，我们不能在一个里边完成，这时候就需要接口了，
定义一个接口类，里边有两个方法(抽象)，接着用两个类去实现它，已完成不同的操作，最后在班级类里实例化该接口，如果用方案一就实例化方案一的类，以此类推。

6.1 接口新方法

6.2 接口其他特性