面向对象编程（下）

以下为本人观看尚硅谷Java学习视频所整理的笔记

目录

static关键字

单例设计模式

main方法

代码块

final关键字

抽象类和抽象方法

创建抽象类的匿名对象

模板方法设计模式

接口(interface)

代理模式(Proxy)

内部类

---

static关键字

当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上的对象，只有通过new关键字才会产生出对象，这时系统才会分配内存空间给对象,其方法才可以供外部调用。我们有时候希望无论是否产生了对象或无论产生了多少对象的情况下，某些特定的数据在内存空间里只有一份，例如所有的中国人都有个国家名称，每一个中国人都共享这个国家名称，不必在每一个中国人的实例对象中都单独分配一个用于代表国家名称的变量。

static关键字的使用：

1、static：静态的

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

3、使用static修饰属性：静态变量（类变量）

• 属性按是否使用static修饰分为：静态属性vs非静态属性（实例变量）

        实例变量：

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

        静态变量：

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

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

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

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

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

        ④

能否调用	类变量	实例变量
类	yes	no
对象	yes	yes

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

4、使用static修饰方法：静态方法

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

        ②

能否调用	静态方法	非静态方法
类	yes	no
对象	yes	yes

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

        ④非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性

5、static注意点：

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

关于静态属性和静态方法的使用，大家都从生命周期的角度去理解

静态方法只能访问类中的静态变量

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

• 属性是可以被多个对象所共享的，不会随着对象的不同而不同
• 类中的常量常常声明为static的

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

• 操作静态属性的方法，通常设置为static的
• 工具类中的方法，习惯上声明为static的，比如：Math、Arrays、Collections

单例设计模式

单例(Singleton)设计模式：

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式就像是经典的棋谱，不同的棋局，我们用不同的棋谱，免去我们自己再思考和摸索。”套路”

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。

单例模式的优点：

由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决

单例设计模式的饿汉式实现：

class Bank{
    //1、私有化类的构造器
    private Bank(){}
    //2、内部创建类的对象，要求此对象也必须声明为静态的
    private static Bank instance = new Bank();
    //3、提供公共的静态方法，返回类的对象
    public static Bank getInstance(){
        return instance;
    }
}

单例设计模式的懒汉式实现：

class Bank {
    // 1、私有化类的构造器
    private Bank() {}
    // 2、声明当前类对象，没有初始化，此对象也必须声明为static的
    private static Bank instance = null;
    // 3、提供公共的静态方法，返回类的对象
    public static Bank getInstance() {
        if (instance == null)
            instance = new Bank();
        return instance;
    }
}

区分饿汉式和懒汉式：

饿汉式：

        好处 --> 线程安全

        坏处 --> 对象加载时间过长

懒汉式：

        好处 --> 延迟对象的创建

        坏处 --> 目前的写法是线程不安全的 --> 到多线程内容时，再修改

笔试中如果没说明写哪种单例设计模式，则两种方式都可以写，但如果要写懒汉式的写法注意需要写修改后的线程安全版本。

main方法

main()方法的使用说明：

1、main()方法作为程序的入口

2、main()方法也是一个普通的静态方法

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

        如何将控制台获取的数据传给形参：String[] args

        运行时：java 类名 参数列表

        例如：java Test "Tom" "Jerry" "123"

代码块

代码块（初始化块）

1、代码块的作用：用来初始化类、对象

2、代码块如果有修饰的话，只能使用static

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

4、静态代码块

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

5、非静态代码块

• 随着对象的创建而执行
• 每创建一个对象，就执行一次非静态代码块
• 作用：可以在创建对象时，对对象的属性等进行初始化
• 如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
• 非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法

对属性可以赋值的位置：

1、默认初始化

2、显示初始化

3、构造器中初始化

4、有了对象以后，可以通过“对象.属性”或“对象.方法”的方式进行赋值

5、在代码块中赋值

代码块比构造器先执行

代码块的执行顺序：由父及子，静态先行（先运行父类的代码块，静态的代码块都先执行）

final关键字

单词final的含义：最终的

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

2、final用来修饰一个类：此类不能被其他类所继承

比如：String类、System类、StringBuffer类

3、final用来修饰方法：表明此方法不可以被重写

比如：Object类中getClass()

4、final用来修饰变量：此时的“变量”就称为是一个常量

• final修饰属性：可以考虑赋值的位置有：显示初始化、代码块中初始化、构造器中初始化
• final修饰局部变量：尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。

5、static final用来修饰属性：全局常量

抽象类和抽象方法

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。

1、abstract：抽象的

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

3、abstract修饰类：抽象类

• 此类不能实例化
• 抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
• 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作

4、abstract修饰方法：抽象方法

• 抽象方法只有方法的声明，没有方法体
• 包含抽象方法的类一定是抽象类；反之，抽象类中可以没有抽象方法
• 若子类重写了父类中所有的抽象方法，此子类方可实例化；若子类没有重写父类中所有的抽象方法，则子类也是抽象类，需要用abstract修饰

abstract使用上的注意点：

1、abstract不能用来修饰：属性、构造器等结构

2、abstract不能用来修饰私有方法、静态方法、final方法、final类

创建抽象类的匿名对象

非匿名类的非匿名对象

Worker worker = new Worker();
method(worker);//非匿名类的非匿名对象

非匿名类的匿名对象

method(new Worker());//非匿名类的匿名对象

匿名子类的非匿名对象

//创建一个匿名子类的非匿名对象
//Person是一个抽象类，eat方法和breath方法是抽象方法
Person p = new Person(){
    @Override
    public void eat(){
        //方法体
    }
    @Override
    public void breath(){
        //方法体
    }
};
method(p);

匿名子类的匿名对象

//创建匿名子类的匿名对象
method(new Person(){
    @Override
    public void eat(){
        //方法体
    }
    @Override
    public void breath(){
        //方法体
    }
});

模板方法设计模式

模板方法设计模式(TemplateMethod)

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。

解决的问题:

• 当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。

• 换句话说，在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。但是某些部分易变，易变部分可以抽象出来，供不同子类实现。这就是一种模板模式。

接口(interface)

一方面，有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。

另一方面，有时必须从几个类中抽取出一些共同的行为特征，而它们之间又没有is-a的关系，仅仅是具有相同的行为特征而已。例如：鼠标、键盘、打印机、扫描仪、摄像头、充电器、MP3机、手机、数码相机、移动硬盘等都支持USB连接。

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要...则必须能...”的思想。继承是一个"是不是"的关系，而接口实现则是"能不能"的关系。

接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守。

定义Java类的语法格式：先写extends，后写implements

• class SubClass extends SuperClass implements InterfaceA{ }

一个类可以实现多个接口，接口也可以继承其它接口。

实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类。

接口的主要用途就是被实现类实现。(面向接口编程)

与继承关系类似，接口与实现类之间存在多态性

接口和类是并列关系，或者可以理解为一种特殊的类。从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义(JDK7.0及之前)，而没有变量和方法的实现。

举例：

实线箭头为继承关系，虚线箭头为接口功能

接口的使用：

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、接口与接口之间可以继承(extends)，而且可以多继承

8、接口的具体使用，体现多态性

9、接口实际上可以看做是一种规范

10、开发中，体会面向接口编程

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

Computer com = new Computer();

//1、创建接口非匿名实现类的非匿名对象
Flash flash =new Flash();
com.transferData(flash);

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

//3、创建接口的匿名实现类的非匿名对象
USB phone = new USB(){
    public void start(){
        //方法体
    }
    public void end(){
        //方法体
    }
};
com.transferData(phone);

//4、创建了接口的匿名实现类的匿名对象
com.transferData(new USB(){
    public void start(){
        //方法体
    }
    public void end(){
        //方法体
    }
});

Java8中接口的新特性：

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

1、接口中定义的静态(static)方法，只能由接口去调用

2、通过实现类的对象，可以调用接口中的默认(default)方法(非静态方法)

3、如果实现类重写了接口中的默认方法，调用时仍然调用的是重写以后的方法

4、如果子类(或实现类)继承的父亲和实现的接口中声明了同名同参数的方法，那么子类在没有重写此方法的情况下，默认调用的是父类中同名同参数的方法 --> 类优先原则

5、如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况下，报错 --> 接口冲突

6、在子类(或实现类)的方法中调用父类、接口中被重写的方法：

class SubClass extends SuperClass implements CompareA,CompareB{
    public void method3(){
        //方法体
    }
    public void myMethod(){
        method3();//调用自己定义的重写的方法
        super.method3();//调用的是父类中声明的方法
        //调用接口中的默认方法
        CompareA.super.method3();
        CompareB.super.method3();
    }
}

代理模式(Proxy)

代理模式体现了接口的应用

代理模式是Java开发中使用较多的一种设计模式。代理设计就是为其他对象提供一种代理以控制对这个对象的访问。

应用场景:

• 安全代理: 屏蔽对真实角色的直接访问。
• 远程代理: 通过代理类处理远程方法调用（RMI)
• 延迟加载: 先加载轻量级的代理对象，真正需要再加载真实对象

比如要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有100MB，在打开文件时，不可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用proxy来进行大图片的打开。

分类：

• 静态代理（静态定义代理类）
• 动态代理（动态生成代理类)
  • JDK自带的动态代理,需要反射等知识

代理举例：（本例为静态代理）

public class StaticProxyTest {
    public static void main(String[] args) {
        Proxy s = new Proxy(new RealStar());
        s.confer();
        s.signContract();
        s.sing();
        s.collectMoney();
    }
};
interface Star {
    void confer();// 面谈
    void signContract();// 签合同
    void sing();// 唱歌
    void collectMoney();// 收钱
}
// 被代理类
class RealStar implements Star {
    public void confer() {
    }
    public void signContract() {
    }
    public void sing() {
        System.out.println("明星：唱歌");
    }
    public void collectMoney() {
    }
};
// 代理类
class Proxy implements Star {
    private Star real;
    public Proxy(Star real) {
        this.real = real;
    }
    public void confer() {
        System.out.println("经纪人面谈");
    }
    public void signContract() {
        System.out.println("经纪人签合同");
    }
    public void sing() {
        real.sing();
    }
    public void collectMoney() {
        System.out.println("经纪人收钱");
    }
}
// 输出结果：
// 经纪人面谈
// 经纪人签合同
// 明星：唱歌  
// 经纪人收钱  

内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。

在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。

lnner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称。

• Inner class的名字不能与包含它的外部类类名相同

分类：

成员内部类（static成员内部类和非static成员内部类）

局部内部类（方法内、代码块内、构造器内，且不谈修饰符)、匿名内部类

成员内部类：

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

• 调用外部类的结构
• 可以被static修饰
• 可以被4种不同的权限修饰

另一方面，作为一个类

• 类内可以定义属性、方法、构造器等
• 可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承
• 可以被abstract修饰

关注的3个问题：

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

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

3、开发中局部内部类的使用

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

public class StaticProxyTest {
    public static void main(String[] args) {
        // 创建Dog实例(静态的成员内部类)
        Person.Dog dog = new Person.Dog();
        dog.show();
        // 创建Bird实例(非静态的成员内部类)
        // Person.Bird bird = new Person.Bird();错误的
        Person p = new Person();
        Person.Bird bird = p.new Bird();
        bird.sing();
    }
}
class Person {
    String name;
    int age;
    public void eat() {
        System.out.println("人，吃饭");
    }
    // 静态成员内部类
    static class Dog {
        String name;
        int age;
        public void show() {
            System.out.println("卡拉是条狗");
            // eat();不允许调用，因为该内部类是静态类
        }
    }
    // 非静态成员内部类
    class Bird {
        String name;
        public Bird() {
            // 方法体
        }
        public void sing() {
            System.out.println("我是一只小小鸟");
            eat();// 可以调用
            Person.this.eat();// 调用外部类的非静态属性，效果与上一行一致
        }
    }
}

输出：

卡拉是条狗

我是一只小小鸟

人，吃饭     

人，吃饭  

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

public class StaticProxyTest {
    public static void main(String[] args) {
        Person p = new Person();
        Person.Bird bird = p.new Bird();
        System.out.println();
        bird.display("黄鹂");
    }
}
class Person {
    String name = "小明";
    int age;
    // 非静态成员内部类
    class Bird {
        String name = "杜鹃";
        public Bird() {
            // 方法体
        }
        public void display(String name) {
            System.out.println(name);// 方法的形参
            System.out.println(this.name);// 内部类的属性
            System.err.println(Person.this.name);// 外部类的属性
        }
    }
}

输出：

黄鹂

杜鹃

小明

3、开发中局部内部类的使用

public class StaticProxyTest {
    public static void main(String[] args) {
    }
    //开发中很少见
    public void method(){
        //局部内部类
        class AA{
        }
    }
    //返回一个实现了Comparable接口的类的对象
    public Comparable getComparable(){
        //创建一个实现了Comparable接口的类:局部内部类
        //方式一：
        // class MyComparable implements Comparable{
        //     public int compareTo(Object o){
        //         return 0;
        //     }
        // }
        // return new MyComparable();
        //方式二：
        //创建了一个实现接口的匿名实现类的匿名对象
        return new Comparable() {
            public int compareTo(Object o){
                return 0;
            }
        };
    }
}

局部内部类使用时的一个注意点：

• 在局部内部类的方法中如果调用局部内部类所声明的方法中的局部变量，要求此局部变量声明为final的。
• JDK7及之前版本要求此局部变量显式地声明为final的
• JDK8及之后的版本可以省略final的声明