6.面向对象编程下

1.关键字：static

当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上的对象，只有通过new关键字才会产生出对象，这时系统才会分配内存空间给对象，其方法才可以供外部调用

1.static：静态的

2.static：可以用来修饰：属性、方法、代码块、内部类

3.修饰属性：静态变量

​ 属性：按是否使用static分静态属性非静态属性（实例变量）

​ 实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性，当修改其中一个对象的非静态属性时，不会导致其他属性中的同样的属性值的修改

​ 静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态对象时，是修改过了的

​ static修饰属性的说明：

①静态变量随着类的加载而加载，可以通过“类.静态变量”的方式调用

②静态变量的加载早于对象的创建

③由于类只会加载一次，则静态变量在内存中也只会存在一份，存在方法区的静态域中

④ 类变量 实例变量

类 √ ×

对象 √ √

静态属性举例：System.out;Math.PI等

4.修饰方法：静态方法

①随着类的加载而加载，可以用过“类.静态方法”调用

② 静态方法 非静态方法

类 √ ×

对象 √ √

③静态方法中只能调用静态的方法或属性

​ 非静态方法中既能调用非静态方法或属性也可以调用静态方法或属性

5.static注意点

​ ①在静态的方法内，不能使用this关键字、super关键字

​ ②关于静态属性和静态方法的使用都从生命周期的角度理解

6.开发中，如何确定一个属性是否要声明为static的？

​ >属性是可以被多个对象所共享的，不会随着对象的不同而不同

​ 开发中，如何确定一个方法是否要声明为static的？

​ >操作静态属性的方法，通常设置为static的

​ >工具类中的方法，习惯性上声明为static的，如Math、Arrays、Collections

单例（Singleton）模式

懒汉式：什么时候用什么时候造

/**
 * @@author:zsb
 * {@code @create:} 2022-06-21 18:16
 */
public class SingletonTest2 {
    public static void main(String[] args) {
        Order o1=Order.getInstance();
        Order o2=Order.getInstance();
        System.out.println(o1==o2);
    }
}

//懒汉式
class Order{
    //1.私有化类的构造器
    private Order(){

    }
    //2.声明当前类对象，没有初始化
    private static Order instance =null;
    //3.声明public、static的返回当前类对象的方法
    public static Order getInstance(){
        if(instance==null){
            instance=new Order();
        }
        return instance;
    }
}

饿汉式：先造出来对，等你用

/**
 * @@author:zsb
 * {@code @create:} 2022-06-21 18:10
 */
public class SingletonTest {
    public static void main(String[] args) {
        Bank bank1=Bank.getInstance();
        Bank bank2=Bank.getInstance();
        System.out.println(bank1==bank2);
    }
}

//饿汉式
class Bank{
    //1.私有化类的构造器
    private Bank(){

    }
    //2，内部创建类的对象
    //4.要求此对象也必须声明为静态
    private static Bank instance=new Bank();
    //3.提供公共的静态方法，返回类的对象
    public static Bank getInstance() {
        return instance;
    }
    public void setInstance(Bank instance) {
        Bank.instance = instance;
    }
}

区分：

​ 饿汉式：坏处：一开始造的对象可能没用上

​ 好处：线程安全

​ 懒汉式：好处：延迟对象的创建

​ 坏处：线程不安全

2.main方法

1.main（）方法作为程序入口

2.main（）方法也是一个普通的静态方法

3.main（）方法也可以作为我们与控制台交互的方式（之前使用Scanner）

3.（初始化块）代码块

由父及子，静态先行

1.作用：用来初始化类、对象

2.代码块如果有修饰只能是static

3.分类：静态代码块、非静态代码块

4.静态代码块

​ >内部可以有输出语句

​ >随着类的加载而执行，只执行一次

​ >如果定义了多个静态代码块，则按照声明的先后顺序执行

​ >静态代码块内只能调用静态属性或方法、不能调用非静态的结构

5.非静态代码块

​ >内部可以有输出语句

​ >随着对象的创建而执行

​ >每创建一个对象，就执行一次非静态代码块

​ >作用：可以在创建对象时，对对象的属性等进行初始化

​ >如果定义了多个非静态代码块，则按照声明的先后顺序执行

​ >非静态代码块内可以调用静态属性或方法、也可以调用非静态的属性或方法

对属性可以赋值的位置：

①默认初始化

②显式初始化

③构造器初始化

④有了对象以后，可以对象.XXX的方法

⑤在代码块中赋值

package daimakuai;

/**
 * @@author:zsb
 * {@code @create:} 2022-06-21 22:00
 */
public class BlockTest {
    public static void main(String[] args) {
        String desc = Person.desc;
        new Person();
        new Person();
    }
}

class Person{
    //属性
    String name;
    int age;
    static String desc="我是一个人";
    //构造器
    public Person(){

    }
    public Person(String name, int agec) {
        this.name = name;
        this.age = age;
    }
    //代码块
    static {
        System.out.println("aaa");
    }
    {
        System.out.println("bbb");
    }
    //方法
    public void eat(){
        System.out.println("chifan");
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

4.关键字：final

1.final可以用来修饰的结构：类、方法、变量

2.final 用来修饰类（太监类）：此类不能被其他类继承

​ 比如：String 、Sysytem 、StringBuffer类

3.final用来修饰方法：方法不能被重写

​ 比如：Object类中getClass（）

4.final用来修饰变量：变量改变为常量

①final修饰属性：可以考虑赋值的位置：显示初始化、代码块中初始化、构造器中初始化

②final修饰局部变量：

​ 尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量赋予一个实参，一旦执行以后，就只能在方法体内使用此形参，但不能重新赋值。

static final用来修饰属性：全局常量（常量名全大写）

5.抽象类与抽象方法

abstract（抽象的）关键字的使用

​ 1.abstract可以用来修饰的结构：方法、类

​ 2.abstract修饰类：抽象类

​ >此类不能实例化

​ >抽象类中一定有构造器，便于子类对象实例化时调用

​ >开发中，都会提供抽象类的子类，让子类对象实例化，完成相关操作

​ 3.abstract修饰方法：

​ >抽象方法只有方法的声明，没有方法体

​ >包含抽象方法的类一定是一个抽象类

​ >若子类重写了父类中所有的抽象方法后，此子类方可实例化

​ 否则此子类也是抽象类，需要abstract修饰

​ 4.注意点：

​ ①不能用来修饰：属性、构造器等

​ ②不能用来修饰私有方法、静态方法、final的方法

6.接口（interface）

接口的使用：

1.接口使用interface来定义

2.Java中，接口和类时并列的两个结构

3.如何定义接口：定义接口中的成员

​ JDK7以前：只能够定义全局常量、抽象方法

​ >全局常量：public static final的（书写可以省略）

​ >抽象方法：public abstract的

​ JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法

4.接口中不能定义构造器，意味着接口不可以实例化

5.Java开发中，接口都通过让类去实现（implements）的方式来使用

​ 如果实现类覆盖了接口中的所有抽象方法，则此实现类可以实例化，否则不可以实例化，仍然为抽象类

6.Java类可以实现多个接口——>弥补了Java单继承性的局限性

格式：

class AA extends BB implements CC,DD,EE

7.接口与接口之间可以多继承、抽象类可以继承接口

8.接口的使用体现了多态性

9.接口，实际上可以看作是一种规范

抽象类和接口共同点和区别

相同点：不能实例化、都可以被继承

不同点：抽象类：有构造器。接口：不能声明构造器

多继承vs单继承

public class InterfaceTest {
    public static void main(String[] args) {
        System.out.println(Flyface.MAX_SPEED);
        System.out.println(Flyface.MIN_SPEED);
    }
}

interface Flyface{
    //全局常量
    public static final int MAX_SPEED=7900;
    int MIN_SPEED=1;
    //抽象方法
    public abstract void fly();
    void stop();
}
interface Attackable{
    void attack();
}
class Plane implements Flyface{

    @Override
    public void fly() {
        System.out.println("引擎启动");
    }

    @Override
    public void stop() {
        System.out.println("引擎熄灭");

    }
}
class Bullet implements Flyface,Attackable,CC{

    @Override
    public void fly() {

    }

    @Override
    public void stop() {

    }

    @Override
    public void attack() {

    }

    @Override
    public void mathod1() {
        
    }

    @Override
    public void mathod2() {

    }
}
//
interface AA{
    void mathod1();
}
interface BB{
    void mathod2();
}
interface CC extends AA,BB{

}

public class UsbTest {
    public static void main(String[] args) {
        Computer com=new Computer();
        //1.创建了接口的非匿名实现类的非匿名对象
        Flash  flash=new Flash();
        com.transferData(flash);
        //2.创建了接口的非匿名实现类的匿名对象
        com.transferData(new Flash());
        //3.创建了接口的匿名实现类的非匿名对象
        USB phone=new USB() {
            @Override
            public void start() {
                System.out.println("手机开始工作");
            }

            @Override
            public void stop() {
                System.out.println("手机结束工作");
            }
        };
        com.transferData(phone);
        //4.创建了接口的匿名实现类的匿名对象
        com.transferData(new USB() {
            @Override
            public void start() {
                System.out.println("MP3开始工作");
            }

            @Override
            public void stop() {
                System.out.println("MP3结束工作");
            }
        });
    }
}

class Computer{
    public void transferData(USB usb){//USB usb=new Flash();
        usb.start();
        System.out.println("具体传输数据细节");
        usb.stop();
    }
}

interface USB{
    void start();
    void stop();
}
class Flash implements USB{

    @Override
    public void start() {
        System.out.println("U盘开始工作");
    }

    @Override
    public void stop() {
        System.out.println("U盘结束工作");
    }
}

7.内部类

1，Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类

2.内部类分：成员内部类vs局部内部类（方法内、代码块内、构造器内）

3.成员内部类：

​ 一方面，作为外部类的成员：

​ >调用外部类的结构

​ >可以被static修饰

​ >可以被四种不同权限修饰符的修饰

​ 一方面，作为一个类：

​ >类内可以定义属性、方法、构造器等

​ >可以被final修饰，表示此类不能被继承

​ >可以被abstract修饰

4.关注如下三个问题

​ 1.如何实例化成员内部类

​ 2.如何在成员内部类中区分调用外部类的结构

​ 3.开发中局部内部类的使用

class Person{
    //成员内部类
    class BB{}
    static class CC{}

    public void method(){
        //局部内部类
        class AA{}
    }
    {
        //局部内部类
        class DD{}
    }
    public Person(){
        //局部内部类
        class EE{}
    }

}