Java-继承

最新推荐文章于 2024-05-11 10:24:57 发布

别喝凉水容易凉

最新推荐文章于 2024-05-11 10:24:57 发布

阅读量35

点赞数 1

分类专栏： Java基础文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_55047679/article/details/132108600

版权

Java基础专栏收录该内容

8 篇文章 0 订阅

订阅专栏

概述

子类具有父类的一般特征也会具有自身的特性

如：动物 & 食草动物 & 食肉动物

动物为食草动物、食肉动物的父类

食草动物、食肉动物为动物的子类

优点

子类拥有父类非private的属性、方法和构造方法
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展
子类可以用自己的方法实现父类的方法
Java的继承是单继承，但是可以多重继承（即B继承A，C又继承B）
提高了代码复用性

格式

class 子类extends 父类{
    .....
}

extends关键字可以声明一个类是从另一个类继承而来的

示例

父类Animal

package text.entity;

/**
 * @ClassName : Animal
 * @Description : Animal
 * @Author : mt
 * @Date: 2023-08-04 15:36
 */
public class Animal {
    private String name;
    private int id;

    public Animal(String name,int id){
        this.name = name;
        this.id = id;
    }

    public void eat(){
        System.out.println(name+"正在吃");
    }

    public void sleep(){
        System.out.println(name+"正在睡");
    }

    public void introduction(){
        System.out.println("大家好！我是"+id+"号"+name);
    }
}

子类Mouse

package text.entity;

/**
 * @ClassName : Mouse
 * @Description : Mouse
 * @Author : mt
 * @Date: 2023-08-04 15:40
 */
public class Mouse extends Animal{
    public Mouse(String myName,int myId){
        super(myName,myId);
    }
}

super关键字

当子父类中的成员变量同名用super区分。

this	代表一个本类对象的引用
super	代表一个父类对象的引用

子类调用父类的属性：super.属性

子类调用父类的方法：super.方法

子类调用父类的构造方法：super()

示例

package text;

import text.entity.Zi;

/**
 * @ClassName : Zitest
 * @Description : Zitest
 * @Author : mt
 * @Date: 2023-08-04 16:05
 */
public class Zitest {
    public static void main(String[] args) {
        Zi z=new Zi();
        z.show();
    }
}

封装

package text.entity;

/**
 * @ClassName : Fu
 * @Description : Fu
 * @Author : mt
 * @Date: 2023-08-04 16:02
 */
public class Fu {
    private int num =4;

    public int getNum(){
        return this.num;
    }
}

package text.entity;

/**
 * @ClassName : Zi
 * @Description : Zi
 * @Author : mt
 * @Date: 2023-08-04 16:03
 */
public class Zi extends Fu{
    private int num=5;

    public void show(){
        System.out.println(this.num+"..."+super.getNum());
    }
}

未封装

package text.entity;

/**
 * @ClassName : Fu
 * @Description : Fu
 * @Author : mt
 * @Date: 2023-08-04 16:02
 */
public class Fu {
    int num =4;
//    private int num =4;
//
//    public int getNum(){
//        return this.num;
//    }
}

package text.entity;

/**
 * @ClassName : Zi
 * @Description : Zi
 * @Author : mt
 * @Date: 2023-08-04 16:03
 */
public class Zi extends Fu{
    private int num=5;

    public void show(){
//      System.out.println(this.num+"..."+super.getNum());
        System.out.println(this.num+"..."+super.num);
    }
}

方法重写

重写的特点

相同的方法名称、相同的返回值、相同的参数列表
父类中的private修饰的方法不能被重写
子类重写的方法权限修饰符不能比父类的更严格

package text;

import text.entity.Mouse;

/**
 * @ClassName : MouseText
 * @Description : MouseText
 * @Author : mt
 * @Date: 2023-08-04 16:25
 */
public class MouseText {
    public static void main(String[] args) {
        Mouse m = new Mouse("mmm",01);
        m.eat();
    }
}

package text.entity;

/**
 * @ClassName : Mouse
 * @Description : Mouse
 * @Author : mt
 * @Date: 2023-08-04 15:40
 */
public class Mouse extends Animal{
    public Mouse(String myName,int myId){
        super(myName,myId);
    }

    public void eat(){
        System.out.println("老鼠在吃粮食");
    }
}

点击重写标志，点击可查看父类方法

package text.entity;

/**
 * @ClassName : Animal
 * @Description : Animal
 * @Author : mt
 * @Date: 2023-08-04 15:36
 */
public class Animal {
    private String name;
    private int id;

    public Animal(String name,int id){
        this.name = name;
        this.id = id;
    }

    public void eat(){
        System.out.println(name+"正在吃");
    }

    public void sleep(){
        System.out.println(name+"正在睡");
    }

    public void introduction(){
        System.out.println("大家好！我是"+id+"号"+name);
    }
}

抽象类

Java中的抽象类：当两个类有共性，他需要向上抽取然后继承，那么这个函数声明是相同的，但是里面的逻辑是不同的

格式

//抽象类
修饰符 abstract class 类名{
    //抽象方法
    修饰符 abstract 返回值类型 方法名([参数列表]);   
}

abstract修饰方法，称抽象方法。只有方法的定义，没有方法体并且只能定义在抽象类中；

abstract修饰类，称抽象类。抽象类不能被直接实例化，需要借助子类重写抽象类中全部的抽象方法，通过子类创建对象

问题

Q：抽象类中有构造函数吗？

有，用于给子类对象进行初始化

Q：抽象类可以不定义抽象方法吗？

可以，但是很少见

Q：抽象类和一般类有什么区别？

Q：抽象类一定是父类吗？

是的，因为需要子类覆盖其方法后才可以对子类实例化

示例

package text.entity;

/**
 * @ClassName : Animal01 抽象类
 * @Description : Animal01
 * @Author : mt
 * @Date: 2023-08-04 16:40
 */
public abstract class Animal01 {
    private String name;
    public abstract void eat();
}

package text.entity;

/**
 * @ClassName : Mouse01 子类
 * @Description : Mouse01
 * @Author : mt
 * @Date: 2023-08-04 16:42
 */
public class Mouse01 extends Animal01{
    @Override
    public void eat() {
        System.out.println("老鼠吃粮食");
    }
}

package text.entity;

/**
 * @ClassName : Penguin01 子类
 * @Description : Penguin01
 * @Author : mt
 * @Date: 2023-08-04 16:41
 */
public class Penguin01 extends Animal01{
    @Override
    public void eat() {
        System.out.println("企鹅正在吃鱼");
    }
}

final关键字

理解：在Java中表示独一无二

特性

final可以修饰类、方法、变量
final修饰的类不可以被继承
final修饰的方法不可以被重写
final修饰的变量是一个常量，只能被赋值一次，在定义时赋值，且该值不可改
内部类只能访问final修饰的局部变量

示例：类不可以被继承

package text.entity;

/**
 * @ClassName : Msg
 * @Description : Msg
 * @Author : mt
 * @Date: 2023-08-04 16:58
 */
public final class Msg {
}

示例：方法不可以被重写

package text;

import text.entity.Msg;

/**
 * @ClassName : MsgTest
 * @Description : MsgTest
 * @Author : mt
 * @Date: 2023-08-04 17:03
 */
public class MsgTest {
    public static void main(String[] args) {
        Msg m = new Msg();
        m.show();
    }
}

package text.entity;

/**
 * @ClassName : Msg
 * @Description : Msg
 * @Author : mt
 * @Date: 2023-08-04 16:58
 */
public final class Msg {
    //定义常量
    public static final String title="java";
    public final void show(){
        System.out.println(title);
    }
}