0
点赞
收藏
分享

微信扫一扫

黑马全套Java教程（五）

流沙雨帘 2022-12-06 阅读 36
JavaSystemjava父类系统/运维
加载失败


文章目录

  • ​​18 继承​​
  • ​​18.1 继承概述​​
  • ​​18.2 继承中变量的访问特点​​
  • ​​18.3 super关键字​​
  • ​​18.4 继承中构造方法的访问特点​​
  • ​​18.5 继承中成员方法的访问特点​​
  • ​​18.6 方法重写​​
  • ​​18.7 Java中继承注意事项​​
  • ​​19 包​​
  • ​​19.1 包的定义​​
  • ​​19.2 import导包​​
  • ​​20 修饰符​​
  • ​​20.1 权限修饰符​​
  • ​​20.2 状态修饰符​​
  • ​​1. final​​
  • ​​2. static​​
  • ​​21 多态​​
  • ​​21.1 多态概述​​
  • ​​21.2 多态访问特点​​
  • ​​21.3 多态的好处和弊端​​
  • ​​21.4 多态中的转型​​


​​黑马全套Java教程（一）​


​​黑马全套Java教程（二）​


​​黑马全套Java教程（三）​


​​黑马全套Java教程（四）​



本博客从黑马第150个视频开始，​​视频链接​​

18 继承

18.1 继承概述

如下：学生类和老师类中有相同的特征，即重复的代码，我们可以单独提取出来，提高代码复用性

黑马全套Java教程（五）_System


黑马全套Java教程（五）_父类_02


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

继承格式
格式：​​​public class 子类 extends 父类{}​​​ 范例：​​public class Zi extends Fu{}​​ Fu：是父类，也被称为基类、超类
Zi：是子类，也被称为派生类

继承中子类的特点

  • 子类可以有父类的内容
  • 子类还可以有自己特有的内容

继承的好处

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

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

什么时候用继承？
比如猫、狗，都是动物，是动物的一种，所以可以继承动物类

代码实现如下：
父类：Fu.java

package Demo1;

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

子类：Zi.java

package Demo1;

public class Zi extends Fu{   //extends关键字继承父类
    public void method() {
        System.out.println("method方法被调用");
    }
}

测试类：Demo.java

package Demo1;
/*
    测试类
 */
public class Demo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Fu f = new Fu();
        f.show();
        System.out.println("-----------------");

        Zi z = new Zi();
        z.method();
        z.show();
    }
}

黑马全套Java教程（五）_Java_03


18.2 继承中变量的访问特点

就近原则
在子类方法中访问一个变量，按下面顺序寻找：

  • 子类局部范围找
  • 子类成员范围找
  • 父类成员范围找
  • 报错

代码实现：
Fu.java

package Demo2;

public class Fu {
    public int age = 40;
}

Zi.java

package Demo2;

public class Zi extends Fu {
    //身高
    public int height = 175;
    public int age = 20;

    public void show(){
        int age = 30;
        System.out.println("age:" + age);
        System.out.println("height:" + height);
    }
}

Demo.java

package Demo2;

/*
    测试类
 */
public class Demo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Zi z = new Zi();
        z.show();
    }
}

黑马全套Java教程（五）_java_04


18.3 super关键字

super关键字的用法和this关键字的用法相似

  • this：代表本类对象引用
  • super：代表分类存储空间的标识（可以理解为父类对象引用）

代码实现：
Fu.java

package Demo3;

public class Fu {
    public int age = 40;
}

Zi.java

package Demo3;

public class Zi extends Fu {
    //身高
    public int age = 20;

    public void show(){
        int age = 30;
        System.out.println("局部变量age:" + age);
        //我要访问本类的成员变量age
        System.out.println("子类的成员变量：" + this.age);
        //我要访问父类的成员变量age
        System.out.println("子类的成员变量" + super.age);

    }
}

Demo.java

package Demo3;

/*
    测试类
 */
public class Demo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Zi z = new Zi();
        z.show();
    }
}

黑马全套Java教程（五）_Java_05


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

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

为什么呢？

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

代码实现：
Fu.java

package Demo4;

public class Fu {
    public Fu(){System.out.println("Fu中无参构造方法被调用");}
    public Fu(int age){System.out.println("Fu中带参构造方法被调用");}
}

Zi.java

package Demo4;

public class Zi extends Fu {
    public Zi(){System.out.println("Zi中无参构造方法被调用");}
    public Zi(int age){System.out.println("Zi中带参构造方法被调用");}
}

Demo.java

package Demo4;

public class Demo {
    public static void main(String[] args) {
        //创建对象
        Zi z = new Zi();
        System.out.println("--------------");
        Zi z2 = new Zi(20);
    }
}

黑马全套Java教程（五）_父类_06


上面子类也可以这样写：都加个super()

package Demo4;

public class Zi extends Fu {
    public Zi(){
        super();
        System.out.println("Zi中无参构造方法被调用");
    }
    public Zi(int age){
        super();
        System.out.println("Zi中带参构造方法被调用");
    }
}

若需要调用父类带参构造方法，子类可以做如下修改：

package Demo4;

public class Zi extends Fu {
    public Zi(){
        super(20);   //写与不写效果一样
        System.out.println("Zi中无参构造方法被调用");
    }
    public Zi(int age){
        super(20);
        System.out.println("Zi中带参构造方法被调用");
    }
}

黑马全套Java教程（五）_java_07

如果父类中只有带参构造方法，没有无参构造方法，我们又想调用父类无参构造方法，我们可以手动写一个父类无参构造方法

黑马全套Java教程（五）_System_08


总结如下：

黑马全套Java教程（五）_System_09


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

通过子类对象访问一个方法，顺序如下：

  • 子类成员范围找
  • 父类成员范围找
  • 如果都没用就报错（不考虑父亲的父亲…）

代码实现：
Fu.java

package Demo5;

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

Zi.java

package Demo5;

public class Zi extends Fu {
    public void method() {
        System.out.println("Zi中的method方法被调用");
    }
    public void show() {
        super.show();
        System.out.println("Zi中的show方法被调用");
    } //就近原则
}

Demo.java

package Demo5;

public class Demo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Zi z = new Zi();
        z.method();
        z.show();
    }
}

黑马全套Java教程（五）_父类_10


18.6 方法重写

方法重写概述
子类中出现了和父类中一模一样的方法声明

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

Phone.java

package Demo6;
/*
    手机类
 */
public class Phone {
    public void call(String name) {
        System.out.println("给" + name + "打电话");
    }
}

NewPhone.java

package Demo6;
/*
    新手机
 */
public class NewPhone extends Phone{

    @Override  //重写注解  ，可以帮助检查重写的方法正确性
    public void call(String name){  //方法重写
        System.out.println("开启视频功能");
//        System.out.println("给" + name + "打电话");
        super.call(name);  //实现上面那句功能
    }
}

PhoneDemo.java

package Demo6;

public class PhoneDemo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Phone p = new Phone();
        p.call("林青霞");

        System.out.println("----------");
        NewPhone np = new NewPhone();
        np.call("林青霞");
    }
}

黑马全套Java教程（五）_System_11


方法重写的注意事项

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


18.7 Java中继承注意事项

黑马全套Java教程（五）_父类_12

代码实现如下：
Father.java

package Demo8;

public class Father extends Granddad{
    public void smoke(){
        System.out.println("爸爸爱抽烟");
    }
}

Granddad.java

package Demo8;

public class Granddad {
    public void drink(){
        System.out.println("爷爷爱喝酒");
    }
}

Mother.java

package Demo8;

public class Mother {
    public void dance(){
        System.out.println("妈妈爱跳舞");
    }
}

Son.java

package Demo8;

//Java不支持集继承多个类
//但是Java能多层继承，爸爸继承爷爷，儿子继承爸爸
public class Son extends Father{
}



案例：老师和学生

黑马全套Java教程（五）_System_13


Person.java

package Demo10;

public class Person {
    private String name;
    private int age;

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

Teacher.java

package Demo10;

public class Teacher extends Person{
    public Teacher(){}

    public Teacher(String name, int age){   //带参构造方法
//        this.name = name;
//        this.age = age;
        super(name, age); //实现传递
    }
    public void teach(){
        System.out.println("用爱成就每一位学员");
    }
}

Student.java

package Demo10;

public class Student extends Person{
    public void study(){
        System.out.println("好好学习，天天向上！");
    }
}

Demo.java

package Demo10;
/*
    测试类
 */
public class Demo {
    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();
    }
}

案例2：猫和狗

黑马全套Java教程（五）_java_14

Animal.java

package Demo11;

public 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() {
        return age;
    }

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

Cat.java

package Demo11;

public class Cat extends Animal {
    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

Dog.java

package Demo11;

public class Dog extends Animal{
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    public void lookDoor(){
        System.out.println("狗看门");
    }
}

Demo.java

package Demo11;

/*
    测试类
 */
public class Demo {
    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("橘猫", 6);
        System.out.println(c2.getName() + "," + c2.getAge());
        c2.catchMouse();
    }
}


19 包

19.1 包的定义

包的概述
其实就是文件夹
作用：对类进行分类管理

包的定义格式
格式：​​package 包名;​​，（多级包用.分开）
范例：​​package aaa.bbb​​

带包的Java类编译和执行

黑马全套Java教程（五）_父类_15



记事本演示如下：

黑马全套Java教程（五）_父类_16


编译演示如下

这里需要手动建立Demo01包，然后把生成的class文件放入包中

注意：运行也要带包，要不然会报错

黑马全套Java教程（五）_java_17


黑马全套Java教程（五）_System_18

编译演示二：自动建包

这里不需要手动建包，-d运行可以自动建立

黑马全套Java教程（五）_java_19




19.2 import导包

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

导包的格式
格式：​​import 包名;​​ 范例：​​import bao1.bao2.lei1​​

例如：我要在同一个模块下的Demo2包的Demo.Java中使用Demo1包下的Teacher.Java，就需要导包

代码如下：

黑马全套Java教程（五）_Java_20


黑马全套Java教程（五）_Java_21





20 修饰符

修饰符的分类

  • 权限修饰符
  • 状态修饰符

20.1 权限修饰符

黑马全套Java教程（五）_java_22



我们在Demo1中创建三个类：
Fu.Java

package Demo1;

public class Fu {
    private void show1(){
        System.out.println("private");   //只能在本类中被访问
    }
    void show2(){
        System.out.println("默认");
    }
    protected void show3(){
        System.out.println("protected");
    }
    public void show4(){
        System.out.println("public");
    }
    public static void main(String[] args){
        //创建Fu的对象，测试看有哪些方法可以使用
        Fu f = new Fu();
        f.show1();
        f.show2();
        f.show3();
        f.show4();
    }
}

黑马全套Java教程（五）_Java_23


Zi.Java

package Demo1;

public class Zi extends Fu{
    public static void main(String[] args) {
        //创建Zi的对象，测试看有哪些方法可以使用
        Zi z = new Zi();
        z.show2();
        z.show3();
        z.show4();
    }
}

黑马全套Java教程（五）_System_24


Demo.Java

package Demo1;

public class Demo {
    public static void main(String[] args) {
        //创建Fu的对象，测试看有哪些方法可以使用
        Fu f = new Fu();
        f.show2();
        f.show3();
        f.show4();
    }
}

黑马全套Java教程（五）_System_25


之后我们在Demo2中创建两个类：

黑马全套Java教程（五）_java_26


黑马全套Java教程（五）_System_27



20.2 状态修饰符

  • final（最终态）
  • static（静态）

1. final

final关键字是最终的意思，可以修饰成员方法、成员变量、类

final修饰的特点：

  1. 修饰方法：表明该方法是最终方法，不能被重写
  2. 修饰变量：表明该变量是常量，不能再次被赋值
  3. 修饰类：表明该类是最终类，不能被继承

代码实现：

1.修饰方法：被final修饰的方法叫最终方法，不可被重写

黑马全套Java教程（五）_父类_28


2.修饰变量：被final修饰的变量不能再次修改

黑马全套Java教程（五）_System_29


3.修饰类：被final修饰的类不可被继承

黑马全套Java教程（五）_Java_30



final修饰局部变量

  • 变量是基本类型：final修饰基本类型的数据值不能发生改变
  • 变量是引用类型：final修饰引用类型的地址值不能发生改变，但是地址里面的内容是可以改变的

package Demo2;
/*
    测试类
 */
public class FinalDemo {
    public static void main(String[] args) {
        //final修饰基本类型变量
        final int age = 20;
        //age = 100;
        System.out.println(age);

        //final修饰引用类型变量
        final Student s = new Student();
        s.age = 100;
        System.out.println(s.age);

        //s = new Student();   //报错
    }
}

黑马全套Java教程（五）_System_31



2. static

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

特点：

  • 被类的所有对象共享
  • 可以通过类名调用

static.Java

package Demo3;

public class Student {
    public String name;
    public int age;
    //public String university;
    public static String university;   //所有成员共享
    public void show(){
        System.out.println(name + "," + age + "," + university);
    }
}

staticDemo.Java

package Demo3;

public class StaticDemo {
    public static void main(String[] args) {
        Student.university = "南昌";

        Student s1 = new Student();
        s1.name = "林青霞";
        s1.age = 30;
        //s1.university = "南昌";   //不建议这样
        s1.show();

        Student s2 = new Student();
        s2.name = "风清扬";
        s2.age = 33;
        //s2.university = "南昌";
        s2.show();
    }
}

静态访问特点

黑马全套Java教程（五）_java_32

package Demo4;
/*
    static访问特点
 */
 
public class Student {
    //非静态成员变量
    private String name = "林青霞";
    //静态成员变量
    private static String university = "南昌";

    //非静态成员方法
    public void show1(){}
    //静态成员方法
    public static void show3(){}
    
    //非静态成员方法
    public void show2(){
        System.out.println(name);
        System.out.println(university);
        show1();
        show3();
    }

    //静态成员方法
    public static void show4(){  //静态成员方法只能访问静态成员变量和静态成员方法
        //System.out.println(name);   //报错
        System.out.println(university);
        //show1();                    //报错
        show3();
    }
}


21 多态

21.1 多态概述

同一个对象，在不同时刻表现出来的不同形态

举例：猫
我们可以说猫是猫：​​猫 cat = new 猫();​​ 我们也可以说猫是动物：​​动物 animal = new 猫();​​ 这里猫在不同的时刻表现出来了不同的形态，这就是多态

多态的前提和体现

  • 有继承/实现关系
  • 有方法重写
  • 有父类引用指向子类对象

Animal.java

package Demo1;

public class Animal {
    public void eat(){
        System.out.println("动物吃东西");
    }
}

Cat.java

package Demo1;

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

AnimalDemo.java

package Demo1;
/*
    多态：
        同一个对象，在不同时刻表现出来的不同形态

    举例：猫
        我们可以说猫是猫：     猫 cat = new 猫();
        我们也可以说猫是动物：  动物 animal = new 猫();

    多态的前提和体现
        有继承/实现关系
        有方法重写
        有父类引用指向子类对象
 */

public class AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a = new Cat();
        a.eat();
    }
}



21.2 多态访问特点

  • 成员变量：编译看左边，执行看左边
  • 成员方法：编译看左边，执行看右边

为什么成员变量和成员方法的访问不一样呢？

  • 因为成员方法有重写，而成员变量没有

Animal.java

package Demo2;

public class Animal {
    public int age = 40;
    public void eat(){
        System.out.println("动物吃东西");
    }
}

Cat.java

package Demo2;

public class Cat extends Animal {
    public int age = 20;
    public int weight = 10;

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void playGame(){
        System.out.println("猫捉迷藏");
    }
}

AnimalDemo.java

package Demo2;

public class AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a = new Cat();

        System.out.println(a.age);  //40，父类中的
        //System.out.println(a.weight);  //报错
        a.eat();  //子类中的
        //a.playGame();   //报错
    }
}



21.3 多态的好处和弊端

多态的好处：提高了程序的扩展性
具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作
多态的弊端：不能使用子类的特有功能

Animal.java

package Demo3;

public class Animal {
    public void eat(){
        System.out.println("动物吃东西");
    }
}

Cat.java

package Demo3;

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

Dog.java

package Demo3;

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public void lookDoor(){
        System.out.println("狗看门");
    }
}

Pig.java

package Demo3;

public class Pig extends Animal{
    @Override
    public void eat() {
        System.out.println("猪吃白菜");
    }
}

AnimalOperator.java

package Demo3;
/*
    动物操作类
 */
public class AnimalOperator {
//    public void useAnimal(Cat c){ //Cat c = new Cat();
//        c.eat();
//    }
//    public void useAnimal(Dog d){
//        d.eat();
//    }

    public void useAnimal(Animal a){
        //相当于
        //Animal a = new Cat();
        //Animal a = new Dog();
        a.eat();
        //a.loolDoor();   //不能访问具体子类所特有的功能
    }
}

AnimalDemo.java

package Demo3;
/*
    测试类
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //创建动物操作类的对象，调用方法
        AnimalOperator ao = new AnimalOperator();
        Cat c = new Cat();
        ao.useAnimal(c);
        System.out.println("--------------");

        Dog d = new Dog();
        ao.useAnimal(d);

        Pig p = new Pig();
        ao.useAnimal(p);

    }
}



21.4 多态中的转型

  • 向上转型：从子到父，父类引用指向子类对象
  • 向下转型：从父到子，父类引用转为子类对象

Animal.java

package Demo4;

public class Animal {
    public void eat(){
        System.out.println("动物吃东西");
    }
}

Cat.java

package Demo4;

public class Cat extends Animal{
    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }

    public void playGame(){
        System.out.println("猫捉迷藏");
    }
}

AnimalDemo.java

package Demo4;
/*
    向上转型
        从子到父
        父类引用指向子类对象

    向下转型
        从父到子
        父类引用转为子类对象
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //多态
        Animal a = new Cat();  //向上转型
        a.eat();
        //a.playGame();   //报错
        System.out.println("-------------------");

        //创建Cat类的对象
//        Cat c = new Cat();
//        c.eat();
//        c.playGame();
//        System.out.println("------------");

        //向下转型
        Cat c = (Cat)a;
        c.eat();
        c.playGame();
    }
}

黑马全套Java教程（五）_Java_33



案例：猫和狗

黑马全套Java教程（五）_Java_34


Animal.java

package Demo5;

public 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() {
        return age;
    }

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

    public void eat(){
        System.out.println("动物吃东西");
    }
}

Cat.java

package Demo5;

public class Cat extends Animal{
    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

Dog.java

package Demo5;

public class Dog extends Animal{
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

AnimalDemo.java

package Demo5;
/*
    测试类
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //创建猫类进行测试
        Animal a = new Cat();
        a.setName("加菲猫");
        a.setAge(5);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();

        a = new Cat("橘猫", 5);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();
    }
}

本博客到视频d174截止!




举报

相关推荐

黑马全套Java教程（七）

JavaSystemjava字符串系统/运维

黑马全套Java教程（六）

javaSystem抽象类系统/运维

黑马全套Java教程（三）

JavaSystem字符串构造方法系统/运维

黑马全套Java教程（一）

JavaSystemi++系统/运维

黑马全套Java教程（二）

JavaSystem数组数据系统/运维

黑马全套Java教程（八）：集合进阶

JavaSystemjavaList系统/运维

黑马全套Java教程（十）：网络编程

javajvm前端System.net编程语言

黑马程序员Java教程学习笔记（五）

java学习Systemd3代码人生

黑马程序员SpringBoot2全套教程学习笔记

spring bootjavaintellij-idearedisehcache

黑马Redis视频教程实战篇（五）

mysql数据库java
0 条评论
加载失败