abstract

抽象类

abstract 修饰的类称为抽象类
抽象类意为不完整的类、不够具体的类。抽象类对象无法独立存在，即不能new对象

声明abstract类的举例：

public abstract class Person{
    //姓名
    private String name;
    //年龄
    private int age;
    
    public void eat(){
        System.out.println("Person Eat ...");
    }
}

作用：

可以被子类继承，提供共性属性和方法
可声明为引用，更自然的使用多态

抽象类的多态（与普通子父类无异）：


public class MyTest{
    public static void main(){
        Person p1 = new Student();
        Person p2 = new Teacher();
    }

}

abstract class Person{
    //姓名
    private String name;
    //年龄
    private int age;
    
    public void eat(){
        System.out.println("Person Eat ...");
    }
}
//使用extends继承父类
class Student extends Person{}
class Teacher extends Person{}

抽象方法

abstract 修饰的方法即为抽象方法
抽象方法没有方法体，当子类继承时，要么选择重写抽象方法，要么将子类也设置为抽象类。

抽象方法的使用：

//定义抽象类
abstract class MyTest{
    //定义抽象方法
    public abstract void test(){}
} 

//继承抽象类的方式1：
//重写抽象方法
class SubMyTest1 extends MyTest{
    //重写抽象方法
    @Override
    public void test(){
        System.out.println("SubMyTest1");
    }
}
//继承抽象类的方式2：
//将子类改为抽象类
abstract class SubMyTest2 extends MyTest{}

总结

abstract 修饰的类不可以new对象，但是可以被继承、声明和引用
abstract 修饰的方法，只有方法声明，但是没有方法体，需要在抽象类中
抽象类不一定有抽象方法，但是由抽象方法的类一定是抽象类（接口 interface 中也有抽象方法）
不能用abstract修饰变量、代码块、构造器
不能用abstract修饰私有方法、静态方法、final的方法、final的类。

Static

静态的概念

静态可以修饰属性和方法

被static修饰的属性称为静态属性，被static修饰的方法称为静态方法。

静态成员是全类中所有对象共享的成员，在全类中只有一份，不因创建多个对象而产生多分。

在不创建对象的情况下，可以通过类名直接访问：

类名.成员
类名.变量

静态属性、方法

静态属性可以被类和实例对象访问
静态方法只可以访问静态属性和静态方法

静态属性和静态方法的声明：

public class Person{
    //声明静态属性
    public static String name;
    //声明静态方法
    public static void test(){};
}

关于静态的注意事项：

静态方法允许直接调用静态成员；
静态方法不能直接访问非静态成员（如果要访问属性需要将属性声明static设置为静态）
静态方法中不允许使用this和super关键字；

动态代码块和静态代码块

动态代码块

定义在类中，与属性和方法同一级

class Person{
    //动态代码块
    {
    
    }

}

动态代码块在创建对象时，创建一次，执行一次。

实例变量赋值顺序：

默认赋值
显示赋值/代码块赋值（谁在前谁先赋值）
构造器赋值
通过调用 对象.属性 或 对象.方法 赋值

静态代码块

定义在类中，与属性和方法处于同一级

class Person{
  static{
  
    }
}

类加载时，静态代码块执行（仅一次）

执行顺序：

静态属性默认赋值
静态属性显示赋值/静态代码块赋值
构造器赋值
通过对象或者类名调用赋值

作用：可以为静态属性赋值，或必要的初始行为

public class Person{

    public static String name;
    static {
        name = "XZRO";
    }
    //构造器
    public Person(String name){
        Person.name = name;
    }
}

单例设计模式

是什么？

一个类的对象实例只有一个

如何设计：

首先设计一个 private 权限的构造器防止外部使用new操作进行创建新的对象
调用类中的静态方法返回在类内部创建的对象
静态方法只能访问类中的静态成员变量，所以我们需要将类内部创建该对象的变量声明为静态 static

饿汉式

public class MyTest{
    private Mytest(){}
    private static MyTest instance = new MyTest();
    public static MyTest getInstance(){
        return instamce;
    }
}

该方式线程安全

懒汉式

public class MyTest{
    private Mytest(){}
    private static MyTest instance;
    public static MyTest getInstance(){
        if(instance == null){
            instance = new MyTest();
        }
        return instance;
    }
}

存在线程安全问题，但避免了不必要的资源占用

final

修饰属性，变为常量，一旦赋值不可修改
若修饰的是引用类型，只是地址不可变
修饰方法，不可被重写
修饰类表示这个类不能被继承，没有子类

注意final不可以在以下情况修饰：

abstract
代码块
构造器

菜单

Java基础-修饰符：abstract、static、final