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

已于 2022-08-27 19:45:23 修改
阅读量448 收藏 1
点赞数 2
分类专栏： 初学java 文章标签： java 开发语言
于 2022-08-27 19:43:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46213083/article/details/126561660
版权

🎨 个人介绍

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

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

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

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

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

黑马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 继承的好处和弊端

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

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

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 方法
}

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

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

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

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

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

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);  // 正确
}

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

4.7 static 访问特点

1 ）static 的访问特点

  1. 非静态的成员方法

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

  2. 静态的成员方法

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

  3. 总结成一句话

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

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

知识的搬运工旺仔
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
java黑马学习笔记
02-21
是我从黑马资源中抓出来的每天教师上课的笔记,对于基础学习者帮助还是很大的,毕竟视频太多了,不可能全部看完,但是笔记就不一样.
2023黑马面试宝典-Java面试宝典大全-java面试宝典黑马
11-16
1. **Java基础**：面试中，面试官通常会从基本语法开始，包括数据类型、变量、运算符、流程控制（if、switch、for、while）、类与对象、封装、继承、多态等。理解并能灵活运用这些基础知识是成为一名合格Java开发者...
黑马JAVA全套视频
06-14
【压缩包子文件的文件名称列表】中，"黑马java28期基础班.txt"可能是一个文本文件，包含了第28期黑马Java培训的基础班课程大纲或者笔记。这个文件可能包含了课程的详细内容概览，如章节划分、重点知识点、课后练习等...
java的基础，我是总结了韩顺平老师和黑马的老师
03-15
java的新手小白的可以来看看
黑马程序员-Java语言进阶-源码、教程笔记.zip
12-16
day01_Object类、常用API day02_Collection、泛型 day03_List、Set、数据结构、Collections day04_Map，斗地主案例 day05_异常，线程 day06_线程、同步 day07_等待与唤醒案例、线程池、Lambda...Java基础小节练习题答案
Java内存模型
最新发布
weixin_44267758的博客
07-19 315
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 585
JVM-垃圾回收与内存分配
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 847
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
【Java算法】前缀和 下
2302_79806056的博客
07-18 898
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
liangzai215的专栏
07-15 504
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 528
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。
构建自动化的精粹：Gradle任务依赖性与执行顺序控制
liuxin33445566的博客
07-15 569
本文以"构建自动化的精粹：Gradle任务依赖性与执行顺序控制"为题，详细介绍了任务依赖性的重要性、基本配置、多个任务的依赖性、条件依赖性、错误处理、高级用法、多项目构建中的任务依赖性。随着Gradle的不断发展，我们可以预见到更多关于任务依赖性和构建自动化的高级特性的出现，这将进一步扩展Gradle的构建能力，满足更复杂的项目构建需求。任务依赖性定义了任务之间的执行关系，确保了在构建过程中，任务能够按照预期的顺序执行。任务是一个特殊的任务，它默认依赖于所有没有显式排除的任务。方法来指定任务的依赖性。
Java实验2
qq_64727229的博客
07-16 517
类的封装、继承、多态和接口（1）有理数四则运算（2）最终得分
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 271
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
每 日练 习
m0_67187271的博客
07-19 496
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
【利用Selenium+autoIt实现文件上传】
凌飞安
07-16 433
当文件上传功能不能简单修改value属性的时候，你一定要看一下我这片文章。
Srping Cloud - @Async注解+Feign手动设置token
qq_36782325的博客
07-16 266
在Spring cloud项目开发中，经常需要通过feign远程调用其他的服务的方法。有时因为跨服务调用的时间较长，就会存在需要异步跨服务调用的场景，此时就会出现请求头（主要是token）丢失的问题。
《简历宝典》15 - 简历中“项目经历”，实战讲解，Java篇
xingyu_qie的专栏
07-18 216
校招和初级Java开发的项目经历重点是突出自己在实战中的学习。比如对数据库的操作，比如前后端联调工作中遇到问题的解决，比如一些Java基础知识点的逐渐深入掌握，这些都是这个阶段的Java开发需要去不断增强的。和初级前端开发类似，例如你作为一名初级Java开发，负责的是校园图书管理系统的图书信息上传，图书信息管理这个模块的服务端开发，项目经历可以这样编写，如图。
python--实验14 并发编程（多线程）
wumingzei的博客
07-18 707
定义通过声明Thread的派生类，创建一个子类，并重写对象的run方法，然后创建其对象实例，可创建线程。通过对象的start方法，可启动线程，并自动执行对象的run方法。注意子类的构造器一定要先调用基类的构造器直接将线程需要做的事写到run方法中示例。
黑马程序员java笔记继承
09-15
继承是Java中的一种重要的面向对象编程概念，它允许一个类（子类）继承另一个类（父类）的属性和方法。通过继承，子类可以从父类中获得已有的属性和方法，并且可以在此基础上进行扩展或者修改。 在Java中，使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

知识的搬运工旺仔

希望能帮助到大家学习

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值