java初学者日志_04

程序设计：高内聚 低耦合。
高内聚：封装细节，便于修改内部代码
低耦合：简化外部调用，便于调用者使用，便于扩展和协作

关于protected:
1.如果父类和子类在同一个包中，子类可访问父类的protected成员，也可访问父类对象的protected成员
2.如果子类和父类不在同一个包中，子类可访问父类的protected成员，不能访问父类对象的protected成员

封装规则：
一般使用private访问权限

属性私有后（private），提供相应的get/set方法来访问相关属性，这些方法通常是public修饰的，以提供对属性的赋值于读取操作

一些只用于本类的辅助性方法可以用private修饰，希望其它类调用的方法用public修饰

package com.text.text2;
public class Person {
    private String name;
    private int age;
    private boolean flag;
    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<0||age>150) {
            System.out.println("年龄不合法");
        }else{
            this.age = age;
        }
    }
    public boolean isFlag(){
        return flag;
    }
    public void setFlag(){
        this.flag=flag;
    }
}

public class Person2 {
    public static void main(String[] args) {
        Person p=new Person();
        p.setAge(100);
        System.out.println(p.getAge());
    }
}

多态：同一个方法的调用，由于对象不同可能会有不同的行为
同一个方法的调用指的是对该方法的重写
多态的要点：
1.方法的多态，不是属性
2.多态存在的必要条件：继承 方法重写 父类引用指向子类对象
3.父类引用指向子类对象后，用该父类调用子类重写的方法

多态实例

package com.duotai;
public class animal {
    public void shout(){
            System.out.println("叫了一声");
    }
}
class dog extends animal{
    public void shout(){
        System.out.println("汪");
    }
}
class cat extends animal{
    @Override
    public void shout() {
        System.out.println("喵");
    }
}

public class test {
    static void animalCry(animal a){
        //多态！！！
        a.shout();//此时不知道使用哪个类的shout（）方法
    }
    public static void main(String[] args) {
        dog d=new dog();
        animalCry(d);
        animalCry(new cat());
    }
}

如果没有多态：

public class test {
    static void animalCry(dog a){
        //多态！！！
        a.shout();//此时不知道使用哪个类的shout（）方法
    }
    static void animalCry(cat a){
        //多态！！！
        a.shout();//此时不知道使用哪个类的shout（）方法
    }
    static void animalCry(tiger a){
        //多态！！！
        a.shout();//此时不知道使用哪个类的shout（）方法
    }
    public static void main(String[] args) {
        dog d=new dog();
        animalCry(d);
        animalCry(new cat());
    }
}

非常繁琐，多态有利于低耦合

类型的转化

package com.duotai;

public class test {
    static void animalCry(animal a){
        //多态！！！
        a.shout();//此时不知道使用哪个类的shout（）方法
    }
    public static void main(String[] args) {
        dog d=new dog();
        animalCry(d);
        animalCry(new cat());
        animal a = new dog();//向上类型转换，自动的
        //a.seedoor();//不行，编译器只认animal,只能强制类型转化
        dog d2=(dog) a;
        d2.seedoor();
/*
        cat c3=(cat) a;
        c3.cats();//cat中有没有cats()方法？有！那就通过
*/
        //改造一下，
        if(a instanceof dog){
            dog d3=(dog) a;
        }else if(a instanceof cat){
            cat c4=(cat) a;
            c4.cats();
        }
    }
}