No2_2.接口继承多态_Java学习笔记_继承

***类的继承***
1.继承的实现extends
2.[修饰符] class 子类名 extends 父类名{}
3.修饰符一般为：public abstract final
4.重写是指父子类之间的关系，子类的方法名与父类的方法名相，那么子类就不能继承父类的方法，称子类的方法重写了父类的方法。
5.重写体现了子类补充或者改变父类方法的能力。通过重写，可以使一个方法在不同的子类中表现出不同的行为；
6.重写民可以称为覆盖；

***使用super关键字***
1.子类可以继承父类的非私有成员变量和成员方法（非private）作为自己的成员变量和方法；
2.如果子类与父类成员变量同名，子类不能继承父类的成员变量，称：子类的成员变量隐藏了父类的成员变量；
3.如2.换成方法，称：子类成员方法重写了父类的成员方法；
4.这时，想在子类中访问父类中被隐藏的成员方法或变量，就可以用super;
5.两种用途：
a.调用父类的构造方法；子类可以调用由父类声明的构造方法，必须使用super调用；【必须写在构造方法体中吗？？？是的】
super([参数列表]);
应该为构造函数中的第一条语句；

b.操作被隐藏的成员变量和被重写的成员方法；
super.成员变量名
super.成员方法名([参数列表])

问题：super. 可以不在构造方法中使用吗，可以。但应该是写在方法体中的

import java.util.Date;
import java.util.Locale;


/**
 * @author: liu_y
 * @Date: 2016年7月3日
 * @Title:继承、继承中的重写
 */
    /********** 继承的实现 **************/
    
    class Bird {
        String color = "white";
        String skin = "羽毛";
    }
    
    class Pigeon extends Bird {
        public void pColor() {
            Pigeon p = new Pigeon();
            System.out.println("鸽子继承的鸟类的属性，颜色是：" + p.color);
        }
    }
    
    /********** 继承中的重写 **************/
    class Animal {
        public Animal() {
        }
    
        public void cry() {
            System.out.println("动物发出叫声！");
        }
    }
    
    class Dog extends Animal {
        public Dog() {
        }
    
        public void cry() {
            System.out.println("狗发出“汪汪汪”的叫声！");
        }
    }
    
    class Cat extends Animal {
        public Cat() {
        }
    
        public void cry() {
            System.out.println("罗小黑发出“喵喵喵”的叫声！");
        }
    }
    
    class Sheep extends Animal {
    
    }
    
    /********** 使用super关键字 **************/
    class Beast {
        String skin;
        int age=77;    //父类成员变量，赋值是77
        public Beast() {
            
        }
    
        public Beast(String skin) {
            this.skin = skin;
            this.age=55; //调用父类的构造方法后，赋值为55。不调用就77
        }
    
        public void move() {
            System.out.println("跑");
        }
    
        public String getSkin() {
            return skin;
        }
    }
    
    class Tiger extends Beast {
        private int age;
    
        public Tiger() {
            super("条纹"); //调用父类的构造方法，一定要放在方法的首个语句！！
            age = 33;
            super.age = 88; // 在子类中修改父类Beast的成员变量的值
            super.move(); // 在子类中调用父类Beast的成员方法（需要写在方法体中，不一定构造方法）
        }
        
        public int getSuperAge() {
            return super.age;
        }    
        public int getAge(){
            return age;
        }
    }
    
    /********** 范例：经理与员工的差异 **************/
    class Employee{
        private String name;
        private int age;
        private Date birthday;
        private double salary;
        public void setName(String name){
            this.name=name;
        }
        public String getName(){
            return name;
        }
        public void setAge(int age){
            this.age=age;
        }
        public int getAge(){
            return age;
        }
        public void setBirthday(Date birthday){
            this.birthday=birthday;            
        }
        public Date getBirthday(){
            return birthday;
        }
        public void setSalary(double salary){
            this.salary=salary;
        }
        public double getSalary(){
            return salary;
        }        
        
        public String getInfo(){
            return "我是父类：我是jm的员工~~";
        }
    }
    
    class Manager extends Employee{
        private double bonus;        //经理有奖金的哟
        public void setBonus(double bonus){
            this.bonus=bonus;            
        }
        public double getBonus(){
            return bonus;
        }
        
        @Override        //重写getInfo（）
        public String getInfo(){
            return "我是子类：我是jm的工程师~~";
        }

    }
    

public class Hello2Extends {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //继承的实现
        System.out.println("继承的实现：");
        Pigeon p=new Pigeon();
        p.pColor();

        //继承中的重写
        System.out.println("\n继承中的重写");
        Dog dog=new Dog();
        Cat cat=new Cat();
        Sheep sheep=new Sheep();
        System.out.println("执行dog.cry()时的输出结果：");
        dog.cry();
        System.out.println("执行cat.cry()时的输出结果：");
        cat.cry();
        System.out.println("执行sheep.cry()时的输出结果：");
        sheep.cry();
        
        //使用super关键字
        System.out.println("\n使用super关键字");
        Tiger tiger=new Tiger();
        System.out.println("老虎的皮肤是："+tiger.getSkin()+"；父类年龄是："+tiger.getSuperAge());
        System.out.println("老虎的皮肤是："+tiger.getSkin()+"；父类年龄是："+tiger.getAge());
        
        
        //    范例：经理与员工的差异
        Employee employee=new Employee();
        employee.setName("Sunshine");
        employee.setAge(28);
        employee.setBirthday(new Date());
        employee.setSalary(3000);
        
        Manager manager=new Manager();
        manager.setAge(30);
        manager.setName("Liuliu");
        manager.setBirthday(new Date());
        manager.setSalary(5000);
        manager.setBonus(2577.88);
        System.out.println("员工的个人信息："+employee.getName()+" "+String.format(Locale.CHINA,"%tF",new Date())
        +" "+employee.getSalary());
        System.out.println("经理的个人信息："+manager.getName()+" "+manager.getAge()+" "+manager.getSalary()+" "+manager.getBonus());
                
        
        //范例 重写父类中的方法
        System.out.println("\n重写父类中的方法");
        System.out.println(employee.getInfo());
        System.out.println(manager.getInfo());
    }
}

输出结果：

继承的实现：
鸽子继承的鸟类的属性，颜色是：white

继承中的重写
执行dog.cry()时的输出结果：
狗发出“汪汪汪”的叫声！
执行cat.cry()时的输出结果：
罗小黑发出“喵喵喵”的叫声！
执行sheep.cry()时的输出结果：
动物发出叫声！

使用super关键字
跑
老虎的皮肤是：条纹；父类年龄是：88
老虎的皮肤是：条纹；父类年龄是：33
员工的个人信息：Sunshine 2016-07-04 3000.0
经理的个人信息：Liuliu 30 5000.0 2577.88

重写父类中的方法
我是父类：我是jm的员工~~
我是子类：我是jm的工程师~~