day01——面向对象高级

YangeIT大约 32 分钟

day01——面向对象高级

学习目标

静态关键字static 🍐 ✏️
- 修饰成员变量
- 修饰成员方法
- 注意事项
设计模式 🍐
- 单例模式
  - 饿汉式
  - 懒汉式
继承 🍐✏️❤️
- 概念🍐
- 好处🍐
- 权限修饰符✏️
- 方法重写✏️

1.静态 🍐 ✏️

1.1 static修饰成员变量

静态

Java中的成员变量按照有无static修饰分为两种：类变量、实例变量。

它们的区别如下图所示：

由于静态变量是属于类的，只需要通过类名就可以调用：类名.静态变量
实例变量是属于对象的，需要通过对象才能调用：对象.实例变量

代码操作

下面是代码演示（注意静态变量，和实例变量是如何调用的）

为了让大家对于这两种成员变量的执行过程理解更清楚一点，在这里给大家在啰嗦几句，我们来看一下上面代码的内存原理。

在实际开发中，如果某个数据只需要一份，且希望能够被共享（访问、修改），则该数据可以定义成类变量来记住。

我们看一个案例

👉需求： 系统启动后，要求用于类可以记住自己创建了多少个用户对象。

第一步：先定义一个User类，在用户类中定义一个static修饰的变量，用来表示在线人数；

public class User{
    public static int number;
    //每次创建对象时，number自增一下
    public User(){
        User.number++;
    }
}

第二步：再写一个测试类，再测试类中创建4个User对象，再打印number的值，观察number的值是否再自增。


public class Test2 {
    public static void main(String[] args) {
        // 目标：通过案例理解类变量的应用场景。
        // 1.创建4个对象
        User u1 = new User();
        User u2 = new User();
        User u3 = new User();
        User u4 = new User();

        // 2.查看系统创建了多少个User对象
        System.out.println(User.number); // 4
    }
}

运行上面的代码，查看执行结果是：系统创建的User对象个数：4

总结

类变量：属于类，在内存中只有一份，用类名调用
实例变量：属于对象，每一个对象都有一份，用对象调用

课堂作业

类变量和实例变量各有什么特点？🎤
练习一下上述 系统启动后，要求用于类可以记住自己创建了多少个用户对象 案例。 ✏️

1.2 static修饰成员方法 ✏️

各位同学，学习完static修饰成员变量之后，接下来我们学习static修饰成员方法。

static修饰成员方法

成员方法根据有无static也分为两类：类方法、实例方法

有static修饰的方法，是属于类的，称为类方法；调用时直接用类名调用即可。
无static修饰的方法，是属于对象的，称为实例方法；调用时，需要使用对象调用。

代码操作

我们看一个案例，演示类方法、实例方法的基本使用

先定义一个Student类，在类中定义一个类方法、定义一个实例方法

public class Student {
    // 成员变量：分数
    double score;

    // 类方法，有static修饰，可以用类名.方法名() 调用
    public static void printHelloWorld(){
        System.out.println("Hello World");
        System.out.println("Hello World");
    }

    // 实例方法（对象的方法） 没有static修饰的方法,需要用对象名.方法名() 调用
    public void printPass(){
        //打印成绩是否合格
        System.out.println("成绩：" + (score >= 60 ? "及格": "不及格"));
    }
}

在定义一个测试类，注意类方法、对象方法调用的区别

public class Test {
    public static void main(String[] args) {
        // 目标：掌握有无static修饰方法的用法。
        // 1.类方法的用法
        //类名.类方法（推荐）---调用Student类中的类方法
        Student.printHelloWorld();
        
        // 使用对象也能调用类方法【不推荐，IDEA连提示都不给你，你就别这么用了】
        Student s = new Student();
        s.printHelloWorld();
        

        // 2.实例方法的用法
        // 对象.实例方法
        s.printPass();
        // Student.printPass(); //报错, 实例方法,需要用对象名.方法名() 调用
    }
}

搞清楚类方法和实例方法如何调用之后，接下来再啰嗦几句，和同学们聊一聊static修饰成员方法的内存原理。 1664005554987

类方法：static修饰的方法，可以被类名调用，是因为它是随着类的加载而加载的；所以类名直接就可以找到static修饰的方法
实例方法：非static修饰的方法，需要创建对象后才能调用，是因为实例方法中可能会访问实例变量，而实例变量需要创建对象后才存在。 所以实例方法，必须创建对象后才能调用。

main() 作为程序的入口

需求：给main方法的args参数，传点数据试试！！ 👇

/**
目标：给main方法传参数，遍历输出到控制台
 */
public class MainTest {

    public static void main(String[] args) {

        //遍历args参数
        for (String arg : args) {
            System.out.println(arg);
        }
    }
}

配置完，运行MainTest，观察控制台是否输出数字 👈

总结

关于static修饰成员变量、和静态修饰成员方法这两种用法，到这里就学习完了。

类方法：static修饰的方法，可以被类名调用，是因为它是随着类的加载而加载的；所以类名直接就可以找到static修饰的方法
实例方法：非static修饰的方法，需要创建对象后才能调用，是因为实例方法中可能会访问实例变量，而实例变量需要创建对象后才存在。所以实例方法，必须创建对象后才能调用。

课堂作业

类方法是随对象创建而存在的，对吗？🎤
实例方法可以通过类名.实例方法直接调用吗?🎤

1.3 工具类 ✏️

工具类

代码操作

我们写一个生成验证码的工具类

1. 写一个生成验证码的工具类

public class MyUtils{
public static String createCode(int n){
    // 1.定义一个字符串，用来记录产生的验证码
    String code = "";
    
    // 2.验证码是由所有的大写字母、小写字母或者数字字符组成
    //这里先把所有的字符写成一个字符串，一会从字符串中随机找字符
    String data = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKMNOPQRSTUVWXYZ";
    
    // 3.循环n次，产生n个索引,再通过索引获取字符
    Random r = new Random();
    for(int i=0; i<n; i++){
        int index = r.nextInt(data.length());
        char ch = data.charAt(index);
        // 4.把获取到的字符，拼接到code验证码字符串上。
        code+=ch;
    }
    
    // 5.最后返回code,code的值就是验证码
    return code;
}
}

1. 接着可以在任何位置调用MyUtils的createCOde()方法产生任意个数的验证码

//比如这是一个登录界面
public class LoginDemo{
    public static void main(String[] args){
        System.out.println(MyUtils.createCode());
    }
}

//比如这是一个注册界面
public class registerDemo{
    public static void main(String[] args){
        System.out.println(MyUtils.createCode());
    }
}

工具类的使用就是这样子的，学会了吗？

在补充一点，工具类里的方法全都是静态的，推荐用类名调用为了防止使用者用对象调用。我们可以把工具类的构造方法私有化。

public class MyUtils{
    //私有化构造方法：这样别人就不能使用构造方法new对象了
    private MyUtils(){
        
    }
    
    //类方法
    public static String createCode(int n){
       ...
    }
}

总结

如果一个类中的方法全都是静态的，这就意味着这个类中的方法就全都可以被类名直接调用，由于调用起来非常方便，就像一个工具一下，所以把这样的类就叫做工具类，一般在项目中，工程师们都可以用。

课堂作业

防止使用者用对象调用工具类中的方法，怎么做？🎤

1.4 static的注意事项

static的注意事项

现在在我们已经学会了static修饰的变量、方法如何调用了。但是有一些注意事项还是需要给大家说明一下，目的是让大家知道，使用static写代码时，如果出错了，要知道为什么错、如何改正。

使用类方法、实例方法时注意事项：

类方法中可以直接访问类的成员，不可以直接访问实例成员。
实例方法中既可以直接访问类成员，也可以直接访问实例成员。
实例方法中可以出现this关键字，类方法中不可以出现this关键字的。

代码操作

代码验证👇


/**
 *目标：掌握使用类方法、实例方法时的几点注意事项。
 * 1、类方法中可以直接访问类的成员，不可以直接访问实例成员。
 * 2、实例方法中既可以直接访问类成员，也可以直接访问实例成员。
 * 3、实例方法中可以出现this关键字，类方法中不可以出现this关键字的
 */
public class Student {
    static String schoolName; // 类变量
    double score; // 实例变量

    // 1、类方法中可以直接访问类的成员，不可以直接访问实例成员。
    public static void printHelloWorld(){
        // 注意：同一个类中，访问类成员，可以省略类名不写。
        schoolName = "黑马";
        printHelloWorld2();
        //System.out.println(score); // 报错的
        //printPass(); // 报错的
        //System.out.println(this); // 报错的
    }

    // 类方法
    public static void printHelloWorld2(){

    }

    // 实例方法
    public void printPass2(){

    }

    // 实例方法
    // 2、实例方法中既可以直接访问类成员，也可以直接访问实例成员。
    // 3、实例方法中可以出现this关键字，类方法中不可以出现this关键字的
    public void printPass(){
        schoolName = "黑马2"; //对的
        printHelloWorld2(); //对的

        System.out.println(score); //对的
        printPass2(); //对的

        System.out.println(this); //对的
    }
}

总结

使用类方法、实例方法时注意事项：

类方法中可以直接访问类的成员，不可以直接访问实例成员。
实例方法中既可以直接访问类成员，也可以直接访问实例成员。
实例方法中可以出现this关键字，类方法中不可以出现this关键字的。

课堂作业

类方法可以直接访问实例成员吗？🎤
解释一下为什么类方法中不可以出现this关键字的？🎤

1.5 代码块

static应用（代码块）

代码块根据有无static修饰分为两种：静态代码块、实例代码块 1664007549583

代码操作

我们先类学习静态代码块：

public class Student {
    static int number = 80;
    static String schoolName = "黑马";
    // 静态代码块
    static {
        System.out.println("静态代码块执行了~~");
        schoolName = "黑马";
    }
}

静态代码块不需要创建对象就能够执行

public class Test {
    public static void main(String[] args) {
        // 目标：认识两种代码块，了解他们的特点和基本作用。
        System.out.println(Student.number);
        System.out.println(Student.number);
        System.out.println(Student.number);

        System.out.println(Student.schoolName); // 黑马
    }
}

执行上面代码时，发现没有创建对象，静态代码块就已经执行了。

关于静态代码块重点注意思考一下：应用场景：静态代码块，随着类的加载而执行，而且只执行一次。

再来学习一下实例代码块

实例代码块的作用和构造器的作用是一样的，用来给对象初始化值；而且每次创建对象之前都会先执行实例代码块。

public class Student{
    //实例变量
	int age;
    //实例代码块：实例代码块会执行在每一个构造方法之前
    {
        System.out.println("实例代码块执行了~~");
        age = 18;
        System.out.println("有人创建了对象：" + this);
    }

    public Student(){
        System.out.println("无参数构造器执行了~~");
    }

    public Student(String name){
        System.out.println("有参数构造器执行了~~");
    }
}

接下来在测试类中进行测试，观察创建对象时，实例代码块是否先执行了。

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student("张三");
        System.out.println(s1.age);
        System.out.println(s2.age);
    }
}

对于实例代码块重点注意：实例代码块每次创建对象之前都会执行一次 ,和构造很相似哦

总结

静态代码块，随着类的加载而执行，而且只执行一次。
实例代码块每次创建对象之前都会执行一次

课堂作业

静态代码块和实例代码块执行时机有什么不同？🎤

1.6 static应用（单例设计模式）

单例设计模式

什么是设计模式（Design pattern） ?
- 一个问题通常有n种解法，其中肯定有一种解法是最优的，这个最优的解法被人总结出来了，称之为设计模式。
设计模式有23种，对应23多种软件开发中会遇到的问题。链接open in new window
关于设计模式的学习，主要学什么？
- 解决什么问题？
- 怎么写？

单例设计模式

确保一个类只有一个对象。

写法

把类的构造器私有。
定义一个类变量记住类的一个对象。
定义一个类方法，返回对象。

代码操作

单例设计模式书写

定义一个类，私有化构造方法，并且暴露一个对外访问的静态方法，返回对象。

/**
 * 
 * 饿汉式单例模式
 */
public class A {
    // 2、定义一个类变量记住类的一个对象
    private static A a = new A();

    // 1、必须私有类的构造器
    private A(){

    }

    // 3、定义一个类方法返回类的对象
    public static A getObject(){
        return a;
    }
}

创建一个测试类，通过类名.方法调用多次，观察地址值是否一致

public class Test1 {
    public static void main(String[] args) {
        // 目标：掌握单例设计模式的写法。
        A a1 = A.getObject();
        A a2 = A.getObject();
        System.out.println(a1);
        System.out.println(a2);
    }
}

控制台输出：

com.itheima.d6_singleInstance.A@5594a1b5
com.itheima.d6_singleInstance.A@5594a1b5

定义一个类，私有化构造方法，并且暴露一个对外访问的静态方法，返回对象。

public class B {
    // 2、定义一个类变量，用于存储这个类的一个对象。
    private static B b;

    // 1、把类的构造器私有
    private B(){

    }

    // 3、定义一个类方法，这个方法要保证第一次调用时才创建一个对象，后面调用时都会用这同一个对象返回。
    public static B getInstance(){
        if(b == null){
            System.out.println("第一次创建对象~");
            b = new B();
        }
        return b;
    }
}

创建一个测试类，通过类名.方法调用多次，观察地址值是否一致

/**
 * 目标：掌握懒汉式单例的写法。
 */
public class Test2 {
    public static void main(String[] args) {
        B b1 = B.getInstance(); // 第一次拿对象
        B b2 = B.getInstance();
       
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b1 == b2);
    }
}

控制台输出：

第一次创建对象~
com.itheima.d6_singleInstance.B@5594a1b5
com.itheima.d6_singleInstance.B@5594a1b5
true

总结

饿汉式： 对象预先加载，在类创建好的同时对象生成，调用获得对象实例的方法反应速度快，代码简练。

懒汉式： 对象延迟加载，效率高，只有在使用的时候才实例化对象，代码相对于饿汉式复杂，第一次加载类对象的时候反应不快。

课堂作业

如果使用某个软件，每次使用加载同一个很大的资源包，请问适合哪种加载方式？🎤

2. 继承 ✏️ 🍐❤️

各位同学，我们继续学习面向对象相关内容。面向对象编程之所以能够能够被广大开发者认可，有一个非常重要的原因，是因为它有三大特征，继承、封装和多态。封装我们在基础班已经学过了，接下来我们学习一下继承。

2.1 继承快速入门 ❤️ ✏️

前言

代码操作

接下来，我们演示一下使用继承来编写代码，注意观察继承的特点。

public class A{
    //公开的成员
    public int i;
    public void print1(){
        System.out.println("===print1===");
    }
    
    //私有的成员
    private int j;
    private void print2(){
        System.out.println("===print2===");
    }
}

然后，写一个B类，让B类继承A类。在继承A类的同时，B类中新增一个方法print3

public class B extends A{
    public void print3(){
        //由于i和print1是属于父类A的公有成员，在子类中可以直接被使用
        System.out.println(i); //正确
        print1(); //正确
        
        //由于j和print2是属于父类A的私有成员，在子类中不可以被使用
        System.out.println(j); //错误
        print2();
    }
}

接下来，我们再演示一下，创建B类对象，能否调用父类A的成员。再写一个测试类

public class Test{
    public static void main(String[] args){
        B b = new B();
        //父类公有成员，子类对象是可以调用的
        System.out.println(i); //正确
        b.print1();
        
        //父类私有成员，子类对象时不可以调用的
        System.out.println(j); //错误
        b.print2(); //错误
    }
}

到这里，关于继承的基本使用我们就算学会了。

为了让大家对继承有更深入的认识，我们来看看继承的内存原理。

这里我们只需要关注一点：子类对象实际上是由子、父类两张设计图共同创建出来的。

所以，在子类对象的空间中，既有本类的成员，也有父类的成员。但是子类只能调用父类非私有的成员。

总结

继承就是用extends关键字，让一个类和另一个类建立起一种父子关系。
子类对象实际上是由子、父类两张设计图共同创建出来的。
在子类对象的空间中，既有本类的成员，也有父类的成员,但是子类可以继承父类非私有(private）的成员

课堂作业

带继承关系的类，Java会怎么创建它的对象？对象创建出来后，可以直接访问哪些成员？
练习一下上述的继承代码 ✏️

2.2 继承的好处

各位同学，学习完继承的快速入门之后，接下来我们学习一下继承的好处，以及它的应用场景。

继承的好处

我们通过一个案例来学习

观察代码发现，我们会发现Teacher类中和Consultant类中有相同的代码；其实像这种两个类中有相同代码时，没必要重复写。

我们可以把重复的代码提取出来，作为父类，然后让其他类继承父类就可以了，这样可以提高代码的复用性。改造后的代码如下：

接下来使用继承来完成上面的案例，这里只演示People类和Teacher类，然后你尝试自己完成Consultant类。

代码操作

/**教师类 */
public class Teacher {
    
    private String name;

    public String getName() {
        return name;
    }

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

    private String skill;

    public String getSkill() {
        return skill;
    }

    public void setSkill(String skill) {
        this.skill = skill;
    }

    public void printInfo(){
        System.out.println(getName() + "具备的技能：" + skill);
    }
}


/**
 * 顾问类
 */
public class Consultant {
    private String name;

    private int number;

    // 解答问题的人数    
    public String getName() {
        return name;
    }

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

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }
}

最后再写一个测试类，再测试类中创建Teacher、Consultant对象，并调用方法。

public class Test {
    public static void main(String[] args) {
        // 目标：搞清楚继承的好处。
        Teacher t = new Teacher();
        t.setName("播仔");
        t.setSkill("Java、Spring");
        System.out.println(t.getName());
        System.out.println(t.getSkill());
        t.printInfo();
    }
}

先写一个父类 People，用来设计Teacher和Consultant公有的成员。

public class People{
    private String name;
    
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name=name;
    }
}

再写两个子类Teacher继承People类，同时在子类中加上自己特有的成员。

public class Teacher extends People{
    private String skill; //技能
    
    public String getSkill(){
        return skill;
    }
    
    public void setSkill(String skill){
        this.skill=skill;
    }
    
    public void printInfo(){
        System.out.println(getName()+"具备的技能："+skill);
    }
}

最后再写一个测试类，再测试类中创建Teacher、Consultant对象，并调用方法。

public class Test {
    public static void main(String[] args) {
        // 目标：搞清楚继承的好处。
        Teacher t = new Teacher();
        t.setName("播仔");
        t.setSkill("Java、Spring");
        System.out.println(t.getName());
        System.out.println(t.getSkill());
        t.printInfo();
    }
}

执行代码，打印结果如下：

关于继承的好处我们只需要记住：继承可以提高代码的复用性

总结

课堂作业

继承的好处是什么？🎤
完成Consultant类的继承操作，并且在测试类中测试Consultant继承情况。✏️

2.3 权限修饰符

各位同学，在刚才使用继承编写的代码中我们有用到两个权限修饰符，一个是public （公有的）、一个是private （私有的），实际上还有两个权限修饰符，一个是protected （受保护的）、一个是缺省的（不写任何修饰符）。
接下来我们就学习一下这四个权限修饰符分别有什么作用。

权限修饰符

什么是权限修饰符呢？
权限修饰符是用来限制类的成员（成员变量、成员方法、构造器...）能够被访问的范围。

每一种权限修饰符能够被访问的范围如下

代码操作

下面我们用代码演示一下，在本类中可以访问到哪些权限修饰的方法。

public class Fu {
    // 1、私有:只能在本类中访问
    private void privateMethod(){
        System.out.println("==private==");
    }

    // 2、缺省：本类，同一个包下的类
    void method(){
        System.out.println("==缺省==");
    }

    // 3、protected: 本类，同一个包下的类，任意包下的子类
    protected void protectedMethod(){
        System.out.println("==protected==");
    }

    // 4、public： 本类，同一个包下的类，任意包下的子类，任意包下的任意类
    public void publicMethod(){
        System.out.println("==public==");
    }

    public void test(){
        //在本类中，所有权限都可以被访问到
        privateMethod(); //正确
        method(); //正确
        protectedMethod(); //正确
        publicMethod(); //正确
    }
}

接下来，在和Fu类同一个包下，创建一个测试类Demo，演示同一个包下可以访问到哪些权限修饰的方法。

public class Demo {
    public static void main(String[] args) {
        Fu f = new Fu();
        // f.privateMethod();	//私有方法无法使用
        f.method();
        f.protectedMethod();
        f.publicMethod();
    }
}

接下来，在另一个包下创建一个Fu类的子类，演示不同包下的子类中可以访问哪些权限修饰的方法。

public class Zi extends Fu {
    //在不同包下的子类中，只能访问到public、protected修饰的方法
    public void test(){
        // privateMethod(); // 报错
        // method(); // 报错
        protectedMethod();	//正确
        publicMethod();	//正确
    }
}

接下来，在和Fu类不同的包下，创建一个测试类Demo2，演示一下不同包的无关类，能访问到哪些权限修饰的方法；

public class Demo2 {
    public static void main(String[] args) {
        Fu f = new Fu();
        // f.privateMethod(); // 报错
        // f.method();		  //报错
        // f.protecedMethod();//报错
        f.publicMethod();	//正确

        Zi zi = new Zi();
        // zi.protectedMethod();
    }
}

总结

课堂作业

4个修饰符(含默认)能够被访问的范围哪个最大？🎤
如果父类某个方法什么修饰符都不写，其他包的子类能访问父类的该方法吗？🎤

2.4 单继承、Object

刚才我们写的代码中，都是一个子类继承一个父类，那么有同学问到，一个子类可以继承多个父类吗？

单继承、Object

Java语言只支持单继承，不支持多继承，但是可以多层继承。就像家族里儿子、爸爸和爷爷的关系一样：一个儿子只能有一个爸爸，不能有多个爸爸，但是爸爸也是有爸爸的。

代码操作

代码验证 👇

public class Test {
    public static void main(String[] args) {
        // 目标：掌握继承的两个注意事项事项。
        // 1、Java是单继承的：一个类只能继承一个直接父类；
        // 2、Object类是Java中所有类的祖宗，那么应该继承顶级父类的非私有资源
        A a = new A();
        B b = new B();

        ArrayList list = new ArrayList();
        list.add("java");
        System.out.println(list.toString());
    }
}

class A {} //extends Object{} 
class B extends A{} 
// class C extends B , A{} // 报错,单继承
class D extends B{}

总结

Java语言只支持单继承，不支持多继承，但是可以多层继承

课堂作业

如果有个类：猫 还有一个类叫：动物 现在定义一个类：加菲猫。

如果这样:class 加菲猫 extends 猫,动物 可以吗？

2.5 方法重写

各位同学，学习完继承之后，在继承的基础之上还有一个很重要的现象需要给大家说一下。
叫做方法重写。为了让大家能够掌握方法重写，我们先认识什么是方法重写，再说一下方法的应用场景。

方法重写

什么是方法重写

当子类觉得父类方法不好用，或者无法满足需求时，子类可以重写一个方法名称、参数列表一样的方法，去覆盖父类的这个方法，这就是方法重写。

注意：重写后，方法的访问遵循就近原则。

代码操作

下面我们看一个代码演示

写一个A类作为父类，定义两个方法print1和print2

public class A {
    public void print1(){
        System.out.println("父类的老print1方法");
    }
    public int print2(int a, int b){
        System.out.println("父类的老print2方法");
        return 1;
    }
}

再写一个B类作为A类的子类，重写print1和print2方法。

public class B extends A{
    // 方法重写
    public void print1(){
        System.out.println("子类的print1");
    }
    public int print2(int a, int b){
        System.out.println("子类的print2");
        return 2;
    }
}

接下来，在测试类中创建B类对象，调用方法

/**
 * 目标：认识方法重写，掌握方法重写的常见应用场景。
 */
public class Test {
    public static void main(String[] args) {
        B b =  new B();
        b.print1();
        b.print2(2, 3);
    }
}

执行代码，我们发现真正执行的是B类中的print1和print2方法就近原则

知道什么是方法重写之后，还有一些注意事项，需要和大家分享一下:

重写的方法上面，可以加一个注解@Override,用于标注这个方法是复写的父类方法
子类复写父类方法时，访问权限必须大于或者等于父类方法的权限 public > protected > 缺省
重写的方法返回值类型，必须与被重写的方法返回值类型一样，或者范围更小
私有方法、静态方法不能被重写，如果重写会报错。

注意1：👇

/**
 * 子类B
 */
public class B extends A{
    // 方法重写
    @Override
    public void print1(){
        System.out.println("子类的print1");
    }


    @Override
    public void print2(int a, int b){
        System.out.println("子类的print2");
    }
}

关于这些注意事项，同学们其实只需要了解一下就可以了了解一下。实际上我们实际写代码时，只要和父类写的一样就可以（总结起来就8个字：声明不变，重新实现）

方法重写的应用场景

学习完方法重写之后，接下来，我们还需要大家掌握方法重写，在实际中的应用场景。方法重写的应用场景之一就是：子类重写Object的toString()方法，以便返回对象的内容。

比如：有一个Student类，这个类会默认继承Object类。

public class Student extends Object{
    private String name;
    private int age;

    public Student() {
    }

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

    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;
    }
}

其实Object类中有一个toString()方法，直接通过Student对象调用Object的toString()方法，会得到对象的地址值。

public class Test {
    public static void main(String[] args) {
        Student s = new Student("播妞", 19);
        // System.out.println(s.toString());
        System.out.println(s);
    }
}

但是，此时不想调用父类Object的toString()方法，那就可以在Student类中重新写一个toSting()方法，用于返回对象的属性值。

package com.itheima.d12_extends_override;

public class Student extends Object{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
。。。。省略get set方法

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

重新运行测试类，结果如下

好了，到这里方法什么是方法重写，以及方法重写的应用场景我们就学习完了。

总结

当子类觉得父类方法不好用，或者无法满足父类需求时，子类可以重写一个方法名称、参数列表一样的方法，去覆盖父类的这个方法，这就是方法重写。
重写后，方法的访问遵循就近原则。
注意事项：声明不变，重新实现
方法重写的应用场景之一就是：子类重写Object的toString()方法，以便返回对象的内容。

课堂作业

运行下列代码，观察效果，为什么没有输出地址值，而是输出ArrayList的元素信息？

ArrayList list = new ArrayList();
list.add("java");
list.add("html");
System.out.println(list);

尝试重写Object类中的toString()方法，改变输出格式，输出对象的属性信息而非地址值, 输出格式如：[name:'播妞', age:19]

可以使用快捷键

2.6 子类中访问成员的特点

子类中访问成员的特点

各位同学，刚才我们已经学习了继承，我们发现继承至少涉及到两个类，而每一个类中都可能有各自的成员（成员变量、成员方法），就有可能出现子类和父类有相同成员的情况，那么在子类中访问其他成员有什么特点呢？

原则：在子类中访问其他成员（成员变量、成员方法），是依据就近原则的

代码操作

定义一个父类，代码如下

public class F {
    String name = "父类名字";

    public void print1(){
        System.out.println("==父类的print1方法执行==");
    }
}

再定义一个子类，代码如下。有一个同名的name成员变量，有一个同名的print1成员方法；

public class Z extends F {
    String name = "子类名称";
    public void showName(){
        String name = "局部名称";
        System.out.println(name); // 局部名称
    }

    @Override
    public void print1(){
        System.out.println("==子类的print1方法执行了=");
    }

    public void showMethod(){
        print1(); // 子类的
    }
}

接下来写一个测试类，观察运行结果，我们发现都是调用的子类变量、子类方法。

public class Test {
    public static void main(String[] args) {
        // 目标：掌握子类中访问其他成员的特点：就近原则。
        Z z = new Z();
        z.showName();
        z.showMethod();
    }
}

运行结果：

局部名称
==子类的print1方法执行了=

如果子类和父类出现同名变量或者方法，优先使用子类的；此时如果一定要在子类中使用父类的成员，可以加this或者super 进行区分。

public class Z extends F {
    String name = "子类名称";

    public void showName(){
        String name = "局部名称";
        System.out.println(name); // 局部名称
        System.out.println(this.name); // 子类成员变量
        System.out.println(super.name); // 父类的成员变量
    }

    @Override
    public void print1(){
        System.out.println("==子类的print1方法执行了=");
    }

    public void showMethod(){
        print1(); // 子类的
        super.print1(); // 父类的
    }
}

运行结果：

局部名称
子类名称
父类名字
==子类的print1方法执行了=
==父类的print1方法执行==

Process finished with exit code 0

总结

在子类中访问其他成员（成员变量、成员方法），是依据就近原则的
如果子类和父类出现同名变量或者方法，优先使用子类的；此时如果一定要在子类中使用父类的成员，可以加this或者super 进行区分。

课堂作业

结合上述代码，创建Z对象，调用showName和showMethod()方法，观察控制台输出

F代码在上面，可以直接拷贝

public class Z extends F {
    String name = "子类名称";

    public void showName(){
        String name = "局部名称";
        System.out.println(name); // 局部名称
        System.out.println(this.name); // 子类成员变量
        System.out.println(super.name); // 父类的成员变量
    }

    @Override
    public void print1(){
        System.out.println("==子类的print1方法执行了=");
    }

    public void showMethod(){
        print1(); // 子类的
        super.print1(); // 父类的
    }
}

2.7 子类中访问构造器的特点

各位同学，我们知道一个类中可以写成员变量、成员方法，还有构造器。在继承关系下，子类访问成员变量和成员方法的特点我们已经学过了；接下来再学习子类中访问构造器的特点。

子类中访问构造器的特点

1. 子类构造器的特点：

子类的全部构造器，都会先调用父类的构造器，再执行自己。

2. 子类构造器是如何实现调用父类构造器的：

默认情况下，子类全部构造器的第一行代码都是 super() （写不写都有），它会调用父类的无参数构造器。
如果父类没有无参数构造器，则我们必须在子类构造器的第一行手写super(….)，指定去调用父类的有参数构造器。

3. 补充知识

任意类的构造器中，是可以通过this(…) 去调用该类的其他构造器的。
this(…) 、super(…) 都只能放在构造器的第一行，因此，有了this(…)就不能写super(…)了，反之亦然。

代码操作


class F{
    public F(){
        System.out.println("===父类F的 无参数构造器 执行了===");
    }

    public F(String name, int age){
        System.out.println("===父类F的 有参数构造器 执行了===");
    }
}

class Z extends F{
    public Z(){
        // super(); // 默认存在的
       //super("播妞", 17);
        System.out.println("===子类Z的 无参数构造器 执行了===");
    }

    public Z(String name){
        // super(); // 默认存在的
        //super("播妞", 17);
        System.out.println("===子类Z的 有参数构造器 执行了===");
    }
}

public class Test {
    public static void main(String[] args) {
        // 目标：先认识子类构造器的特点，再掌握这个特点的常见应用场景。
        Z z = new Z();
        Z z2 = new Z("播妞");
    }
}

运行结果：

===父类F的 无参数构造器 执行了===
===子类Z的 无参数构造器 执行了===
===父类F的 无参数构造器 执行了===
===子类Z的 有参数构造器 执行了===

任意类的构造器中，是可以通过this(…) 去调用该类的其他构造器的。

this(…) 、super(…) 都只能放在构造器的第一行，因此，有了this(…)就不能写super(…)了，反之亦然。

总结

最后我们被this和super的用法在总结一下

访问本类成员：
	this.成员变量	//访问本类成员变量
	this.成员方法	//调用本类成员方法
	this()		   //调用本类空参数构造器
  this(参数)	  //调用本类有参数构造器
	
访问父类成员：
	super.成员变量	//访问父类成员变量
	super.成员方法	//调用父类成员方法
	super()		   //调用父类空参数构造器
  super(参数)	  //调用父类有参数构造器
    
注意：this和super访问构造方法，只能用到构造方法的第一句，否则会报错。

课堂作业

练一练上述代码操作中 演示子调父 中的代码，体会this和super的区别！🎤

课后作业

🚩 1. 重点完成上述的课堂作业

晚自习第一节课的前30分钟，总结完毕之后，每个同学先必须梳理今日知识点

晚自习第一节课的后30分钟开始练习（记住：程序员是代码堆起来的）：
- 先要把今天的所有案例或者课堂练习，如果没练完的，练完他
- 完成讲师发送在班级群中的作业，提交位置关注群里
- 不懂要多问，问同学，问老师，问百度，都可以！！独自解决分析问题，解决问题的能力-----编程思维！！
剩余的时间：预习第二天的知识，预习的时候一定要注意：

预习不是学习，不要死看第二天的视频（很容易出现看了白看，为了看视频而看视频）
预习看第二天的笔记，把笔记中标注重要的知识，可以找到预习视频，先看一遍，如果不懂的，记住做好标注。

day01——面向对象高级

# day01——面向对象高级

# 1.静态 🍐 ✏️

# 1.1 static修饰成员变量

# 1.2 static修饰成员方法 ✏️

# 1.3 工具类 ✏️

# 1.4 static的注意事项

# 1.5 代码块

# 1.6 static应用（单例设计模式）

# 2. 继承 ✏️ 🍐❤️

# 2.1 继承快速入门 ❤️ ✏️

# 2.2 继承的好处

# 2.3 权限修饰符

# 2.4 单继承、Object

# 2.5 方法重写

# 2.6 子类中访问成员的特点

# 2.7 子类中访问构造器的特点

day01——面向对象高级

1.静态 🍐 ✏️

1.1 static修饰成员变量

1.2 static修饰成员方法 ✏️

1.3 工具类 ✏️

1.4 static的注意事项

1.5 代码块

1.6 static应用（单例设计模式）

2. 继承 ✏️ 🍐❤️

2.1 继承快速入门 ❤️ ✏️

2.2 继承的好处

2.3 权限修饰符

2.4 单继承、Object

2.5 方法重写

2.6 子类中访问成员的特点

2.7 子类中访问构造器的特点