面向2-封装、继承、多态、instanceof和类型转换

封装、继承、多态

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

extands关键字扩展

封装

/* 封装-隐藏内部信息，通过接口访问
属性私有，get/set get-获得这个数据，set-给这个数据设定值 Alt+insert也可以自动生成get和set
1、“高内聚，低耦合”-该露的露，该藏得藏  
2、提高程序的安全性，保护数据
3、隐藏代码的实现细节
4、统一接口
5、提高系统的可维护性
是否方法重载，对比方法名和参数列表
 */
package oop;
//类 private:私有和public对应
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;//使用时就b1.setName("小白"); System.out.println(b1.getName());
    }

    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());
    }
}
*/

继承-extends

继承和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、子类继承了父类，就会拥有了父类的全部方法
 */
package oop;
//子类
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调用父类的构造方法，必须在构造方法的第一个否则会报错；父类不写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();//new就在调用
        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 d2 = new D1();还是执行D2
       //非静态方法：子类重写了父类的方法
    public static void main(String[] args) {
        D1 d1 = new D1();
        d1.test();//输出D1==>test

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


/*
package oop;

public class D1 extends D2 {
    //Alt+Insert插入override-重写-默认调用父类的方法;
    @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 方法
          父类引用指向子类对象 E1 s3 = new E2(); //通过父类的引用E1指向子类E2
*/
package oop;

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

instanceof判断继承关系和类型转换

/* instanceof关键字-判断是否存在父子关系 简化方法调用代码
1、只能父类引用指向子类的对象
2、把子类转换为父类，向上转型； 父类转换为子类，向下转型强制转换（可能会丢失一些方法）
3、方便方法的调用，减少重复的代码！-简洁
*/
package oop;

public class Application {
    public static void main(String[] args) {
/*      //父类不能使用子类方法，父类转子类（强制转换）
        E1 obj = new E2();
    //  obj.go(); //报错
        //将obj这个对象转换E2这个类型，就可以使用obj了
        E2 e2 = (E2)obj;//强制转换
        e2.go();
*/
        //如果子类转父类可能会丢失自己本来的一些方法-没懂
        E2 e2 = new E2();
        e2.go();
        //只能父类引用指向子类的对象
        E1 e1 = e2;
     }


}


/*
   public static void main(String[] args) {
   
        //判断类型是否相同，是否存在父子关系
        // System.out.println（X instanceof Y);能不能编译通过

        Object object = new E2(); //此时object参数为左指导
        System.out.println(object instanceof E2);//true
        System.out.println(object instanceof E1);//true
        System.out.println(object instanceof E3);//False
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof String);//false

        System.out.println("====================");

        E1 e1 = new E2();
        System.out.println(e1 instanceof E2);//true
        System.out.println(e1 instanceof E1);//true
        System.out.println(e1 instanceof E3);//False
        System.out.println(e1 instanceof Object);//true
    //    System.out.println(e1 instanceof String);毫无瓜葛，编译就会报错

        System.out.println("====================");

        E2 e2 = new E2();
        System.out.println(e2 instanceof E2);//true
        System.out.println(e2 instanceof E1);//true
    //    System.out.println(e2 instanceof E3);//无瓜葛不能比较
        System.out.println(e2 instanceof Object);//true
    }
 */