面向对象_下

面向对象_3

一、static关键字的使用

static：静态的
static可以用来修饰：属性、方法、代码块、内部类
修饰属性：静态变量（或类变量）

3.1 属性，按是否使用static修饰分为静态属性和非静态属性（实例变量）

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

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

3.2 static修饰属性的其他说明：

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

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

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

④ 类变量实例变量

类 yes no

对象 yes yes
修饰方法：静态方法

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

② 静态方法非静态方法

类 yes no

对象 yes yes

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

非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
注意点：

5.1 在静态方法中，不能使用 this、super 关键字

5.2 关于静态属性和静态方法的使用，都从生命周期去理解
在开发中，如何确定一个属性是否要声明为 static ？

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

>类中的常量也常常声明为 static

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

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

>工具类中的方法习惯上声明为 static 的（如：Math、Arrays、Collections等）

二、单例设计模式

2-1、定义

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例

2-2、如何实现？

饿汉式 vs 懒汉式

饿汉式：

/*
单例模式的 饿汉式 实现
 */
public class SingletonTest1 {
    public static void main(String[] args) {
//        Bank bank1 = new Bank();
//        Bank bank2 = new Bank();

        Bank bank1 = Bank.getBank();
        Bank bank2 = Bank.getBank();

        System.out.println(bank1 == bank2);
    }
}

//饿汉式
class Bank{

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

    }

    //2.内部创建类的对象
    //4.要求此对象也要声明为静态的
    private static Bank bank = new Bank();

    //3.提供公共的静态方法，返回类的对象
    public static Bank getBank(){
        return bank;
    }

}

懒汉式：

/*
单例模式的 懒汉式 实现
 */
public class SingletonTest2 {
    public static void main(String[] args) {
        Order order1 = Order.getInstance();
        Order order2 = Order.getInstance();

        System.out.println(order1 == order2);
    }
}

class Order{

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

    }

    //2.声明当前类的对象，没有初始化
    //4.此对象也必须声明为 static 的
    private static Order instance = null;

    //3.声明 public、static 的返回当前类对象的方法
    public static Order getInstance(){
        if (instance == null){
            instance = new Order();
        }
        return instance;
    }
}

2-3、区分饿汉式和懒汉式

饿汉式：
坏处：对象加载时间过长
好处：线程安全

懒汉式：
好处：延迟对象的创建
目前的写法坏处：线程不安全

三、代码块（或初始化块）

3-1、代码块的作用

用来初始化类、对象

3-2、代码块的修饰

如果有修饰，只能用static

3-3、分类

静态代码块：
>内部可以有输出语句
>随着类的加载而执行，而且只执行一次
>作用：初始化类的信息
>如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
>静态代码块的执行优先于非静态代码块
>静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构

非静态代码块：
>内部可以有输出语句
>随着对象的创建而执行
>每创建一个对象就执行一次非静态代码块
>作用：可以在创建对象时，对对象的属性等进行初始化
>非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法

四、final关键字

final可以用来修饰的结构：类、方法、变量
final用来修饰一个类：此类不能被其它类所继承。

比如：String类、System类、StringBuffer类等
final用来修饰方法：表明此方法不可被重写

比如：Object类中的getClass()
final用来修饰变量：此时的“变量”就称为是一个常量
1. 修饰属性：可以考虑赋值的位置有：显式初始化、代码块中赋值、构造器中初始化
2. 修饰局部变量：尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能重新赋值。
static final：用来修饰属性、方法属性：全局常量

五、抽象类与抽象方法

5-1、abstract关键字的使用

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

5-2、abstract修饰类：抽象类

此类不能实例化
抽象类中一定有构造器，便于子类的实例化
开发中，都会提供抽象类的子类，让子类对象实例化，完成相关操作

5-3、abstract修饰方法：抽象方法

抽象方法只有方法的声明，没有方法体
包含抽象方法的类一定是抽象类。反之，抽象类中可以没有抽象方法。
若子类重写了父类中的所有抽象方法后，此子类可实例化

若子类没有重写父类中的所有抽象方法，则此子类也是一个抽象类

5-4、abstract使用注意点

abstract不能用来修饰：属性、构造器等结构
abstract不能用来修饰私有方法、静态方法、final的方法、final的类

★六、接口（interface）

6-1、接口的使用

使用interface来定义
Java中，接口和类时并列的两个结构
如何定义接口：定义接口中的成员
1. JDK7及以前：只能定义全局常量和抽象方法
  
  >全局常量：public static final，书写时可以省略
  
  >抽象方法：public abstract
2. （下面细🔒）JDK8及以后：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法
接口中不能定义构造器！说明接口不能实例化
Java开发中，接口通过让类去实现（implements）的方式来使用。

如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化

如果实现类没有覆盖接口中的所有抽象方法，则此实现类仍为一个抽象类

java类可以实现多个接口 ---> 弥补了java类的单继承性的局限性

格式：

class AA extends BB implements CC, DD{
    //类AA继承于BB，并实现了接口CC和DD
}

接口与接口之间可以继承，且可以多继承

接口的具体使用，体现了多态性
接口，实际上可以看做是一种规范
开发中，体会面向接口编程

测试代码

public class USBTest {
    public static void main(String[] args) {
        Computer com = new Computer();
        
        //1.创建了接口的非匿名实现类的非匿名对象
        Flash flash = new Flash();
        Printer printer = new Printer();

        //2.创建了接口的非匿名实现类的匿名对象
        com.transferData(new Printer());

        //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.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盘结束工作");
    }
}

class Printer implements USB{

    @Override
    public void start() {
        System.out.println("打印机开始工作！");
    }

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

面试题：抽象类与接口有哪些异同？

6-2、JDK 1.8 中接口的新特性

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

接口中定义的静态方法，只能通过接口来调用
通过实现类的对象，可以调用接口中的默认方法
如果实现类重写了接口中默认的方法，调用时，仍然调用的是重写后的方法
如果子类（或实现类）继承的父类和实现的接口中声明了同名同参数的方法，那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数方法 ---> 类优先原则
如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况下，报错！ ---> 接口冲突

这就需要我们必须在实现类中重写此方法

如何在子类（实现类）的方法中调用父类、接口中定义的方法

class Subclass extends SuperClass implements CompareA, CompareB{

    @Override
    public void method3() {
        System.out.println("override");
    }

    //5.如何在子类（实现类）的方法中调用父类、接口中定义的方法
    public void myMethod(){
        
        method3();//调用自己定义的重写过的方法
        super.method3();//调用父类中声明的方法

        //调用接口中的默认方法
        CompareA.super.method3();
        CompareB.super.method3();
    }
}

七、内部类

Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类
内部类的分类：成员内部类（静态、非静态） vs 局部内部类（方法内、代码块内、构造器内）
成员内部类：
1. 作为外部类的成员
  1. 调用外部类的结构（属性、方法）
  2. 可以被static修饰
  3. 可以被四种不同的权限修饰
2. 作为一个类
  1. 类内可以定义属性、方法、构造器等
  2. 可以被final修饰
  3. 可以被abstract修饰

关注如下的3个问题

如何实例化成员内部类的对象

//创建Dog实例（静态的成员内部类）：
Person.Dog dog = new Person.Dog();
dog.show();

//创建Bird实例（非静态的成员内部类）：
Person person = new Person();
Person.Bird bird = person.new Bird();
bird.sing();

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

public void display(String name){

    System.out.println(name);//方法的形参
    System.out.println(this.name);//内部类的name
    System.out.println(Person.this.name);//外部类的name
}

开发中局部内部类的使用

//开发中常见的：
//返回一个实现了Comparable接口的类的对象
    //方式一：
public Comparable getComparable(){

    //创建一个实现Comparable接口的类：局部内部类
    class MyComparable implements Comparable{

        @Override
        public int compareTo(Object o) {
            return 0;
        }
    }

    return new MyComparable();
}

    //方式二：
public Comparable getComparable2(){

    return new Comparable() {

        @Override
        public int compareTo(Object o) {
            return 0;
        }

    };

}

posted @ 2021-10-15 00:06 叁玖贰拾柒阅读(30) 评论(0) 收藏举报

刷新页面返回顶部

共勉至上

从零开始跟我学