DAY11、面向对象进阶（static、单例、代码块、继承）

面向对象进阶（一）

（一）静态关键字：static

1static的作用、修饰成员变量的用法

1.1static关键字的作用：

static是静态的意思，可以修饰成员变量，表示该成员变量只在内存中只存储一份，可以被共享访问、修改。

public class User { 
    // 成员变量
    public static int onlineNumber= 161;
    private String name; 
    private int age;
    …
}

2.成员变量可以分为2类

2.1静态成员变量（有static修饰，属于类，内存中加载一次）:

常表示如在线人数信息、等需要被共享的信息，可以被共享访问。

2.2实例成员变量（无static修饰，存在于每个对象中）：

常表示姓名name、年龄age、等属于每个对象的信息。

注意：实例成员变量属于每个对象，且每个对象信息不同时（name,age,…等）

3.static修饰成员变量的内存原理

4.static修饰成员方法的基本用法

public void run(){
    System.out.println(name +"正在好好学习，天天向上~~");
}

 public static int getMax(int a , int b){
 return a > b ? a : b; 
 }

分为两类：

4.1静态成员方法（有static修饰，属于类），建议用类名访问，也可以用对象访问。

访问格式：类名.静态成员方法。

​ 对象.静态成员方法。（不推荐）

4.2实例成员方法（无static修饰，属于对象），只能用对象触发访问。

访问格式：对象.实例成员方法

**注意：使用场景：

表示对象自己的行为的，且方法中需要访问实例成员的，则该方法必须申明成实例方法。

如果该方法是以执行一个共用功能为目的，则可以申明成静态方法。

5.static修饰成员方法的内存原理

6.static实际应用案例：定义工具类

6.1工具类：

工具类中定义的都是一些静态方法，每个方法都是以完成一个共用的功能为目的。

6.2案例导学：

l在企业的管理系统中，通常需要在一个系统的很多业务处使用验证码进行防刷新等安全控制**。**

6.3现状问题分析：

l如果登录和注册等多处地方都存在验证码逻辑，就会导致同一个功能多处开发，会出现代码重复度过高。

6.4工具类的好处

一是调用方便，二是提高了代码复用（一次编写，处处可用）

注意：为什么工具类中的方法不用实例方法做？

实例方法需要创建对象调用，此时用对象只是为了调用方法，这样只会浪费内存。

6.5工具类的定义注意

建议将工具类的构造器进行私有，工具类无需创建对象。里面都是静态方法，直接用类名访问即可。

7.static的注意事项

static访问注意事项

静态方法只能访问静态的成员，不可以直接访问实例成员。

实例方法可以访问静态的成员，也可以访问实例成员。

静态方法中是不可以出现this关键字的。

（二）、stati应用知识：代码块

1.代码块的分类、作用

1.1代码块概述

代码块是类的5大成分之一（成员变量、构造器，方法，代码块，内部类），定义在类中方法外。

在Java类下，使用 { } 括起来的代码被称为代码块 。

1.2代码块分为

静态代码块:

1. 格式：static{}
2. 特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发、只执行一次
3. 使用场景：在类加载的时候做一些静态数据初始化的操作，以便后续使用。

构造代码块（了解，用的少）：

1. 格式：{}
2. 特点：每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行前执行
3. 使用场景：初始化实例资源。

2.1静态代码块的应用案例需求：

在启动游戏房间的时候，应该提前准备好54张牌，后续才可以直接使用这些牌数据。

分析：

①该房间只需要一副牌。

②定义一个静态的ArrayList集合存储54张牌对象，静态的集合只会加载一份。

③在启动游戏房间前，应该将54张牌初始化好

④当系统启动的同时需要准备好54张牌数据，此时可以用静态代码块完成。

package com.itheima.d5_static_codeblock;

import java.util.ArrayList;

public class StaticCodeTest3 {
    /**
       模拟初始化牌操作
         点数: "3","4","5","6","7","8","9","10","J","Q","K","A","2"
         花色: "♠", "♥", "♣", "♦"
       1、准备一个容器，存储54张牌对象，这个容器建议使用静态的集合。静态的集合只加载一次。
     */
    // int age = 12;
    public static ArrayList<String> cards = new ArrayList<>();

    /**
       2、在游戏启动之前需要准备好54张牌放进去，使用静态代码块进行初始化
     */
    static{
        // 3、加载54张牌进去。
        // 4、准备4种花色：类型确定，个数确定了
        String[] colors = {"♠", "♥", "♣", "♦"};
        // 5、定义点数
        String[] sizes = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        // 6、先遍历点数、再组合花色
        for (int i = 0; i < sizes.length; i++) {
            // sizes[i]
            for (int j = 0; j < colors.length; j++) {
                cards.add(sizes[i] + colors[j]);
            }
        }
        // 7、添加大小王
        cards.add("小🃏");
        cards.add("大🃏");
    }

    public static void main(String[] args) {
        System.out.println("新牌：" +  cards);
    }
}

总结：静态代码块的作用

如果要在启动系统时对数据进行初始化。

建议使用静态代码块完成数据的初始化操作，代码优雅。

（三）static应用知识：单例设计模式

3.1设计模式、单例模式介绍、饿汉单例模式

3.1.1什么是设计模式（Design pattern）

（1）开发中经常遇到一些问题，一个问题通常有n种解法的，但其中肯定有一种解法是最优的，这个最优的解法被人总结出来了，称之为设计模式。

（2）设计模式有20多种，对应20多种软件开发中会遇到的问题，学设计模式主要是学2点：

第一：这种模式用来解决什么问题。

第二：遇到这种问题了，该模式是怎么写的，他是如何解决这个问题的。

3.1.2单例模式

（1）可以保证系统中，应用该模式的这个类永远只有一个实例，即一个类永远只能创建一个对象。

（2）例如任务管理器对象我们只需要一个就可以解决问题了，这样可以节省内存空间。

单例分为懒汉单例、饿汉单例等

3.1.3饿汉单例设计模式

在用类获取对象的时候，对象已经提前为你创建好了。

设计步骤：

定义一个类，把构造器私有。

定义一个静态变量存储一个对象。

代码如下：（单例类）

package com.itheima.d6_singleinstance;

/**
    目标：学会使用恶汉单例模式设计单例类
 */
public class SingleInstance1 {
    /**
       static修饰的成员变量，静态成员变量，加载一次，只有一份
     */
    // public static int onLineNumber = 21;
    public static SingleInstance1 instance = new SingleInstance1();

    /**
        1、必须私有构造器：私有构造器对外不能被访问。
     */
    private SingleInstance1(){
    }


}

（测试类）：

package com.itheima.d6_singleinstance;

public class Test {
    public static void main(String[] args) {
//        SingleInstance1 s1 = new SingleInstance1();
//        SingleInstance1 s2 = new SingleInstance1();
//        SingleInstance1 s3 = new SingleInstance1();

        SingleInstance1 s1 = SingleInstance1.instance;
        SingleInstance1 s2 = SingleInstance1.instance;
        SingleInstance1 s3 = SingleInstance1.instance;
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s1 == s2);
    }
}

输出结果：

3.2懒汉单例模式

懒汉单例设计模式

在真正需要该对象的时候，才去创建一个对象**(延迟加载对象)。**

设计步骤：

定义一个类，把构造器私有。

定义一个静态变量存储一个对象。

提供一个返回单例对象的方法

代码如下（懒汉单例：）

package com.itheima.d6_singleinstance;

/**
    目标：设计懒汉单例
 */
public class SingleInstance2 {
    /**
       2、定义一个静态的成员变量用于存储一个对象，一开始不要初始化对象，因为人家是懒汉
     */
    private static SingleInstance2 instance;

    /**
       1、私有构造器啊
     */
    private SingleInstance2(){
    }

    /**
      3、提供一个方法暴露，真正调用这个方法的时候才创建一个单例对象
     */
    public static SingleInstance2 getInstance(){
        if(instance == null){
            // 第一次来拿对象，为他做一个对象
            instance = new SingleInstance2();
        }
        return instance;
    }
}

测试类：

package com.itheima.d6_singleinstance;

public class Test2 {
    public static void main(String[] args) {
        // 得到一个对象
        SingleInstance2 s1 = SingleInstance2.getInstance();
        SingleInstance2 s2 = SingleInstance2.getInstance();

        System.out.println(s1 == s2);
    }
}

输出结果：true。

（四）面向对象三大特征之二：继承

4.1继承概述、使用继承的好处

4.1.1什么是继承？

Java中提供一个关键字extends，用这个关键字，我们可以让一个类和另一个类建立起父子关系。

public class Student extends People {}

Student称为子类（派生类），People称为父类(基类 或超类)。

4.1.2使用继承的好处

当子类继承父类后，就可以直接使用父类公共的属性和方法了。因此，用好这个技术可以很好的我们提高代码的复用性

案例练习：请阅读以下代码存在的问题，并使用继承这个技术进行优化

解决方案：把相同的属性和行为抽离出来，可以降低重复代码的书写，抽取出来放到何处呢？

总结：

1.什么是继承、继承的好处

继承就是java允许我们用extends关键字，让一个类和另一个类建立起一种父子关系。

提高代码复用性，减少代码冗余，增强类的功能扩展性。

2.继承的格式

子类 extends父类****

3.继承后子类的特点？

子类 继承父类，子类可以得到父类的属性和行为，子类可以使用。

Java中子类更强大

4.2继承的设计规范、内存运行原理

4.2.1继承设计规范：

子类们相同特征（共性属性，共性方法）放在父类中定义，子类独有的的属性和行为应该定义在子类自己里面。

为什么？

如果子类的独有属性、行为定义在父类中，会导致其它子类也会得到这些属性和行为，这不符合面向对象逻辑。

4.2.2案例：继承的设计规范

需求：
在教学资源管理系统中，存在学生、老师角色会进入系统。

分析：

学生信息和行为（名称，年龄，所在班级，查看课表，填写听课反馈）

老师信息和行为（名称，年龄，部门名称，查看课表，发布问题）

定义角色类作为父类包含属性（名称，年龄），行为（查看课表）

定义子类：学生类包含属性（所在班级），行为（填写听课反馈）

定义子类：老师类包含属性（部门名称），行为（发布问题）

代码如下：角色类（父类）：

package com.itheima.d8_extends_test;

/**
   角色类 父类
 */
public class Role {
    private String name;
    private int age;

    /**
        共同行为
     */
    public void queryCourse(){
        System.out.println(name + "开始查看课程信息~~");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

学生类（子类）：

package com.itheima.d8_extends_test;

public class Student extends Role{
    // 独有属性
    private String className;

    // 独有行为
    public void writeInfo(){
        System.out.println(getName()
                + "说：今天学习感觉美美的,老师也是666~~~");
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }
}

测试类：

package com.itheima.d8_extends_test;

public class Test {
    public static void main(String[] args) {
        // 1、创建学生对象
        Student s = new Student();
        s.setName("张松松"); // 父类的
        s.setAge(25); // 父类的
        s.setClassName("Java999期"); // 子类的
        System.out.println(s.getName());
        System.out.println(s.getAge());
        System.out.println(s.getClassName());
        s.queryCourse(); // 父类的
        s.writeInfo(); // 子类的

    }
}

内存图：

4.3继承的特点

4.3.1继承的特点

①子类可以继承父类的属性和行为，但是子类不能继承父类的构造器。

②Java是单继承模式：一个类只能继承一个直接父类。

③Java不支持多继承、但是支持多层继承。

④Java中所有的类都是Object类的子类。

4.3.2子类是否可以继承父类的构造器？

不可以的，子类有自己的构造器，父类构造器用于初始化父类对象。

4.3.3子类是否可以继承父类的私有成员？

可以的，只是不能直接访问。

4.3.4子类是否可以继承父类的静态成员？

有争议的知识点。（我认为子类是可以继承私有的属性和行为）

子类可以直接使用父类的静态成员（共享）

但个人认为：子类不能继承父类的静态成员。（共享并非继承）代码演示如下:

package com.itheima.d9_extends_feature;

public class ExtendsDemo {
    public static void main(String[] args) {
        // 子类是否可以继承私有的属性和行为呢？我认为可以的
        Student s = new Student();
//        System.out.println(s.age);
//        s.run();
        Student.inAddr();
        System.out.println(Student.OnLineNumber);
    }
}

class C extends A{

}

class A{

}

class B{

}

class People{
    private int age = 21;
    private void run(){
        System.out.println("人跑的很快~~");
    }
    public static int OnLineNumber = 12;
    public static void inAddr(){
        System.out.println("我在快乐的学习~~");
    }
}

class Student extends People{

}

4.3.5注意：Java只支持单继承，不支持多继承。

单继承：子类只能继承一个直接父类

​ 不支持多继承：子类不能同时继承多个父类

​ Java支持多层继承**

​ 子类 A 继承父类 B ，父类B 可以 继承父类 C

Object特点：

Java中所有类，要么直接继承了Object , 要么默认继承了Object , 要么间接继承了Object, Object是祖宗类。

4.3.6继承有哪些特点？

①子类可以继承父类的属性和行为，但是子类不能继承父类的构造器。

②Java是单继承模式：一个类只能继承一个直接父类。

③Java不支持多继承、但是支持多层继承。

④Java中所有的类都是Object类的子类。

4.4继承后：成员变量、成员方法的访问特点

4.4.1在子类方法中访问成员（成员变量、成员方法）满足：就近原则

先子类局部范围找，然后子类成员范围找，然后父类成员范围找，如果父类范围还没有找到则报错。

如果子父类中，出现了重名的成员，会优先使用子类的，此时如果一定要在子类中使用父类的怎么办？

可以通过super关键字，指定访问父类的成员。

格式：super.父类成员变量/父类成员方法

案例代码如下：

package com.itheima.d10_extends_field_method;

public class ExtendsDemo2 {
    public static void main(String[] args) {
        Student s = new Student();
        s.run(); // 子类的
        System.out.println("-----------");
        s.go();
    }
}

class People{
    public void run(){
        System.out.println("可以跑~~");
    }
}

class Student extends People{
    public void run(){
        System.out.println("学生跑的贼快~~");
    }

    public void go(){
        run(); // 子类的
        super.run(); // 父类的
    }
}

4.5继承后：方法重写

4.5.1什么是方法重写？

在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法。

4.5.2方法重写的应用场景

当子类需要父类的功能，但父类的该功能不完全满足自己的需求时。

子类可以重写父类中的方法。

案例演示：

旧手机的功能只能是基本的打电话，发信息

新手机的功能需要能够：基本的打电话下支持视频通话。基本的发信息下支持发送语音和图片。

手机类：

package com.itheima.d11_extends_methodoverride;

public class Phone {
    public void call(){
        System.out.println("打电话开始~~~");
    }

    public void sendMessage(){
        System.out.println("发送短信开始~~~");
    }
}

智能手机类：

package com.itheima.d11_extends_methodoverride;

public class NewPhone extends Phone{
    /**
      方法重写了
     */
    @Override
    public void call() {
        super.call();
        System.out.println("支持视频通话~~~");
    }

    /**
     方法重写了
     */
    @Override
    public void sendMessage() {
        super.sendMessage();
        System.out.println("支持发送图片和视频~~~");
    }
}

测试类：

package com.itheima.d11_extends_methodoverride;

public class Test {
    public static void main(String[] args) {
        NewPhone huawei = new NewPhone();
        huawei.call();
        huawei.sendMessage();
    }
}

4.5.3 @Override重写注解

（1）@Override是放在重写后的方法上，作为重写是否正确的校验注解。

（2）加上该注解后如果重写错误，编译阶段会出现错误提示。

（3）建议重写方法都加@Override注解，代码安全，优雅！

4.5.4 方法重写注意事项和要求

（1）重写方法的名称、形参列表必须与被重写方法的名称和参数列表一致。

（2）私有方法不能被重写。

（3）子类重写父类方法时，访问权限必须大于或者等于父类 （暂时了解 ：缺省 < protected < public）

（4）子类不能重写父类的静态方法，如果重写会报错的。

4.5.5总结

4.5.5.1.方法重写是什么样的？

子类写一个与父类申明一样的方法覆盖父类的方法。

4.5.5.2.方法重写建议加上哪个注解，有什么好处？

@Override注解可以校验重写是否正确，同时可读性好。

4.5.5.3.重写方法有哪些基本要求？

重写方法的名称和形参列表应该与被重写方法一致。

私有方法不能被重写。

子类重写父类方法时，访问权限必须大于或者等于父类被重写的方法的权限。

4.6继承后：子类构造器的特点

4.6.1子类继承父类后构造器的特点：

子类中所有的构造器默认都会先访问父类中无参的构造器，再执行自己。

4.6.2为什么？

子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。

子类初始化之前，一定要调用父类构造器先完成父类数据空间的初始化。

4.6.3怎么调用父类构造器的？

子类构造器的第一行语句默认都是：super()，不写也存在。

4.6.4 案例：

package com.itheima.d12_extends_constructor;

public class Cat extends Animal{
    public Cat(){
        super(); // 默认的，写不写都有，默认就是找父类无参数构造器
        System.out.println("==子类Cat无参数构造器被执行===");
    }

    public Cat(String n){
        super(); // 默认的，写不写都有，默认就是找父类无参数构造器
        System.out.println("==子类Cat有参数构造器被执行===");
    }
}

4.7继承后：子类构造器访问父类有参构造器

super调用父类有参数构造器的作用：

l初始化继承自父类的数据。

如果父类中没有无参数构造器，只有有参构造器，会出现什么现象呢？

会报错。因为子类默认是调用父类无参构造器的。

如何解决？

子类构造器中可以通过书写 super(…)，手动调用父类的有参数构造器

4.8 this、super使用总结

关键字	访问成员变量	访问成员方法	访问构造方法
this	this.成员变量 访问本类成员变量	this.成员方法(…) 访问本类成员方法	this(…) 访问本类构器
super	super.成员变量 访问父类成员变量	super.成员方法(…) 访问父类成员方法	super(…) 访问父类构造器

案例需求：

在学员信息登记系统中，后台创建对象封装数据的时候如果用户没有输入学校，则默认使用“培训中心”。

如果用户输入了学校则使用用户输入的学校信息。代码如下：

student类：

package com.itheima.d14_this;

public class Student {
    private String name;
    private String schoolName;

    public Student() {
    }

    public Student(String name) {
        // 借用兄弟构造器！
        this(name, "黑马培训中心");
    }


    public Student(String name, String schoolName) {
        this.name = name;
        this.schoolName = schoolName;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSchoolName() {
        return schoolName;
    }

    public void setSchoolName(String schoolName) {
        this.schoolName = schoolName;
    }
}

测试类：

package com.itheima.d14_this;

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("王亮", "清华大学");
        System.out.println(s1.getName());
        System.out.println(s1.getSchoolName());


        Student s2 = new Student("王超");
        System.out.println(s2.getName());
        System.out.println(s2.getSchoolName());
    }
}

**this(…)**和super(…)使用注意点：

子类通过 this (…）去调用本类的其他构造器，本类其他构造器会通过 super 去手动调用父类的构造器，最终还是会调用父类构造器的。

注意：this(…) super(…) 都只能放在构造器的第一行，所以二者不能共存在同一个构造器中。
ic String getName() {
return name;
}

public void setName(String name) {
    this.name = name;
}

public String getSchoolName() {
    return schoolName;
}

public void setSchoolName(String schoolName) {
    this.schoolName = schoolName;
}

}

测试类：

```java
package com.itheima.d14_this;

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("王亮", "清华大学");
        System.out.println(s1.getName());
        System.out.println(s1.getSchoolName());


        Student s2 = new Student("王超");
        System.out.println(s2.getName());
        System.out.println(s2.getSchoolName());
    }
}

**this(…)**和super(…)使用注意点：

子类通过 this (…）去调用本类的其他构造器，本类其他构造器会通过 super 去手动调用父类的构造器，最终还是会调用父类构造器的。

注意：this(…) super(…) 都只能放在构造器的第一行，所以二者不能共存在同一个构造器中。