封装继承多态，方法重载覆盖

封装
用private将不需要被外界访问到的属性／方法隐藏起来
封装的好处？
    类的开发者：让数据得到保护，从而更加的安全
    类的使用者：将精力放在核心业务逻辑上
封装对属性的要求：
   所有的属性必须用private修饰，每个属性配套提供两个public修饰的方法，一个是给属性赋值的方法-->setter，一个是得到属性值的方法-->getter
封装对方法的要求：
    需要判断哪些方法是核心方法
    核心方法--> public 修饰
    给核心方法提供服务的方法 --> private修饰

public class Test01{
    public static void main(String[] args){
        Student stu = new Student();
        stu.setName("张三");
        stu.setAge(22);
        System.our.println(stu.getName);
        System.out.println(stu.getAge);
        stu.test();
    }
}
class Student{
    //1.每个属性前面加private
    //2.每个属性配套提供两个public方法
    //3.如果要封装方法的画，本类中需要提供访问封装方法的方法
    private String name;
    private int age;
    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;
    }
    private void study(){
        System.out.println("学生爱学习");
    }
    public void test(){
        study();
        System.out.println("对外公开的方法");
    }
}

继承
用extends实现两个类（子类 父类）之间is a（是一个 是一种）的关系

public class Test02{
    public static void main(String[] args){
        Cat cc = new Cat();
        cc.setName = "HelloKitty";
        System.out.println(cc.getName);
    }
}
class Animal{
    private String name;
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
}
class Cat extends Animal{}
当我们写多个类的时候，多个类里面都有公共代码，一般会把公共代码放在父类，子类通过继承得到
*：继承是最简单的实现代码共享方式之一
*：java中的类只能是单根继承 -->一个类只能同时继承一个类型
    class A{}
    class B{}
    class C extends A,B{} //报错
面试题：
    父类中的所有属性都会被子类继承得到么？
父类中的私有属性在子类的内存空间里面存在，但是不能继续使用(子类对象.属性)，所以不能算是继承得到

多态
一个事物总有不同称呼他的类型
一个对象总有不同的类型去定义他
多态的第一个作用：创建对象
    父类类型 = new 子类对象；
    Animal cc = new Dog();
public class Test03{
    public static void main(String[] args){
        Animal dd = new Dog();
        dd.eat();// 打印 小狗吃屎
        dd.play();//编译报错 父类中没有play()方法
    }
}
class Animal{
    public void eat(){
        System.out.println("动物吃食物");
    }
}
class Dog extends Animal{
    public void eat(){
        System.out.println("小狗吃屎");
    }
    public void play(){
        System.out.println("小狗爱玩耍");
    }
}
当我们利用多态创建一个对象之后，这个对象只能调用父类有的属性／方法，一旦调用
子类特有的属性／方法，都会编译报错
*：在编译的时候 编译器只看等号左边进行语法检查，发现dd类型是Animal类型，没有play()方法，所以报错
*：在运行的时候 一个对象属于什么类型决定他能调用哪些方法

多态的第二个作用：放在参数里面用于解除代码之间的耦合度
    方法定义：test(父类类型)
    方法调用：test(子类对象)
public class Test04{
    public static void main(String[] args){
        Etoak v5 = new Etoak();
        Restaurant re = new Restaurant();
        re.service(v5); //打印 正常就餐

        Chinese cn = new Chinese();
        re.service(cn); //打印 正常就餐
    }
}
class Restaurant{
    public void service(Person x){
        System.out.println("正常就餐");
    }
}
class Person{}
class Chinese extends Person{}
class Etoak extends Person{}
class A extends Person{}

方法重载
方法重载又叫做方法过载，Overload Overloading Overloaded
public class Test05{
    public static void main(String[] args){
        test(45.5);
    }
    //同类 方法名相同 方法参数不同
    public static void test(int x){
        System.out.println("传递int参数");
    }
    public static void test(String y){
        System.out.println("传递String参数");
    }
}
方法重载的条件：
1.需要发生在同一个类体中
2.方法的名字必须一模一样
3.方法的参数不同
    参数的类型不同
    参数的个数不同
    参数的顺序不同
        *：参数的名字不同不能算是不同 -> 参数的名字不被保存在.class文件中
*：方法重载对返回类型和修饰符没有要求 可以一样 也可以不一样
*：方法重载的作用？
    同时满足用户的不同需求
public class Test06{
    public static void main(String[] args){
        //问：下面的代码存在方法重载么？
        //答：存在
        //______和________满足方法重载
        //答：B类从A类中继承得到的test方法与B类自己的test方法满足方法重载
    }
}
class A{
    public void test(){
        System.out.println("A类中的test()方法");
    }
}
class B extends A{
    //test()
    public void test(int x){
        System.out.println("B类中的test()的方法");
    }
}
注意：test(int x,int y)与test(int y,int x)不是方法重载，他们是同一个方法，因为变量在编译时不会存在于.class文件中，无法通过变量名来判断方法参数的不同

方法覆盖
方法覆盖又叫做方法重写 Override
面试题：方法覆盖的条件？
    需要发生在有继承关系的两个类中，而且是在子类类型当中
    （子类继承得到父类的某些方法之后，觉得父类的方法实现得不好，于是在子类中重新实现一下）
    public void test() throws Exception{}
           |           |
      脑袋      躯干           尾巴
    脑袋：访问权限修饰符 >= 父类的访问全县修饰符（public > protected > default > private）
        Sun公司认为子类重新实现的方法应该更加优秀，更加优秀的方法应该给更多的人使用 这样才有利于java的发展
    躯干：返回类型 + 方法签名
        方法签名必须一模一样
        返回类型：
        jdk5.0之前 一模一样
        jdk5.0之后 返回类型可以变 但只能变成父类方法返回类型的子类类型 -> 协变返回类型
    尾巴：异常处理部分 <= 父类的异常（范围 不是个数）
        Sun公司认为子类重新实现的方法 应该更加优秀 更加优秀的方法不应该有更多的隐患

面试题：父类抛出一个异常 子类能不能抛出2、3个异常？
    能 必须保证子类抛出的所有异常范围都比父类的异常小

*：在jdk5.0开始 方法覆盖的时候可以加@Override，表示子类的这个方法一定要覆盖父类的某个方法
*：在jdk5.0开始 方法覆盖的时候其实返回类型可以改变了 可以变成父类方法返回类型的子类类型 ->协变返回类型
public class Test07{
    public static void main(String[] args){
        Dog dd = new Dog();
        dd.eat();   //打印 狗吃屎
    }
}
class Animal{
    public void eat(){
        System.out.println("动物要吃食物");
    }
}
class Dog extends Animal{
    @Override
    public void eat(){
        System.out.println("狗吃屎");
    }
}
面试题：Override 与 Overload之间的区别？
1.表示含义不一样
    Override表示方法覆盖 Overload表示方法重载
2.发生的位置不同
    Override发生在有继承关系的子类中 Overload必须发生在同一个类体中
3.返回类型要求不一样
    Override：分版本
        jdk5.0之前： 一模一样
        jdk5.0开始： 协变返回类型
    Overload：无要求
4.方法参数要求不一样
    Override：参数必须和父类的完全一样
    Overload：参数必须不同