10.JAVASE中的封装继承和多态

封装

俗意：该露的露，该藏得藏

程序要求高内聚低耦合

高内聚：就是类的内部数据操作细节自己完成，不允许外部干涉。

低耦合：仅暴露少量的方法给外部使用。

一个java属性私有，另一个程序就无法调用了，这个时候使用set/get

get/set提供一些可以操作这个属性得方法。提供一些public使用的get/set的方法

get：获取这个数据 set ：给这个数据设置值

package OOP2;
public class Demo1 {
    private String name; //名字
    private int id; //学号
    private char sex; //性别
    private int age;
    public String getName() {
        return this.name;     //试了下和下面return name;也可以
    }
    //set给这个数据设置值
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if (age > 120 || age < 0) { //不合法
            this.age = 3;
        } else {
            this.age = age;
        }

    }
}

package OOP2;
/*
1.提高程序的安全性，保护数据
2.隐藏代码的实现性
3.统一接口
4.系统可维护性增强了
 */
public class Demo1Packaging {
    public static void main(String[] args) {

        Demo1 s1 = new Demo1();
        s1.setName("liuyyy");
        System.out.println(s1.getName());
        s1.setAge(999); //999岁不合法   set里面设置安全性的验证
        s1.setAge(70);
        System.out.println(s1.getAge());
    }
}



输出：
liuyyy
70

继承

在java中所有的类都默认直接或者间接继承Object 。
java中只有单继承没有多继承：一爸爸多儿子，一儿子只有一爸爸
继承：对一批类的抽象，extends扩展。子类是父类的扩展
继承是类和类之间的关系。
子类继承父类，就会用有父类的全部方法。

public class 子 extends 父 {}

例题代码实现如下：

父类

package OOP2;
public class Demo2Father {
  private int money =10_000_00000;   //要是public改为private子类就不能使用了
    public  static  void say(){                   //默认不写就是 default
        System.out.println("说了一句话");  //protected
    }
}

子类

package OOP2;
public class Demo2Son extends Demo2Father {
}

实现

package OOP2;
public class Demo2Inherit {
    public static void main(String[] args) {
        Demo2Son demo2 = new Demo2Son();
   Demo2Son.say();
        //ctrl+h  当父类设置private
    }
}

super注意点:
1.调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造方法中！
3.super和this不能同时调用构造方法

Vs this：
   代表对象的不同：
   this：本身调用者这个对象
   super：代表父类对象的应用
   前提
   this：没有继承也可以使用
   super：只能在继承条件下才可以使用
   构造方法：
   this（）；本类的构造
   super（）；父类的构造！

例如：

父类

package OOP2;
public class Demo3Father {
    public Demo3Father(String  name) {  //有参构造
        System.out.println("person执行了");
    }
  protected  String name="刘洋";
    public void print(){
        System.out.println("person");
    }
}

子类

package OOP2;
public class Demo3Son extends Demo3Father {
    public Demo3Son() {
        super("name");
        System.out.println("有参执行了");
    }
        //隐藏代码，默认调用了父类的无参构造
       // super(); //调用父类的构造器必须要在子类的第一行，
        // super（）；不写也行默认
    private  String name ="liuyang";
    public  void print(){
        System.out.println("student");
    }
    public void text1(){
      print();  //student
      this.print();  //student 上面的
      super.print();  //super父类的
    }
    public void text(String name){
        System.out.println(name);
        System.out.println(this.name);  //这个是上面的
        System.out.println(super.name); //super这个是父类的
    }
}

执行：

package OOP2;

public class Demo3Text {
    public static void main(String[] args) {
        Demo3Son demo3Son = new Demo3Son();
 demo3Son.text1();

输出：
person执行了
有参执行了
student
student
person

override重写

快捷键：alt +fn+insert

子类重写父类，执行子类父类变量名一样，若输出父类变成输出子类。

子类

package OOP2;
//继承关系
public class Demo4A extends Demo4B {
//override重写
    @Override
    public void text() {
        System.out.println("A->test");
    }
}

父类 

package OOP2;
//重写都是方法的重写，和属性无关
public class Demo4B {
    public   void text(){
        System.out.println("B=>test()");
    }
}

 执行

package OOP2;
//非静态才叫重写，没有static ，还有就是public不能是私有的
public class Demo4Application {
    public static void main(String[] args) {
        //方法的调用只和左边，定义的数据类型有关
        Demo4A demo4A = new Demo4A();
        demo4A.text();//A

        //因为有继承关系，父类的引用指向了子类
        Demo4B demo4B = new Demo4A();  //子类重写了父类的方法
        demo4B.text();  //B

        //静态的方法和非静态的方法有区别
        //4A和4B加了statics.
          //输出结果就是就是下面一个A->test一个B->test


    }
}

输出：
A->test
A->test

多态

多态注意事项
1.多态是方法的多态，属性没有多态
2.父类和子类， 有联系   类型转换异常：ClassCastException！
3.存在的条件：
继承关系
方法需要重写，
父类的引用指向子类对象！  father f1 = new Son（）：

下面三个不能重写
1.static 方法：属于类，它不属于实例
2.final 常量
3.private

子类  运用了重写

package OOP2;

public class Demo5Student extends Demo5Person {
    @Override   //fn+alt+insert 重写方法
    public void run() {
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");};
}

父类：

package OOP2;

public class Demo5Person {
    public void run(){
        System.out.println("好好听课认真学习");

    }
}

执行：

package OOP2;
//多态
public class Demo5Text {
    public static void main(String[] args) {
      //一个对象的实际类型是确定的

        //new Demo5Student();
        //new Demo5Person();

        //可以指向的引用类型就不确定了
        Demo5Student s1 = new Demo5Student();
        Demo5Person s2 = new Demo5Student(); //父类的引用指向子类的类型
       Object s3 = new Demo5Student();  //在java中所有的类都默认直接或者间接继承Object



        s2.run();  //son
        s1.run();//son   因为子类重写父类的方法，执行子类，
       // 子类没有父类有，执行父类
        s1.eat();

        ((Demo5Student) s2).eat(); //强制转换 s2.eat（）；
    }
}
输出：
son
son
eat
eat

强制转换

1.父类的引用指向子类的对象
2.把子类转化为父类，向上转型
3.把父类转换为子类，向下转型，强制转换
4.方便方法的调用，减少重复的代码，使代码简洁

子类

package OOP3;

public class ly1Student  extends  ly1Person{
    public void go(){
        System.out.println("go");
    }
}

父类

package OOP3;

public class ly1Person {
    public void run(){
        System.out.println("run");
    }
}

执行

package OOP3;

import org.omg.CORBA.Object;

//instanceof和类型转换。
public class ly1Text {
    public static void main(String[] args) {
        //类型之间的转换。基本类型转换，父类（高） 子类（低）
        //高到低不要强制转换，低到高要

        //高                          / /低
        ly1Person Student = new ly1Student();
  // Studet将这个对象转化为ly1Student类型，我们就可以使用student类型的方法了。
        ly1Student student = (ly1Student) Student;   //这样就可以使用go方法
        student.go();             //前一例题，运用强制转换


        //子类转换为父类，可能会丢失自己本来的一些方法
    }
}

输出
go