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的工程师~~