JavaEE学习记录 day02继承、重写、抽象类、代码块

JavaEE学习记录 day02继承、重写、抽象类、代码块

##思维导图

1.继承的概念

继承是面向对象的三大特征之一，可以使子类具有父类的属性和方法，还可以在子类中重写这些方法或追加属性和方法。

2.继承的格式和好处

class Zi extends Fu{}

关键字：extends
使用继承的好处是提高代码的复用性，便于之后代码的维护。但缺点在于父类和子类之间产生联系，提高了代码的耦合性。
使用继承的场景需要考虑类与类之间是否存在is…a关系。

3.继承的特点

-Java中的类只支持单继承，不支持多继承如：

class A extends B,C{}

是错误的，但支持多层继承，如

class A extends B{}
class C extends A{}

继承中的变量访问采用就近原则，也就是现在子类局部找，然后在成员范围内找，再去父类成员找，都找不到就会报错，不会考虑父类的父类。

class Fu {
    int num = 10;
}
class Zi extends Fu{
    int num = 20;
    public void show(){
        int num = 30;
        System.out.println(num);
        System.out.println(this.num);
        System.out.println(super.num);
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();	// 输出show方法中的局部变量30,在输出子类成员变量20，在输出父类10
    }
}

在变量同名状态下，想要调用成员变量和父类成员要使用this和super关键字

• this：代表本类对象的应用

• super：代表父类存储空间的标识(可以理解为父类对象引用)

• this和super的使用分别

• 成员变量：

  • this.成员变量 - 访问本类成员变量
  • super.成员变量 - 访问父类成员变量

• 成员方法：

  • this.成员方法 - 访问本类成员方法
  • super.成员方法 - 访问父类成员方法

• 构造方法：

• this(…) - 访问本类构造方法

• super(…) - 访问父类构造方法

注意：子类中所有的构造方法默认都会访问父类中无参的构造方法

​ 子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化，原因在于，每一个子类构造方法的第一条语句默认都是：super()

问题：如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？*

1. 通过使用super关键字去显示的调用父类的带参构造方法
2. 子类通过this去调用本类的其他构造方法,本类其他构造方法再通过super去手动调用父类的带参的构造方法

注意: this(…)super(…) 必须放在构造方法的第一行有效语句，并且二者不能共存

方法的重写

重写只会出现在继承父类的子类中，对父类的方法进行重写

• 注意事项
  私有方法不能重写
  被final关键字修饰的方法不能重写
  静态方法不能重写
  @Override注解是用来检测当时方法是否是重写方法
• 重写和重载的区别
  重写出现在继承中，在有父子类的情况下，子类对父类的方法进行重写，除方法体改变外，其他不变，若是重写抽象方法则需要去掉abstract.
  重载出现在同一类中，指方法名相同，参数列表不同的方法，与修饰符和返回值无关。

public class Fu {
    private void show() {
        System.out.println("Fu中show()方法被调用");
    }

    void method() {
        System.out.println("Fu中method()方法被调用");
    }
}

public class Zi extends Fu {

    /* 编译【出错】，子类不能重写父类私有的方法*/
    @Override
    private void show() {
        System.out.println("Zi中show()方法被调用");
    }
   
    /* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    private void method() {
        System.out.println("Zi中method()方法被调用");
    }

    /* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    public void method() {
        System.out.println("Zi中method()方法被调用");
    }
}

权限修饰符

抽象类

关键字：abstract
抽象类和抽象方法的书写格式

public abstract class 类名{
public abstract void 方法名();
}

• 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

• 抽象类不能实例化

• 抽象类可以有构造方法

• 抽象类的子类

  ​ 要么重写抽象类中的所有抽象方法

  ​ 要么是抽象类

模板设计模式

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。
示例代码：

public abstract class CompositionTemplate {

    public final void write(){
        System.out.println("<<我的爸爸>>");

        body();

        System.out.println("啊~ 这就是我的爸爸");

    }

    public abstract void body();
}

实现类A

public class Tom extends CompositionTemplate {

    @Override
    public void body() {
        System.out.println("那是一个秋天, 风儿那么缠绵,记忆中, " +
                "那天爸爸骑车接我放学回家,我的脚卡在了自行车链当中, 爸爸蹬不动,他就站起来蹬...");
    }
}

实现类B

public class Tony extends CompositionTemplate {
    @Override
    public void body() {
		System.out.orintln("示例");
    }

    
}

测试类

public class Test {
    public static void main(String[] args) {
        Tom t = new Tom();
        t.write();
    }
}

final关键字

• fianl关键字的作用

  • final代表最终的意思，可以修饰成员方法，成员变量，类

• final修饰类、方法、变量的效果

  • fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）

  • final修饰方法：该方法不能被重写

  • final修饰变量：表明该变量是一个常量，不能再次赋值

    • 变量是基本类型,不能改变的是值

    • 变量是引用类型,不能改变的是地址值,但地址里面的内容是可以改变的

4.代码块

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

代码块分类

• 局部代码块

  • 位置: 方法中定义

  • 作用: 限定变量的生命周期，及早释放，提高内存利用率

  • 示例代码

    public class Test {
        /*
            局部代码块
                位置：方法中定义
                作用：限定变量的生命周期，及早释放，提高内存利用率
         */
        public static void main(String[] args) {
            {
                int a = 10;
                System.out.println(a);
            }
    
           // System.out.println(a);
        }
    }
    

• 构造代码块

  • 位置: 类中方法外定义

  • 特点: 每次构造方法执行的时，都会执行该代码块中的代码，并且在构造方法执行前执行

  • 作用: 将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性

  • 示例代码

    public class Test {
        /*
            构造代码块:
                位置：类中方法外定义
                特点：每次构造方法执行的时，都会执行该代码块中的代码，并且在构造方法执行前执行
                作用：将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性
         */
        public static void main(String[] args) {
            Student stu1 = new Student();
            Student stu2 = new Student(10);
        }
    }
    
    class Student {
    
        {
            System.out.println("好好学习");
        }
    
        public Student(){
            System.out.println("空参数构造方法");
        }
    
        public Student(int a){
            System.out.println("带参数构造方法...........");
        }
    }
    

• 静态代码块

  • 位置: 类中方法外定义

  • 特点: 需要通过static关键字修饰，随着类的加载而加载，并且只执行一次

  • 作用: 在类加载的时候做一些数据初始化的操作

  • 示例代码

    public class Test {
        /*
            静态代码块:
                位置：类中方法外定义
                特点：需要通过static关键字修饰，随着类的加载而加载，并且只执行一次
                作用：在类加载的时候做一些数据初始化的操作
         */
        public static void main(String[] args) {
            Person p1 = new Person();
            Person p2 = new Person(10);
        }
    }
    
    class Person {
        static {
            System.out.println("我是静态代码块, 我执行了");
        }
    
        public Person(){
            System.out.println("我是Person类的空参数构造方法");
        }
    
        public Person(int a){
            System.out.println("我是Person类的带...........参数构造方法");
        }
    }