当前位置：首页 > article >正文

Java学习笔记--继承的介绍，基本使用，成员变量和成员方法访问特点

article 2024/11/27 6:44:01

一，继承

1.什么是继承

父类怎么形成的:

我们的定义了多个类,发现这些类中有很多重复性的代码,我们就定义了一个父类,将相同的代码抽取出来放到父类中,其他的类直接继承这个父类,就可以直接使用父类中的内容了

2.怎么去继承:

extends

格式：
子类 extends 父类

3.注意:

a.子类可以继承父类中私有和非私有成员,但是不能使用父类中私有成员

private私有的成员还是不能使用，但可以继承
b.构造方法不能继承

方法和类是绑定在一起的

4.继承怎么学

a.继承不要从是否"拥有"方面来学习
要从是否能"使用"方面来学习

只要关注能否使用，只要继承，就能使用非私有成员，目的就是为了减少代码重复，优化代码，是一种重要的面向对象设计思想（不用绕圈想了）

二，继承基本使用

我们需要三个类来演示
1.定义一个父类,在其中定义重复性的代码
2.定义一个子类继承父类 -> extends
子类 extends 父类
3.创建子类对象,直接使用父类中非私有成员

以Employee-->Manager-->Teacher为例，Employee为父类

public class Employee {
    String name;
    int age;


    public void work(){
        System.out.println("工作");
    }

    private void eat(){
        System.out.println("吃饭");
    }
}

public class Manager extends Employee{

}

public class Teacher extends Employee{

}

创建测试类，new子类，使用父类成员，我们发现只能使用父类非私有成员

public class test {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        teacher.name = "张三";
        teacher.age = 23;
        System.out.println(teacher.name+".............."+teacher.age);
        teacher.work();
        //teacher.eat();子类继承父类之后不能使用父类私有成员,只能使用父类非私有成员


        System.out.println("===================");

        Manager manager = new Manager();
        manager.name = "李四";
        manager.age = 34;
        System.out.println(manager.name+".............."+manager.age);
        manager.work();
        //manager.eat();子类继承父类之后不能使用父类私有成员,只能使用父类非私有成员
    }
}

三，成员变量和成员方法访问特点

1.成员变量访问特点

1，子类和父类中的成员变量不重名:

创建三个类，Fu类，Zi类，test类

public class Fu {
    int numFu = 100;
}

public class Zi extends Fu{
    int numZi = 10;
}

public class test {
    public static void main(String[] args) {
        //创建父类对象
        Fu fu = new Fu();
        System.out.println(fu.numFu);//父类中的numFu
        //System.out.println(fu.numZi);//不能直接调用子类特有成员

        System.out.println("======================");
        //创建子类对象

        Zi zi = new Zi();
        System.out.println(zi.numZi);//子类中的numZi
        System.out.println(zi.numFu);//继承了父类，可以使用父类非私有成员
        
    }


}

运行结果如下

总结:

看等号左边是谁,先调用谁中的成员
如果等号左边是父类类型,只能调用父类中的成员变量。

如果等号左边是子类类型,既能调用子类的,还能调用父类中继承过来的非私有成员。

2，子类和父类中的成员变量重名

public class Fu {
    int numFu = 100;

    int num = 10000;
}

public class Zi extends Fu{
    int numZi = 10;

    int num = 1000;
}

public class test {
    public static void main(String[] args) {
        //创建父类对象
        Fu fu = new Fu();
        System.out.println(fu.numFu);//父类中的numFu
        //System.out.println(fu.numZi);//不能直接调用子类特有成员
        System.out.println(fu.num);//父类的

        System.out.println("======================");
        //创建子类对象

        Zi zi = new Zi();
        System.out.println(zi.numZi);//子类中的numZi
        System.out.println(zi.numFu);//继承了父类，可以使用父类非私有成员
        System.out.println(zi.num);//子类的
    }


}

如果把子类里面的num=1000注释掉，输出的zi.num会是什么值呢

会发现zi.num会直接继承Fu类里面的num=10000

那如果左边右边不一样呢

输出的结果会是Zi类里面的1000吗

不是，依然是父类里面的10000，所以只有看左边才能确定调用的是谁中的成员

总结:继承前提下,成员变量访问特点口诀:
看等号左边是谁,先调用谁中的成员,子类没有,找父类

三，成员方法访问特点

1，子类和父类中的成员变量不重名:

依然创建三个类

public class Fu {
    public void methodFu(){
        System.out.println("我是父类中的methodFu");
    }
}

public class Zi extends Fu{
    public void methodZi(){
        System.out.println("我是父类中的methodZi");
    }
}

测试类

public class test {
    public static void main(String[] args) {
        Fu fu = new Fu();
        fu.methodFu();
        //fu.methodZi();  不能调用子类特有方法

        System.out.println("==================");
        Zi zi = new Zi();
        zi.methodZi();
        zi.methodFu();//继承父类，可以调用父类中非私有方法


    }
}

运行

2，子类和父类中的成员变量重名

给Fu类和Zi类各加一个method方法

public class Fu {
    public void methodFu(){
        System.out.println("我是父类中的methodFu");
    }
    
    
    public void method(){
        System.out.println("我是父类中的method方法");
    }
}

public class Zi extends Fu{
    public void methodZi(){
        System.out.println("我是子类中的methodZi");
    }


    public void method(){
        System.out.println("我是子类中的method方法");
    }
}

测试类

public class test {
    public static void main(String[] args) {
        Fu fu = new Fu();
        fu.methodFu();
        //fu.methodZi();  不能调用子类特有方法
        fu.method();//父类中的method方法

        System.out.println("==================");
        Zi zi = new Zi();
        zi.methodZi();
        zi.methodFu();//继承父类
        zi.method();//子类中的method方法


    }
}