面向对象（二）

面向对象之封装，继承，多态

一.封装

封装的八字精髓：“隐藏属性，暴漏方法”
封装的含义：隐藏对象内部的复杂性，只对外公开简单的接口，便于外界使用，从而提高系统的扩展性、可维护性

• this的关键字
  1、this调用本类中的属性，也就是类中的成员变量
  2、this调用本类中的其他方法
  3、this调用本类中的其他构造方法，调用时要放在构造方法的首行

public calss Person{
     private String name;
     private int age;

      public Person(){}
      public Person(String name; int name age) {
           this.setName(name);
           this.setAge(age);
}
public String getName(){
      return this.name;
}
public String setName(){
     this.name = name; 
}
public int getAge(){
     return this.age;
}
public void setAge(int age) {
   if(age < 0 || age > 150){
   System.out.println("年龄输入有误");
   }else{
      this.age = age;
   }
}
}

• 使用访问权限修饰符，实现封装
  Java用于限定其他对象对该类内部定义的访问权限
  有public、protected 、private、default（不写）四个
  
  对于class的权限只能使用public 或 default （不写）
  如何实现封装？
  修改属性的可见性来限制对属性的访问。为每个属性创建一对赋值方法和取值方法，用于对这些属性的访问。
  在赋值和取值方法中，加入对属性的存取的限制

public class Person {
private String name;
private int age;
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public int getAge() {
    return age;
}
public void setAge(int age) {
    if(age > 200){
               throw new RuntimeException("老妖怪....");
    }
    this.age = age;
}
}

二.继承（extends）

java继承：
1、Java只支持单继承，也就是只能继承一个类
2、如果一个类没有声明继承关系，默认继承Object类
3、子类继承父类全部的操作（除了构造方法），如果父类中的属性是private的，属于隐
式继承，不能直接 操作，可以通过set、get方法进行操作
在子类中，可以根据需要对从基类中继承来的方法进行重写
重写方法必须和被重写方法具有相同的方法名称、参数列表、和返回类型
重写方法不能使用比被重写方法更更严格的访问权限

public class Animal {
private String name;
private int age;

public void shout(){
    System.out.println("动物会叫..");
}
}


public class Dog extends Animal{
public void eat() {
    System.out.println("我吃骨头...");
}

@Override
public void shout() {
    System.out.println("汪汪。。汪汪。。。");
}
}

继承：是面向对象的最显著的一个特征。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力
比如上面的动物类，每一个动物都有名字和年龄，都能叫，都会吃。但是具体每一种动物，又有自己特有的属性和行为，甚至相同的行为，也有千差万别。
继承是对某一批类的抽象，从而实现对现实世界更好的建模
提高代码的复用性
子类继承父类的语法格式如下：

修饰符 class subclass extends superclass {…..}
public class Animal {
private String name;
private int age;

public void shout()
    System.out.println("你的叫声很好听..");
}
//省略get、set方法
}


public class Dog extends Animal{
public void eat() {
         System.out.println("我吃骨头...");
}
}

Super：是直接父类对象的引用可以通过super访问父类汇中被子类覆盖的方法或属性
普通方法：没有顺序，任意调用
构造方法：任何类的构造方法中，如果构造方法中没有显示的调用super(…),那么Java会默认调用super()作为父类的初始化方法，所以在写不写super()方法，没有关系

多态（Polymorphism）

多态存在的三个必要条件：

• 继承
• 重写
• 父类引用指向子类对象
  多态可以提高代码的拓展性

多态性是指允许不同软件元素对同一消息作出响应
把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。
赋值之后，父类型的引用就可以根据当前赋值给它的子对象的特性以不同的方式运作。也就是说，父亲的行为像儿子，而不是儿子的行为像父亲
执行期间（非编译期）判断所引用的实际类型，根基其实际类型调用相应的方法。

class Animal{
      public String name;
      public Animal(String name){
           this.name = name;
      }
}


class Dog extends Animal{
      public String folorColor;
      public Dog(String name,StringfolorColor){
           super(name); this.folorColor = folorColor;
       }
}



class Cat extends Animal{
       public String eyesColor;
       public Cat(String name,String eyesColor){
             super(name); this.eyesColor = eyesColor;
       }
}



public class TestCasting{
     public static void main(String args[]){
         Animal a = new Animal("a");
         Cat c = new Cat("c","cEyesColor");
         Dog d = new Dog("d","dForlorColor");                 
         System.out.println(a instanceof Animal); //true      
         System.out.println(c instanceof Animal); //true     
         System.out.println(d instanceof Animal); //true
         System.out.println(a instanceof Dog); //false
         a = new Dog("d2","d2ForlorColor"); //父类引用指向子类对象，向上转型
         System.out.println(a.name); //可以访问            
         //System.out.println(a.folorColor);
         //!error 不可以访问超出Animal自身的任何属性
         System.out.println(a instanceof Animal); //是一只动物       System.out.println(a instanceof Dog); //是一只狗，但是不能访问狗里面的属性      
          Dog d2 = (Dog)a; //强制转换
          System.out.println(d2.folorColor); //将a强制转换之后，就可以访问狗里面的属性了
     }