【java笔记】继承

最新推荐文章于 2024-09-10 10:21:38 发布

码布里

最新推荐文章于 2024-09-10 10:21:38 发布

阅读量91

点赞数

文章标签： java 继承

本文链接：https://blog.csdn.net/marcotsui/article/details/115110178

版权

本文详细解读了Java继承的基础概念，包括单继承、多级继承和抽象类/抽象方法，通过实例展示了如何访问成员变量、重名处理和方法覆盖。同时介绍了构造方法的调用规则以及super与this关键字的用法。重点讲解了抽象类的使用和子类必须实现抽象父类方法的要求。

摘要由CSDN通过智能技术生成

继承的基本概念：
在这里插入图片描述
书写格式：

package demo01;
/*
父类定义格式：
public class 类名称{}

子类定义格式：
public class 子类名称 extends 父类名称{}
 */
public class Demo01Extends {
    public static void main(String[] args) {
        Teacher tec=new Teacher();
        tec.method();
    }
}

package demo01;
/*
定义一个父类
 */
public class Employee {
    public void method(){
        System.out.println("父类方法执行");
    }
}

package demo01;
/*
定义一个子类
 */
public class Teacher extends Employee
{

}

成员变量访问规则：

package demo02;
/*
继承的成员变量访问规则
直接点成员变量：看等号前
用成员方法调用：看是谁的方法
 */
public class Demo01Extends {
    public static void main(String[] args) {
        Fu fu=new Fu();
        System.out.println(fu.num);//100

        Zi zi=new Zi();
        System.out.println(zi.num);//200

        fu.methodFu();//1000
        zi.methodZi();//2000
        zi.methodFu();//1000
    }
}

package demo02;

public class Fu {
    int numFu=10;
    int num=100;
    public void methodFu(){
        System.out.println(1000);
    }
}

package demo02;

public class Zi extends Fu{
    int numZi=20;
    int num=200;
    public void methodZi(){
        System.out.println(2000);
    }
}

区分重名变量的方法：

package demo03;
/*
区分子类变量重名的方法
局部变量：直接写
子类成员变量：this.变量名
父类成员变量：super.变量名
 */
public class Demo01Extends {
    public static void main(String[] args) {
        Zi zi=new Zi();
        zi.method();
    }
}

package demo03;

public class Fu {
    int num=10;
}

package demo03;

public class Zi extends Fu{
    int num=20;
    public void method(){
        int num=30;
        System.out.println(num);
        System.out.println(this.num);
        System.out.println(super.num);
    }
}

成员方法重名：

package demo04;
/*
成员方法重名，往上找
方法的覆盖（Override）：在继承关系中，方法名称一样，参数列表也一样 ，也叫重写
区别于重载（Overload）：方法名称一样，参数列表不一样
 */
public class Demo01Extends {
    public static void main(String[] args) {
        Zi zi =new Zi();
        zi.method();
    }
}

package demo04;

public class Fu {
    public void method(){
        System.out.println("父类重名方法执行");
    }
}

package demo04;

public class Zi extends Fu {
    public void method(){
        System.out.println("子类重名方法执行");
    }
}

/*
注意事项：
1.Overload父类和子类保持方法名和参数列表一致,可以用@Overload测试
2.父类返回值类型大于等于子类Object>=String
3.子类标识符大于等于父类 public>protected>(default)>private
*/
方法的覆盖和重写：
在这里插入图片描述

package demo05;

public class Demo02Extends {
    public static void main(String[] args) {
        Phone phone =new Phone();
        phone.call();
        phone.send();
        phone.show();

        NewPhone newP=new NewPhone();
        newP.show();
    }
}

package demo05;

public class Phone {
    public void call(){
        System.out.println("打电话");
    }
    public void send(){
        System.out.println("接电话");
    }
    public void show(){
        System.out.println("来电显示");
    }
}

package demo05;

public class NewPhone extends Phone {
    @Override
    public void show(){
        super.show();
        System.out.println("显示名字");
        System.out.println("显示头像");
    }
}

package demo06;
/*
构造方法的访问：
1.先调用父类，后调用子类
2.子类构造不能多次调用
3.子类可以通过super关键字来调用父类重载构造
 */
public class Demo01Extends
{
    public static void main(String[] args) {

        Zi zi=new Zi();
    }
}
/*
这是一个有参构造
这是一个子类构造
 */

package demo06;

public class Fu
{
    public Fu(){
        System.out.println("这是一个无参构造");
    }
    public Fu(int num){
        System.out.println("这是一个有参构造");
    }
}

package demo06;

public class Zi extends Fu
{
    public Zi (){
        super(20);
        System.out.println("这是一个子类构造");

    }
}

super关键字的三种用法

package demo07;
/*
super关键字的三种用法
1.子类成员方法访问父类成员变量
2.子类成员方法访问父类成员方法
3.子类构造方法访问父类构造方法
 */
public class Zi extends Fu {
    int num=20;
    public void method(){
        super.method();
        System.out.println(super.num);
    }
    public Zi(){
        super();

    }


}

package demo07;

public class Fu {
    int num=10;
    public void method(){
        System.out.println("父类方法");
    }
}

this关键字的三种用法

package demo07;
/*
this关键字的三种用法
1.成员方法访问本类成员变量
2.成员方法访问本类成员方法
3.构造方法访问本类构造方法
 */
public class Zi extends Fu {
    int num=20;
    public void method(){
        int num=30;
        System.out.println(num);
        System.out.println(this.num);
    }
    public void methodA(){
        System.out.println("AAA");
        
    }
    public void methodB(){
        this.methodA();
        System.out.println("BBB");
        }
        
    public Zi(){
        this(20);
    }    
    public Zi(int num){
        
    }
    

}

super和this的内存图：
在这里插入图片描述

package demo08;

public class Demo {
    public static void main(String[] args) {
        Zi zi=new Zi();
        zi.method();
        zi.show();
    }
}

package demo08;

public class Fu {
    int num=10;
    public void method(){
        System.out.println("父类方法");
    }
}

package demo08;

public class Zi extends Fu {
    int num=20;
    public void method(){
        int num=30;
        System.out.println(num);
        System.out.println(this.num);
        System.out.println(super.num);

    }
    public void show(){
        super.method();
        System.out.println("子类方法");
    }

}

继承的3个特点：
1.单继承
2.多级继承
3.一父可以有多子
在这里插入图片描述
抽象的概念：

抽象方法的定义

/*
抽象方法：在public后面加abstract，后面没有大括号
抽象类：在public后面加abstract
 */

public abstract class demo09 {
    public abstract void method();
    public void main(){

    }
}

抽象方法的使用：

/*
抽象方法：在public后面加abstract，后面没有大括号
抽象类：在public后面加abstract

如何使用抽象类和抽象方法
1.抽象方法不能直接new
2.写一个子类继承父类
3.子类覆盖重写，去abstract，加大括号
4.创建子类对象使用
 */

public abstract class demo09 {
    public abstract void method();
    public void main(){

    }
}

public class Cat extends demo09
{
    public void  method(){
        System.out.println("猫吃鱼");
    }
}

public class Demo01 {
    public static void main(String[] args) {
        Cat cat =new Cat();
        cat.method();
    }
}

注意事项：

package demo09;
/*
抽象类不可以new
抽象子类必须重写抽象父类的所有抽象方法
 */
public class Demo01 {
    public static void main(String[] args) {
        Dog2Ha ha=new Dog2Ha();
        ha.eat();
        ha.sleep();
        Golden gol=new Golden();
        gol.eat();
        gol.sleep();

    }
}

package demo09;

public abstract class Animal {
    public abstract void eat();
    public abstract void sleep();
}

package demo09;

public abstract class dog extends Animal {
    @Override
    public void sleep(){
        System.out.println("呼呼呼");
    }
}

package demo09;

public class Dog2Ha extends dog{
    @Override
    public void eat(){
        System.out.println("吃屎");

        }
}

package demo09;

public class Golden extends dog {
    public void eat(){
        System.out.println("吃骨头");
    }
}

练习：发红包
在这里插入图片描述
代码：p170

码布里

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【java笔记】继承

继承的基本概念：书写格式：package demo01;/*父类定义格式：public class 类名称{}子类定义格式：public class 子类名称 extends 父类名称{} */public class Demo01Extends { public static void main(String[] args) { Teacher tec=new Teacher(); tec.method(); }}package
复制链接

扫一扫