21、封装、继承、多态

内容：

问题描述：

1、封装

@Override
      /*
1.提高程序的安全感，保护数据
2.隐藏代码的实现细节
3.统一接口
4、系统可维护性增加了  有时候在set那边做一些安全性的验证
 */
//类 public 公有的；private 私有的。
public class Student{
       //属性私有
                //名字
        private String name;
                //学号
        private int id;
                //性别
        private char sex;

    //提供一些可以操作私有属性的方法
        //提供一些public 的get、set方法
        //get 获得这个数据
        public String getName(){
                return this.name;
        }
        //set 给这个数据设计值
        public String setName(String name){
                this.name=name;
                return this.name;
        }

    public int getId() {

        return id;
    }

    public void setId(int id) {
        if (id < 10) {
            this.id = id;
            System.out.println(id);
        } else {
            System.out.println("输入年龄错误！");
        }
    }
}

@Override
       public class APP {
    public static void main(String[] args){
        Student s1=new Student();
        s1.setName("小明");
        System.out.println(s1.getName());

        s1.setId(100);//不合法的学号

    }
}

2、继承

//Student 继承Person
public class Student extends Person{
}

public class Person {

    //如果改为私有的private,将会不能给子类使用

    public int money=100_000_000_0;
    public void say(){
        System.out.println("说了一句话");
    }
}

@Override
        public void run() {
            bytes = mmInStream.read(buffer);
            mHandler.obtainMessage(READ_DATA, bytes, -1, buffer).sendToTarget();
        }

//子类是父类的扩展，就是人，把人扩展为老师和学生两个分类，人：父类，学生、老师：子类
//java中，所有的类，都默认直接或者间接继承object类

//子类继承了父类（只能继承一个父类），就会继承父类的全部方法

public class APP {
    public static void main(String[] args){
        Student student = new Student();     //new Student()加alt和enter
        student.say();
        System.out.println(student.money);
    }
}

3、(继承里的内容)super

//Student 继承Person
public class Student extends Person{
    private String name="dahai";
    //子类的print方法
    public void print(){
        System.out.println("Student");
    }
    public void test1(){
     print();              //student
     this.print();            //student
     super.print();      //person
    }
    public void test(String name){
        System.out.println(name);          //小海 输出引用这个方法name的结果
        System.out.println(this.name);     //dahai   输出这个类的name的结果
        System.out.println(super.name);     //zhonghai   输出这个类的父类的name的结果
    }
}

public class Person {
    public Person(){
        System.out.println("person无参执行了");
    }
    protected String name ="zhonghai";

    //父类里的print方法
    public void print(){
        System.out.println("person");
    }
}

//子类是父类的扩展，就是人，把人扩展为老师和学生两个分类，人：父类，学生、老师：子类
//java中，所有的类，都默认直接或者间接继承object类

//子类继承了父类（只能继承一个父类），就会继承父类的全部方法
//父类先执行，后到子类，也就是super();调用父类构造器，必须在子类构造器的第一行，一般不写的话，都会默认这样
//具体可以看狂神说java的java零基础学习视频面向对象10：Super详解

public class APP {
    public static void main(String[] args){
        Student student = new Student();
        student.test("小海");
        student.test1();
    }
}

4、（继承里的内容）方法重写—>多态

public class A extends B{
    public static void test(){
        System.out.println("A=>test()");
    }
}

public class B {
    public static void test(){
        System.out.println("B=>test()");
    }
}

/*
重写：需要有继承关系，子类重写父类的方法！(子类的方法和父类必须一致，方法体不同）
1、方法名必须相同
2、参数列表必须相同
3、修饰符：范围可以扩大但不能缩小 public>Protected>Default>private
4、抛出的异常：范围，可以被缩小，但不能扩大
为啥要重写：
1、父类的功能，子类不一定需要，或者不一定满足！
Alt+Insert; override;
 */
public class APP {
    public static void main(String[] args){
        /*A类、B类如果不是静态方法(static)的话,下面会输出：
        A=>test()
        A=>test()
        如果是静态的话,调用方法只和左边，定义的数据有关，像下面的A a=new A();与A类有关；和B b=new A();与B类有关；
        A=>test()
        B=>test()
         */
       A a=new A();
        a.test();   //A类
        //父类的引用指向了子类
       B b=new A();      //子类重写父类的方法
        b.test();    //B类
    }
}

5、多态

public class Person{
    public void run(){
        System.out.println("run");
    }
}
/*
多态注意事项：
1、多态是方法的多态，属性没有多态
2、父类子类，有联系  》类型转换异常！ClassCastException!
3、存在的条件：继承关系，方法需要重写
 */
/*
那些方法不能被重写
1、static 方法，属于类，它不属于实例
2、final 常量
3、private方法
 */

public class Student extends Person{
    //一个对象的实际类型是确定的
    //可以指向的引用类型就不确定了：父类的引用指向子类
    public void run(){
        System.out.println("son");
    }
}

import com.company.Person;
import com.company.Student;

public class APP {
    public static void main(String[] args){
        //一个对象的实际类型是确定的
        //可以指向的引用类型就不确定了：父类的引用指向子类
        //Student 能调用的方法都是自己的或者继承父类的

        Student s1=new Student();
        //Person 父类型，可以指向子类，但不能调用子类”独有的“法
        Person s2=new Student();    //父类的引用指向子类的类型,可以调用父类的方法
        /*对象能执行那些方法，主要看对象左边的类型，和右边关系不大
        如果子类（student）重构了方法，那用子类的方法（重点)
        如果只有子类有那个方法，父类没有，那就是不能进行Person s2=new Student(); 这个语句
         */
        s2.run();
    }
}

---