Java中的继承（一）

package Test;

public class Cat {
    public String name;
    public String gender;
    public int age;
    public String temper;

    public void init(String name, String gender, int age, String temper) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.temper=temper;
    }
    public void eat(){
        System.out.println(name+"吃猫粮。。。");
    }
    public void sleep(){
        System.out.println(name+"呼呼睡大觉！！");
    }
    public void mew(){
        System.out.println(name+"喵喵喵~~~");
    }

}

package Test ;

public class Dog {
     public String name;
     public String gender;
     public int age;
    public String color;

    public void init(String name, String gender, int age, String color) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.color = color;
    }
    public void eat(){
        System.out.println(name+"吃狗粮。。。");
    }
    public void sleep(){
        System.out.println(name+"呼呼睡大觉！！");
    }
    public void bark(){
        System.out.println(name+"汪汪汪~~~");
    }

}

package Test;
public class TestPet {
    public static void main(String[] args) {
     Dog d1=new Dog();
     d1.init("小七","公",2,"黄色");
     d1.eat();
     d1.sleep();
     d1.bark();
     System.out.println("=======================");
     Cat c1=new Cat();
     c1.init("小八","母",3,"粘人型");
     c1.eat();
     c1.sleep();
     c1.mew();
    }
}

继承主要解决的问题是：共性的抽取，实现代码复用。
例如：狗和猫都是动物，那么我们就可以将共性的内容进行抽取，然后采用继承的思想来达到共

package Test.one;
//子类/派生类;
public class Dog extends Animal{
//在公共类上面来进行扩增
    public String color;
    public void bark(){
        System.out.println(name+"在狗叫");
    }
}

package Test.one;
//子类/派生类;
public class Cat extends Animal{
 //进行扩增
      public String temper;
      public void mew(){
     System.out.println(name+"喵喵喵~~~");
   }
}

package Test.one;
//基类/父类；
    public class Animal {
        public String name;
        public String gender;
        public int age;
        public void init(String name, String gender, int age) {
            this.name = name;
            this.gender = gender;
            this.age = age;
        }
        public void eat(){
            System.out.println(name+"干饭~~~");
        }
        public void sleep(){
            System.out.println(name+"呼呼睡大觉。。。");
        }

        public static void main(String[] args) {

        }
    }

package Test.one;

public class TestAnimal {
    public static void main(String[] args) {
       Dog dog=new Dog();
       //name、gender、age实例变量
        //eat()、sleep()、bark（）成员方法
        //都是从基类中继承下来的
       dog.init("小七","公的",2);
       dog.eat();
       dog.sleep();
       //新增加了bark()方法以及color变量
       dog.bark();
        System.out.println(dog.color);
        System.out.println("==================");
       Cat cat=new Cat();
       cat.init("小八","母的",1);
       cat.eat();
       cat.sleep();
       cat.mew();
        System.out.println(cat.temper);
    }
}

package Test.Two;

public class Base {
    int a;
    int b;
}

package Test.Two;
//测试验证：能否在子类的方法中访问基类继承下来的不同名称的成员变量
//结果：可以直接访问
public class Derive extends Base{
    int c;
    public void method(){
     a=10;
     b=20;
     c=30;
        System.out.println(a+" "+b+" "+c);
    }

    public static void main(String[] args) {
        Derive derive1=new Derive();
        derive1.method();
    }
}

package Test.Three;

public class Base {
    int a;
    double b;
    //方法一:直接在父类中加入成员方法来进行访问成员变量
    public void BaseA(int a){
        this.a=a;
    }
    //方法二：使用super关键字来优先调用基类成员变量
}

package Test.Three;

public class Derive extends Base{
    //测试：能否在子类中直接访问从基类中继承下来的和基类同名的成员变量
    //结果：可以直接访问
    int a;//和基类中的变量a类型和名字完全相同
    short d;//类型不同，名字相同
    //结论：如果子类和基类有着相同名字的变量成员，在子类的方法中优先访问的是子类的
    // 从基类中继承下来的同名成员，不能在子类的方法中被直接访问，这种称为同名隐藏
     public void method(){
         a=20;
         b=60;
       //  System.out.println(a+" "+b);
       //super优先调用基类中的成员变量以及成员方法,如果父类中没有所引用的成员变量或者成员方法编译器就会报错
         super.a=30;
         super.b=70;
         super.BaseA(48 );
     }

    public static void main(String[] args) {
        Derive d1=new Derive();
        d1.method();
        System.out.println(d1.a);
        System.out.println(d1.b);
    }
}

package Test.Four;

public class Base {
    public void func1(){
        System.out.println("Base.fun1()");
    }
    public void func2(int a){
        System.out.println("Base.func2(int)");
    }
    public void func3(int a,int b){
        System.out.println("Base.func3(int,int)");
    }
}

package Test.Four;

public class Derive extends Base{
    public void func1(){
        System.out.println("Base.fun1()");
    }
    public void func2(){
        System.out.println("Base.func2()");
    }
    public void func3(){
        System.out.println("Base.func3(int,int)");
    }
    public void method(){
        //子类和基类的func1方法：访问权限 返回值类型 方法名（参数列表）这些都是相同的，只是实现体不同
        //注意：基类和子类func1的关系是重写
        //在子类中被直接调用构成重写的方法：优先子类自己的，基类的方法被调用到
        //如果要在基类中调用被重写的方法就需要使用关键字super
         func1();
         super.func1();
         //子类和基类的func2方法：只是参数列表不同，其他完全相同（访问权限、方法名字、返回值类型）
        //子类和基类的func2方法就构成了方法重载
        //编译器百衲衣代码时,就会根据传递的实参类型来确定应该调用的时基类还是子类的方法---，原理和方法重载相同
         func2();
         func2(2);
         func3();
         //super后面必需要有成员，否则报错
        //System.out.println(super);
    }
    public static void method1(){
       // System.out.println(this);静态成员方法中不能引用this关键字
        //System.out.println(super.func1(););静态方法中不能使用super关键字
    }
    public static void main(String[] args) {
        Derive d1=new Derive();
      //  d1.func1();
      //  d1.func2(8);
      //  d1.func3(9,40);
        d1.method();
    }
}