简单的封装和多态

简单的封装

设置一定的权限，对private,protected,default,public 的运用

下面的例子可以看出，private 不可访问

package com.object.cap;
/*
这是一个简单的 javabean ,testcap1 中调用了它，可以看到一次权限设置的不同，
导致用法的不同

 */
public class Testcap {

    private String name;//Testcap1中都不可用
     int age;
    private  boolean flag;
    public String getName(){
        return  name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        if(age<0||age>150){
            System.out.println("invalid age");
        }else{
            this.age = age;
        }

    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public int getAge() {
        return age;
    }

}

package com.object.cap;

public class Testcap1 {
    public static void main(String[] args) {
        Testcap t = new Testcap();
        t.setAge(190) ;
        t.age = 19;
        System.out.println(t.getAge());

    }
}

---

多态

什么时候用呢，多个子类跟super都有相同的方法，并且都override,就可以用多态
因为各个子类都有不同点，只要parent相同，就可以通过传递child给parent来达到改变
参数，来引用方法，因为parent >child

package com.object.duotai;

public class Animal {
    public  void shout(){
        System.out.println("animal shout ");
    }
}
class Dog extends Animal{
    @Override
    public void shout() {
        System.out.println("wo wo wo");
    }
}
class  Cat extends Animal{
    @Override
    public void shout() {
        System.out.println("mow mow mow");
    }
}
class Mouse extends  Animal{


}

package com.object.duotai;

public class test {
//多态，animal 是super;dog ,cat 都是child
//如写成static void animalcry(dog a),那么每添一个子类
//就得写一个，很不方便，这个就应用而生
//static方法只能引用static方法，因为main是static ,所以main中用animalCry就必须用static
    static  void animalCry(Animal a){
        a.shout();
    }

    public static void main(String[] args) {
        Dog d= new Dog();
        animalCry(d);//animal a =d or d instanceof Animal =TRUE
        animalCry(new Cat());
        //向上类型转换，自动的,必须这一步，它可以编译通过
        //编译器只看Animal a 是否合法
       Animal a= new Dog();
       // a.watchDog()，它不能调用子类的方法，需要 通过强制转换
       System.out.println("a.shout():");
        a.shout();
       //这个是可以的，是Dog 的叫法，也就是运用了子类和super共同都有的方法
       //但是调用的子类的用法，但是如果想要用它们不同的方法的时候，就需要转换
       Dog d1= (Dog) a;//向下转换
        d1.watchDoor();
       // Cat c1 =(Cat) a;java.lang.ClassCastException,这时候a=dog
        //c1.catMouse();
        //[对象instanceof 类]意思是该对象是否（对象也称为实例）

        System.out.println(a instanceof  Dog);//true ,因为此时a=new Dog()的，它是属于Dog
        if (a instanceof Dog){
            Dog d2 = (Dog) a;
            d2.watchDoor();
        }else if(a instanceof  Cat){
            Cat c1 = (Cat) a;
            c1.catMouse();
        }



    }
}