• 黑马Java第10讲—继承和修饰符

    🎨 个人介绍

    👉大家好，我是：知识的搬运工旺仔

    👉认真分享技术，记录学习过程的点滴，如果我的分享能为你带来帮助，请支持我奥🍻

    👉你的支持，是我每天更新的动力。

    👉赞点：👍 留言：✍ 收藏：⭐

    👉个人格言：想法一步一步的落实，才是你我前进最佳选择。

    黑马Java第10讲—继承和修饰符

    1. 继承

    1.1 继承的实现

    1 ）继承的概念

    1. 继承是面对对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法

    2 ）实现继承的格式

    1. 继承通过extends实现

    2. 格式：

      • class 子类 extends 父类{ }
      • 举例：class Dog extends Animal

    3 ）继承带来的好处

    1. 继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员

    4 ）实例代码

    public class Fu {
    public void show() {
        System.out.rpintln("show方法被调用");
    }
}
​
public class Zi entends Fu {
    public void method() {
        System.out.println("method方法被调用");
    }
}
​
public class Demo {
    public static void main(String[] args) {
        // 创建对象，调用方法
        Fu f =  new Fu();
        f.show();
        
        Zi z = new Zi();
        z.method();
        z.show();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    1.2 继承的好处和弊端

    1 ）继承好处

    1. 提高了代码的复用性（多个类相同的成员可以放到同一个类中）
    2. 提高代码的维护性（如果方法的代码需要修改，修改一处即可）

    2 ）继承弊端

    1. 继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时，子类实现也不得不跟着发生变化，消弱子类的独立性

    3 ）继承的应用场景：

    1. 使用继承，需要考虑类与类之间是否存在is…a的关系，不能盲目使用

      • is…a 的关系：谁时谁的一种，例如：老师和学生时人的一种，那么人就是父类，学生和老师就是子类

    2. 继承中的成员变量的访问特点

    2.1 继承中变量的访问特点

    1 ）在子类方法中访问一个变量，采用的就是就近原则

    1. 子类局部范围内找
    2. 子类成员范围内找
    3. 父类成员范围内找
    4. 如果都没有就报错（不考虑父类的父类）

    2 ）实例代码

    class Fu {
    int num =10;
}
class Zi {
    int num =20;
    public void show() {
        int num =30;
        System.out.println(num);
    }
}
​
public class Demo1 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();  //输出show方法中的局部变量30
    }
 }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    2.2 super

    1 ）this & super 关键字

    1. this ：代表本类对象的引用
    2. super：代表父类存储空间的标识（可以理解位父类对象的引用）

    2 ）this 和 super 的使用分别

    1. 成员变量：

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

    2. 成员方法：

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

    3. 构造方法

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

    2.3 继承中构造方法的访问特点

    1 ）注意

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

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

    1. 通过使用super关键字显示的调用父类的带构造方法
    2. 在父类中自己提供一个无参构造

    3 ）推荐方法

    1. 自己给出构造方法

    2.4 继承中成员方法的访问特点

    1 ）通过子类对象访问一个方法

    1. 子类成员范围找
    2. 父类成员范围找
    3. 如果没有就会报错（不考虑父类的父类）

    2.5 super内存图

    对象在堆内存中，会单独存在一块super区域，用来存放父类的数据

    2.6 方法的重写

    1 ）方法重写概念

    1. 子类出现了和父类一摸一样的方法声明

    2 ）方法重写的应用场景

    1. 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

    3 ）Override注释

    1. 用来检测当前的方法，是否是重写的方法，起到【校验】作用

    2.7 方法重写的注意事项

    1 ）方法重写的注意事项

    1. 私有方法不能被重写（父类私有成员子类是不能继承的）
    2. 子类方法访问权限不能更低（public > 默认 > 私有）

    2 ）实例代码

    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()方法被调用" );    
    }
    
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    2.8 Java中继承的注意事项

    1 ）Java中继承的注意事项

    1. Java中类只支持单继承，不支持多继承

      • 错误实例 ： class A extends B,C {}

    2. Java中类支持多层继承

    2 ）多层继承实例代码

    public class Granddad {
    public void drink() {
    System.out.printl("爷爷爱喝酒");
    }
}
​
public class Father extends Granddad {
    public void smoke() {
        System.out.println("爸爸爱抽烟");
    }
}
​
public class Mother {
    public void dance() {
        System.out.println("妈妈爱跳舞")；
    }
}
​
public class Son extends Father {
    // 此时，Son类中就同时拥有drunk 以及 smoke 方法
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    3. 继承的练习

    3.1 老师和学生类

    1. 需求

    1. 定义老师类和学生类，然后写代码测试
    2. 最后找到老师类和学生类中的共性内容，抽取处一个父类，用于继承的方式改写代码，并进行测试

    2.步骤

    1. 定义老师类（姓名，年龄，教书())
    2. 定义学生类（姓名，年龄，学习() )
    3. 定义测试类，写代码测试
    4. 共性抽取父类，定义人类（姓名，年龄）
    5. 定义老师类，继承人类，并给出自己特有方法：教书()
    6. 定义学生类，继承人类，并给出自己特有方法：学习()
    7. 定义测试类，写代码测试

    3. 代码实例

    class Person {
    private int age;
    private String name;
    
    public Person() {}
    
    public Person(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;
    }
}
​
class Teacher extends Person {
    public Teacher() {}
    
    public Teacher (String name, int age) {
        super(name,age);
    }
    
    public void teach() {
        System.out.println("用爱成就每一位学员");
    }
} 
​
class Student extends Person {
    public Student(String name, int age) {
        super(name,age);
    }
    
    public void study() {
        System.out.ptintln("学生学习");
    }
}
​
class PersonDemo {
    public static void main(String[] args) {
        // 创建老师类对象并进行测试
        Teacher t1 = new Teacher();
        t1.setName("林青霞");
        t1.setAge(30);
        System.out.println(t1.getName() + "," + t1.getAge());
        t1.teach();
        
        Teacher t2 = new Teacher("风清扬",33);
        System.out.println(t2.getName() + "," + t2.getAge());
        t2.teach();
        
        //创建学生对象测试
        Student s = new Student("张三",223);
        System.out.println(s.println(s.getName() + "," + s.getAge()))
        s.study();
    }
    
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70

    3.2 猫和狗

    3.1 需求：

    1. 请求用继承的思想实现猫和狗的案例，
    2. 并在测试类中进行测试

    3.2 分析

    1. 猫

      • 成员变量：姓名，年龄
      • 构造方法：无参、有参
      • 成员方法：get/set方法，抓老鼠()

    2. 狗

      • 成员变量：姓名，年龄
      • 构造方法：无参，带参
      • 成员方法：get/set方法，看门()

    3. 共性：

      • 成员变量：姓名，年龄
      • 构造方法：无参，带参
      • 成员方法：get/set方法

    3.3 步骤

    1. 定义动物类（Animal）

      • 成员变量：姓名，年龄
      • 构造方法：无参，带参
      • 成员方法：get/set方法

    2. 定义猫类（cat),继承动物类

      • 构造方法：无参，带参
      • 成员方法：抓老鼠()

    3. 定义狗类（Dog），继承动物类

      • 构造方法：无参，带参
      • 成员变量：看门()

    3.4 代码实例

    class Animal {
    private String name;
    private int age;
    
    public Animal() {}
    
    public Animal (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(int age) {
        this.age = age;
    }
} 
​
class Cat extends Animal {
    public Cat() {}
    
    public Cat(String name,int age) {
        super(name,age);
    }
    
    public void catchMouse() {
        System.out.println("猫抓老鼠");
    }
}
​
class Dog extends Animal {
    
    public Dog()  {}
    
    public Dog(String name, int age) {
        super(name,age);
    }
    
    public void lookDoor() {
        System.out.println("狗看门");
    }
}
​
/*
   测试类
*/
​
public class AnimalDemo {
    public static void main(String[] args) {
        //创建猫类并进行测试
        Cat c1 = new Cat();
        c1.setName("加菲猫");
        c1.setAge(5);
        
        System.out.println(c1.getName() + "," + c1.getAge());
        c1.catchMouse();
        
        Cat c2 = new Cat("加菲猫",5);
        System.out.println(c2.getName() + "," + c2.getAge());
        c2.catchMouse();
    }
}
    

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69

    4. 修饰符

    4.1 package

    1 ）包的概念

    1. 包就是文件夹，用来管理类文件的

    2 ）包的定义格式

    1. package 包名; (多级包用’’ . " 分开)
    2. 例如： package com.hiema.demo;

    3 ）带包编译 & 带包运行

    1. 带包编译：javac -d .类名.java

      • 例如：javac -d .com.heima.demo.HelloWorld.java

    2. 带包运行：java 包名+类名

      • 例如：java -d .com.heima.demo.HelloWorld

    4.2 import

    1 ）导包的意义

    1. 使用不同包下的类时，使用的时候要写类的全路径，写起来太麻烦了
    2. 为了简化带包的操作，Java就提供了导包的功能

    2 ）导包的格式

    1. 格式：import 包名;
    2. 范例：import java.util.Scanner;

    3 ）实例代码 （没有导包的实例）

    package com.heima;
​
public class Demo {
    public static void main(String[] args) {
        java.util.Scaner input = new java.util.Scanner(system.in);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    4 ）实例代码 （使用导包后，创建Scanner）

    package com.heima
    
import java.util.Scanner;
​
public class Demo {
    public static  void main(String[] args) {
        Scanner input = new Scaner();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    4.3 权限修饰符

    修饰符同一个类中同一个包中子类无关类不同包的子类不同包的无关类
    private√
    默认√√
    protected√√√
    public√√√√

    4.4 final

    1 ）final关键字的作用

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

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

    1. 该类不能被继承（不能有子类，但是可以有父类）
    2. fianl修饰方法：该方法不能被重写
    3. final 修饰变量：表明该变量是一个常量，不能再次赋值

    4.5 final 修饰局部变量

    1 ）fianl 修饰基本数据类型变量

    1. final 修饰指的是基本类型的数据值不能发生改变

    2 ）final 修饰引用数据类型变量

    1. final修饰指的是引用类型的地址不能发生改变，但是地址里边的内容是可以发生改变的
    2. 举例
    public static void main(String[] args) {
    final Student s = new Student(23);
    s = new Student(24);   // 错误
    s.setAGe(24);  // 正确
}

    • 1
    • 2
    • 3
    • 4
    • 5

    4.6 static

    1 ）static 的概念

    1. static 关键字是静态的意思，可以修饰【成员变量】，【成员方法】

    2 ）static 修饰的特点

    1. 被类的所有对象共享，这也是我们判断是否使用静态关键字的条件
    2. 可以通用类名调用，当然，也可以通过对象调用【推荐使用类名调用】

    3 ）实例代码

    class Student {
    public String name;
    public int age;
    public static String university;
    
    public void show() {
        System.out.println(name + ',' + age + "," + university);
    }
}

public class StaticDemo {
    public static void main(String[] args) {
        // 为对象的共享数据赋值
        Student.university = "传智大学";
        
        Student s1 = new Student();
        s1.name = "林青霞";
        s1.age = 30;
        s1.show();
        
        Student s2 = new Student();
        s2.name = "风清扬";
        s2.age = 33;
        s2.show();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    4.7 static 访问特点

    1 ）static 的访问特点

    1. 非静态的成员方法

      • 能访问静态成员变量
      • 能访问非静态的成员变量
      • 能访问静态的成员方法
      • 能访问非静态的成员方法

    2. 静态的成员方法

      • 能访问静态的成员变量
      • 能访问静态的成员方法

    3. 总结成一句话

      • 静态成员方法只能访问静态成员

    🎈看完了不妨给我点个赞吧，👉你的支持，是我每天更新的动力…

  • 相关阅读:
    /lib64/libstdc++.so.6: version `GLIBCXX_3.4.21‘ not found (required by
    什么是网络安全？如何让普通人简单的了解网络安全
    Vue3学习（十五）之 级联选择组件Cascader的使用
    input 只能输入正数并且只能保留3位小数且开头不能为0，并且表单多字段使用
    SpringMVC入门宝典（八）SpringMVC异常处理
    springboot+vue+elementui二手手机销售商城网站
    人脸识别5.3- insightface人脸3d关键点检测源码更改，根据姿态角修正图片角度，调整向量解析值，增大识别准确度，以及返回
    【德哥说库系列】-RHEL8环境源码编译安装MySQL8.0
    Rstudio使用mlogti.data函数出现错误Error in guess(varying) : 没有能够从它们的名字中来猜测时变参数，如何解决？
    啥？你不知道Lucene，这份高级学习文档你值得拥有
  • 原文地址：https://blog.csdn.net/weixin_46213083/article/details/126561660