类继承实例

package com.dx.test03;
public class extendsTest {
    public static void main(String args[]) {
        // 实例化一个Cat对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息
        /********* begin *********/
        Cat cat = new Cat();
        cat.setName("大花猫");
        cat.setAge(6);

        cat.voice(cat.getName());
        cat.eat(cat.getName());

        System.out.println(cat.getName()+cat.getAge()+"岁");
        /********* end *********/

        // 实例化一个Dog对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息
        /********* begin *********/
        Dog dog =new Dog();
        dog.setName("大黑狗");
        dog.setAge(8);

        dog.voice(dog.getName());
        dog.eat(dog.getName());

        System.out.println(dog.getName()+dog.getAge()+"岁");
        /********* end *********/

    }
}

class Animal {
    /********* begin *********/
    //将属性name和age封装起来
    private String name;
    private int age;
    //外部调用实例化属性
    public void setName(String name){
        this.name = name;
    }
    public void setAge(int age){
        this.age = age;
    }
    //提供对外访问方法
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }

    /********* end *********/

}

class Cat extends Animal {
    // 定义Cat类的voice()和eat()方法
    /********* begin *********/
    public void voice(String name){
        System.out.println(name+"喵喵叫");
    }
    public void eat(String name){
        System.out.println(name+"吃鱼");
    }
    /********* end *********/
}

class Dog extends Animal {
    // 定义Dog类的voice()和eat()方法
    /********* begin *********/
    public void voice(String name){
        System.out.println(name + "汪汪叫");
    }
    public void eat(String name){
        System.out.println(name + "吃骨头");
    }
    /********* end *********/
}

super关键字

super主要的功能是完成子类调用父类中的内容，也就是调用父类中的属性或方法。
    
super关键字的使用:
1.super()可以用来引用直接父类的实例变量。//super.color
		eg:
			public class TestSuper1 {
                public static void main(String args[]) {
                    Dog d = new Dog();
                    d.printColor();
                }
            }
			//父类 color = "white"
            class Animal {
                String color = "white";
            }
			//子类 color = "black";
            class Dog extends Animal {
                String color = "black";
                void printColor() {
                    //打印Dog类的color
                    System.out.println(color);
                    //打印Animal类的color，Animal是父类，直接super.color调用
                    System.out.println(super.color);
                }
            }
                    输出结果：
                    black
                    white
		//Animal和Dog都有一个共同的属性：color。 如果我们打印color属性，它将默认打印当前类的颜色。要访			问父属性，需要使用super关键字指定。
                        
                        
2.super()可以用来调用直接父类方法。
             public class TestSuper2 {
                public static void main(String args[]) {
                    Dog d = new Dog();
                    d.work();
                }
            }
			//父类 eat方法
            class Animal {
                void eat() {
                    System.out.println("eating...");
                }
            }
			//子类 super.eat();
            class Dog extends Animal {
                void eat() {
                    System.out.println("eating bread...");
                }
                void bark() {
                    System.out.println("barking...");
                }
                void work() {
                    super.eat();			//在子类的方法中，使用super.eat()直接调用父类方法
                    bark();
                }
            }
			输出结果：
                eating...
                barking...
			//Animal和Dog两个类都有eat()方法，如果要调用Dog类中的eat()方法，它将默认调用Dog类的eat()方			法，因为当前类的优先级比父类的高。所以要调用父类方法，需要使用super关键字指定。



3.super()可以用于调用直接父类构造函数。
                public class TestSuper3 {
                    public static void main(String args[]) {
                        Dog d = new Dog();
                    }
                }
                class Animal {
                    Animal() {
                        System.out.println("animal is created");
                    }
                }
                class Dog extends Animal {
                    Dog() {
                        super();
                        System.out.println("dog is created");
                    }
                }
                输出结果：
                animal is created
                dog is created
			//如果没有使用super()或this()，则super()在每个类构造函数中由编译器自动添加。

super与this关键字的比较

super关键字（父类）：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
this关键字（自己）：指向自己的引用。
    super 或 this 调用构造方法时都需要放在首行，所以super 与 this 调用构造方法的操作是不能同时出现的。

方法重写和重载

1.方法的重写（override）；
定义：	 //子类从父类中继承方法，有时，子类需要修改父类中定义的方法的实现，这称做方法的重写；  
    	//当一个子类继承一父类，而子类中的方法与父类中的方法的名称、参数个数和类型都完全一致时，就称子类中的这个方法重写了父类中的方法。
规则：
    	//重写的方法不能比被重写的方法有更严格的访问权限;
		//重写的方法不能比被重写的方法产生更多的异常（关于异常，在后面会介绍）。

    eg:
	class Super {public String test01(String xxx,int sum){}}//访问权限 方法返回值类型 方法1（参数1）
    
	//访问权限 方法返回值类型 方法1（参数1） —————>复写父类中的方法
    class Sub extends Super{public String test01(String xxx,int sum){}}
         
         
    
2.方法的重载（overload）；
    被重载的方法必须改变参数列表(参数个数或类型不一样)；
    被重载的方法可以改变返回类型；
    被重载的方法可以改变访问修饰符；
    被重载的方法可以声明新的或更广的检查异常；
    方法能够在同一个类中或者在一个子类中被重载。
    无法以返回值类型作为重载函数的区分标准。
    
    

3.重写与重载之间的区别。