java基础：继承的使用

一.继承的使用

1.什么是继承

2.继承的设计规范

3.继承的内存原理

test.java

package Test;

public class test {
    public static void main(String[] args) {
//        目标：理解继承的设计思想
        Student s=new Student();
        s.setName("蜘蛛精");//使用父类的
        s.setAge(999);//使用父类的
        System.out.println(s.getName());//使用父类的
        System.out.println(s.getName());//使用父类的
        s.queryCourse();//父类的
        s.writeInfo();//子类的方法
    }
}

People.java

package Test;

//父类
public class People {
    private String name;
    private int age;

    /**
     * 查看课表
     */
    public void queryCourse(){
        System.out.println(name+"在查看课表");
    }

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

Student.java

package Test;

//子类
public class Student extends People{
//    独有的行为，填写反馈信息
    public void writeInfo(){
        System.out.println(getName()+"写下了：学习语法，好哈皮");


    }
}

二.特点和访问

Object特点：

• java中所有类，要么直接继承Object,要么默认继承了Object,间接继承Object,Object是祖宗类

继承有哪些特点？

• 子类可以继承父类的属性和行为，但是子类不能继承父类的构造器
• Java是单继承模式：一个类只能继承一个直接父类
• Java不支持多继承，但是支持多层继承
• Java中所有的类都是Object类的子类
  
  

package Test;

public class test {
    public static void main(String[] args) {
//        目标：理解继承的特点
//        1.子类不能继承父类的构造器
//        2.子类是否可以继承父类的私有成员？我认为是可以继承父类父类私有成员的，只是不能直接访问
        Tiger t=new Tiger();
//        t.eat();
//        3.子类是否可以继承父类的静态成员，我认为不算继承的，只是共享的
        System.out.println(Tiger.location);

    }
}

class Animal{
    private void eat(){
        System.out.println("动物要吃东西");
    }
    public static String location="长隆动物园";
}

class Tiger extends Animal{

}

三.继承后：成员变量，成员方法的访问特点

就近原则：子类有用子类的，没有找父类，父类没有报错

如果子父类中出现了重名的成员，此时如果一定要在子类中使用父类的怎么办？

super.变量

package Test;

public class test {
    public static void main(String[] args) {
//        目标：理解继承后成员的访问特点：就近原则
        Dog d=new Dog();
        d.run();//子类的
        d.lookDoor();//子类的
        d.showName();
    }
}

class Animal{
    public String name="动物名";
    public void run(){
        System.out.println("动物可以跑");
    }
}

class Dog extends Animal{
    public String name="狗名";
    public void lookDoor(){
        System.out.println("狗可以看门");
    }
    public void showName(){
        String name="局部名";
        System.out.println(name);//局部民名
        System.out.println(this.name);//狗名
        System.out.println(super.name);//动物名，，此时找的是父类的name
    }
    public void run(){
        System.out.println("狗跑的贼快");
    }
}

四.方法重写

package Test;

public class test {
    public static void main(String[] args) {
//        目标：认识方法重写
        NewPhone hw=new NewPhone();
        hw.call();
        hw.sendMsg();

    }
}
/**
 * 新手机：子类
 */
class NewPhone extends Phone{
//    重写的方法
    public void call(){
        super.call();//先用他爸爸的基本功能
        System.out.println("开始视频通话");
    }
    public void sendMsg(){
        super.sendMsg();//先用它爸爸的基本功能
        System.out.println("发送有趣的图片");
    }
}
/**
 * 旧手机：父类的
 */
class Phone{
    public void call(){
        System.out.println("打电话");
    }

    public void sendMsg(){
        System.out.println("发短信");
    }
}

结果展示

打电话
开始视频通话
发短信
发送有趣的图片

package Test;

public class test {
    public static void main(String[] args) {
//        目标：认识方法重写
        NewPhone hw=new NewPhone();
        hw.call();
        hw.sendMsg();

    }
}
/**
 * 新手机：子类
 */
class NewPhone extends Phone{
//    重写的方法
//    1.重写校验注解，加上之后，这个方法，必须是正确重写的，这样更安全。2.提高程序的可读性，代码优雅
//    注意：重写方法的名词和形参列表必须与被重写的方法一致
    @Override
    public void call(){
        super.call();//先用他爸爸的基本功能
        System.out.println("开始视频通话");
    }
    public void sendMsg(){
        super.sendMsg();//先用它爸爸的基本功能
        System.out.println("发送有趣的图片");
    }
}
//注意：静态方法不能被重写
//@Override


/**
 * 旧手机：父类的
 */
class Phone{
    public void call(){
        System.out.println("打电话");
    }

    public void sendMsg(){
        System.out.println("发短信");
    }
}

五，子类构造器的特点.访问父类无参构造器

使用子类时，会默认使用父类构造器

Test.java

package Test;

public class Test {
    public static void main(String[] args) {
        //    目标：认识继承后子类构造器的特点
        //    特点：子类的全部构造器默认会先访问父类的无参构造器再执行自己
        Dog d1=new Dog();
        System.out.println(d1);

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

        Dog d2=new Dog("金毛");
        System.out.println(d2);

    }
}

Dog.java

package Test;

public class Dog extends Animal{
    public Dog(){
        System.out.println("子类Dog无参数构造器被执行");
    }

    public Dog(String name){

    }
}

Animal

package Test;

public class Animal {
    public Animal(){
        System.out.println("父类Animal无参数构造器被执行");
    }
}

六.子类访问父类的有参构造器

Test.java

package Test;

public class Test {
    public static void main(String[] args) {
//        目标：学习子类构造器如何去访问父类有参数构造器，还要清楚其作用
        Teacher t=new Teacher("dlei",18);
        System.out.println(t.getName());
        System.out.println(t.getAge());
    }
}

People.java

package Test;

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

    public People(){

    }

    public People(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 Test;

public class Teacher extends People {
    public Teacher(String name,int age){
//        调用父类的有参数构造器：初始化继承自父类的数据
        super(name,age);

    }

}

七.this和super详情

Test.java

package Test;

public class Test {
    public static void main(String[] args) {
//  目标：理解this(...)的作用：本类构造器中访问本类兄弟构造器
        Student s1=new Student("殷素素","冰火岛自学");
        System.out.println(s1.getName());
        System.out.println(s1.getSchoolName());

//        如果学生不填学校，默认这个对象的学校是黑马
        Student s2=new Student("张三丰");
        System.out.println(s2.getName());
        System.out.println(s2.getSchoolName());

    }

}

Student.java

package Test;

public class Student {
    private String name;
    private String schoolName;

    public Student(){

    }

    /**
     * 如果学生不填写学校，默认这个对象的学校是黑马
     */
    public Student(String name){
//        借用本类兄弟构造器
//        写了this就不能再写super()
        this(name,"黑马程序员");
    }


    public Student(String name, String schoolName) {
//        super();//必须先初始化父类，再初始化自己
        this.name = name;
        this.schoolName = schoolName;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSchoolName() {
        return schoolName;
    }

    public void setSchoolName(String schoolName) {
        this.schoolName = schoolName;
    }
}