Java(三)面向对象：继承

一：继承：Inheritance

//继承
public class Inheritance {
    public static void main(String[] args) {
    
        
        


        Fish fish = new Fish();
        fish.age=10;
        fish.breed="鲨鱼";
        fish.furColor="蓝白";
        System.out.println(
                fish.age+fish.breed+fish.furColor
        );
        fish.swim();
        fish.eat(); //调用父类的方法
        fish.sleep();
    }
}

class Animal {
    String breed; //品种
    int age; //年龄
    String sex; //性别

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

    public void sleep() {
        System.out.println("睡.......");
    }
}


class Fish extends Animal { //继承父类的动物类
    String furColor; // 颜色

    public void swim() {
        System.out.println("游......");
    }
}

class Bird extends Animal {//继承父类的动物类
    String furColor; //颜色

    public void  fly() {
        System.out.println("飞.......");
    }
}

二：继承的语法

//继承的语法
public class Grammar {
    public static void main(String[] args) {
        

        
        

        Fish1 fish1 = new Fish1();
        fish1.breed="鲨鱼";
        fish1.age =30;
        fish1.sex ="公鲨鱼";
        fish1.eat();
        fish1.sleep();
        Animal animal = new Animal();
        animal.eat();
    }
}
class Animal1 {
    String breed; //品种
    int age; //年龄
    String sex; //性别

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

    public void sleep() {
        System.out.println("睡.......");
    }
}
class Fish1 extends Animal1 { //继承父类的动物类
    String furColor; // 颜色

  

    @Override  //注解说明是否重写，进行验证，遵循重写规则
    public void eat() {
        //System.out.println("大鲨鱼喜欢吃小鱼");
    }

    public void swim() {
        System.out.println("游......");
    }
}

三：super关键字：SuperKeyWord

//SuperKeyWord
//super关键字
public class SuperKeyWord {

    
    
    

    public static void main(String[] args) {
        Son son = new Son(); //实例化，创建一个子类的对象
        //在想调用一下父类的show方法"",进行复用,去子类去调用，不可在这个地方调用
        son.show(); //这个是子类的show方法""
    }
}

class Father {

    int value = 10;

    public void show() {
        System.out.println("这是Father的show方法");
    }
}

class Son extends Father {
    int value = 10; //访问本类的实例变量value
    //重写父类的这个方法，SupperKeyWord
    @Override

    public void show() {
        super.show();//复用，调用父类的方法
        int value = 10; //局部变量
        System.out.println(value);//局部变量
        System.out.println(this.value); //访问本来的实例变量value
        System.out.println(super.value); //访问父类中value
    }
}

练习：

public class Practice01 {
    public static void main(String[] args) {
        //在创建B的子类对象，会先执行A的构造方法
        B b = new B();
        b.m1();
        b.m2();
       
        
        
    }
}

class A {
    int num1;
    int num2;

    //添加A的构造方法
    public A() {
        System.out.println("A的构造方法");
    }


    public A(int num1, int num2) { this.num1 = num1 ; this.num2 = num2;}

    public void m1() {
        System.out.println("A类中的m1方法");
    }
}

class B extends A {
    int num3;

    //添加B的构造方法
    public B() {
        super(); //就是调用父类的无参构造方法，默认添加的
        System.out.println("B的构造方法");
    }

    public B(int num1, int num2, int num3) {
        //super(); //默认调用的是父类的无参构造
        super( num1, num2); //调用父类的带参构造
        //this.num1 = num1;this.num2 = num2;调用父类的带参构造这个两个可以省略
        this.num3 = num3;}

    public void m2() {
        System.out.println("B类中的m2方法");
    }
}