封装、继承、多态

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模

extands关键字扩展

封装

/* 封装-隐藏内部信息，通过接口访问
1、“高内聚，低耦合”-该露的露，该藏得藏  属性私有，get/set
2、提高程序的安全性，保护数据
3、隐藏代码的实现细节
4、统一接口
5、提高系统的可维护性
 */
package oop;
//类 private:私有
public class B1 {
    //对于学生有 名字，学号，性别，学习方法（），睡觉方法（）
    //属性私有
    private String name;
    private int id;
    private char sex;
    private int age;

    //提供一些可以操作这个属性得方法-提供一些public的get、set方法
    //get-获得这个数据，set-给这个数据设定值

    //Alt+insert也可以自动生成get和set
    public String getName(){ //getName和setName自动生成-遵守驼峰规则
        return this.name;
    }
    public void setName(String name){
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age<120 && age>0){
            this.age = age;
        }else{
            this.age = 3;
        }
    }
}


/*
//封装的辅助程序
//println按住加countrol  方法重载-主要看方法名和参数列表是否对应
package oop;

public class BI1 {
    public static void main(String[] args) {
        B1 b1 = new B1();
     // bi.name = "";使用得private会报红，换成public就不会
        b1.setName("小白");
        System.out.println(b1.getName());
        b1.setAge(999); //不合法的，可以在语法中辅助判断
        System.out.println(b1.getAge());
    }
}
*/

继承-extend

继承和object类

/* 继承-类跟类之间的关系（父子）  除此之外还有其他关系 object类
Control+H-打开了一个继承树
java中只有单继承，没有多继承，但可以有多个继承者
私有的东西无法被继承
在java中，所有的类都默认直接或间接继承object类
 */
package oop;
//C1 人 父类
public class C1 {
    //public-公共的，protected-受保护的，default-默认的，private-私有的 一般继承都是public,属性里才用private
    private int age = 99;
    public int money = 10_0000_0000;
    public void say(){
        System.out.println("说了一句话");
    }

}

/*
/* 辅助理解继承
1、子类继承了父类，就会拥有了父类的全部方法
 */
/* //extends
package oop;
//Student is 人 子类
public class Student extends C1 {

}
*/
package oop;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say(); //子类继承了父类，就会拥有了父类的全部方法
        System.out.println(student.money);
     //   System.out.println(student.age); //父类private,会报错
    }
}
*/

Super的定义和使用

/* super
1、super调用父类的构造方法，必须在构造方法的第一个
2、super必须只能出现在子类的方法或者构造方法中
3、super和this不能同时调用构造方法
Vs this
代表的对象不同
  this:本身调用者这个对象
  super:代表父类对象的引用
前提
   this：没有继承也可以使用
   super:只能在继承条件下才可以使用
构造方法
   this：调用本类的构造
   super:调用父类的构造
 */
/*
package oop;
//C1 人 父类
public class C1 {
    //public-公共的，protected-受保护的，default-默认的，private-私有的 一般继承都是public,属性里才用private
    protected String name = "大黑" ;
    public C1(){
        System.out.println("父类C1的无参构造器");
    }

}


*/
package oop;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.test("二黄");
    }
}
/*
//super
//Control+H-打开了一个继承树
package oop;
//Student is 人 子类
public class Student extends C1 {
    public Student(){
        super();//调用父类的构造器，必须在子类构造器的第一行； 也可以不写，它自己默认调用
        System.out.println("Student的无参执行了");
    }
    private String name = "小白";
    public void test(String name){
        System.out.println(name);//二黄
        System.out.println(this.name);//小白
        System.out.println(super.name); //大黑-子类调用父类属性

    }
}

 */

Override重写的定义和使用

/* 方法重写
1、重写都是方法的重写，和属性无关
2、重写的修饰符只能说public，不能是private
重写原因
1、父类的功能子类不一定需要或不一定满足
2、Alt+Insert-override;
重写总结：
重写子类和父类的方法必须要一致，方法体不同
1、需要有继承关系，子类重写父类的  方法
2、方法名必须相同、参数列表必须相同、修饰符：范围可以扩大，但不能缩小 public》Protected》Dewault》private
3、抛出的异常范围可以被缩小，但不能扩大：Exception(大)-->ClassNotFoundException(小）
 */
package oop;

public class Application {
    //静态方法和非静态方法输出区别很大 D2会成D1
       //静态方法:方法的调用只和左边，定义的类有关
       //非静态方法：子类重写了父类的方法
    public static void main(String[] args) {
        D1 d1 = new D1();
        d1.test();

        // 父类的引用指向了子类
        D2 d2 = new D1();
        d2.test();
    }
}


/*
package oop;

public class D1 extends D2 {
    //Overrried-重写
    @Override //注解-有功能的注释！
    public void test() {
        System.out.println("D1==>test");
    }
}
/*
    public  void test() {
        System.out.println("D1==>test");
    }
 */
*/

  
  
  
/*
package oop;

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

*/

多态

/* 多态-多种方法发生方式
1、多态是方法的多态，属性没有多态
2、父类和子类的类型应该相同 ClassCastException！-类型异常报错
3、存在的条件
          继承关系
          方法需要重写，父类引用指向子类对象
          不能重写的方法 1、static 方法 属于类，不属于实列
                      2、final 常量
                      3、private 方法
*/
package oop;

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的 如：new E2();new E1();
        //但可以指向的引用类型就不确定了
        //子类能调用的方法都是自己的或继承父类
        E2 s1 = new E2();
        E2 s2 = new E2();
        //通过父类的引用指向子类
        //父类虽然可以指向子类，但不能调用子类的方法
        E1 s3 = new E2();
        //Object 默认拥有
        Object s4 = new E2();
        //子类继承了父类的全部方法,如果子类重写了父类的方法就是走子类的程序
        s3.run();
        s1.run();
        //对象能执行那些类型，主要看左边和右边关系不大
    //  s3.eat();//此行会报错，E1里没有eat;  只用通过（（E2）s3).eat;进行强制转换
        s1.eat();

    }

}





/*
package oop;

public class E1 {
    public void run(){
        System.out.println("run");
    }
}
*/


/*
package oop;

public class E2 extends E1{
    public void run(){
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}
*/