封装、继承、多态

封装

程序设计要高内聚，低耦合

封装（数据的隐藏）

• 通常应禁止直接访问一个对象中数据的实际表示，而应该通过操作接口来访问，这称为信息隐藏

属性私有，get/set

public static void main(String[] args) {
        Student s1 = new Student();

        s1.setName("秦疆");
        System.out.println(s1.getName());

        s1.setAge(17);//不合法的
        System.out.println(s1.getAge());
    }

//类     private:私有
public class Student {

    private String name;//名字

    private int id;//学号

    private char sex;//性别

    private int age;//年龄

    //提供一些可以操作这个属性的方法！
    //提供一些public的get、set方法

    //get   获得这个数据
    public String getName(){
        return this.name;
    }

    //set   给这个数据设置值
    public void setName(String name){
        this.name=name;
    }

    //alt+insert    自动生成get\set

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public char getSex() {
        return sex;
    }
    public void setSex(char sex) {
        this.sex = sex;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if (age>120 || age<0){
            this.age = 3;
        }else{
            this.age=age;
        }
    }
}

继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
• extends的意思是"扩展"。。子类是父类的扩展
• JAVA中类只有单继承，没有多继承
• 继承是类与类之间的一种关系。除此之外，类与类之间的关系还有依赖，组合，聚合等
• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示

//学生    is  人
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{

    //ctrl+h;F4		打开当前类的继承关系图
}
=============================================
//老师    is  人   派生类，子类
public class Teacher extends Person{
}
=============================================
//学生    is  人
//在Java中所有的类，都默认直接或者间接继承object
public class Person {
    //public
    //protected
    //default
    //private
    private int money = 10_0000_0000;
    public void say(){
        System.out.println("说了一句话");
    }
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }
}
=============================================
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
        System.out.println(student.getMoney());
        student.setMoney(120392879);
        System.out.println(student.getMoney());

        Person person = new Person();
    }
}

Java中的super

//学生    is  人
//在Java中所有的类，都默认直接或者间接继承object
public class Person {
//一个类重写了有参构造器，必须先写一个无参构造器，否则将报错
    public Person() {
        System.out.println("Person无参执行了");
    }

    protected String name = "kuangshen";

    //private私有的东西无法被继承
    public void print(){
        System.out.println("Person");
    }
}
==========================================================
//学生    is  人
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{

    public Student(){
        //隐藏代码，调用了父类的无参构造
        //如果父类只有有参构造器，那么必须调用有参构造器，不能调用无参构造器
        super();    //调用父类的构造器，必须要在子类构造器的第一行
        System.out.println("Student无参执行了");
    }
    private String name = "qinjiang";

    public void print(){
        System.out.println("Student");
    }
    public void test1(){
        print();
        this.print();
        super.print();
    }

    public void test(String name){
        System.out.println(name);//秦疆
        System.out.println(this.name);//qinjiang
        System.out.println(super.name);//kuangshen
    }
}
===========================================================
import com.oop.demo05.Person;
import com.oop.demo05.Student;

public class Application {
    public static void main(String[] args) {

        Student student = new Student();
        //student.test("秦疆");

        student.test1();
    }
}

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

• super与this的区别：
  代表的对象不同：
  this：本身调用者这个对象
  super：代表父类对象的应用
  前提
  this：没有继承也可以使用
  super：只能在继承条件才可以使用
  构造方法
  this();本类的构造
  super();父类的构造

方法重写

• 重写：需要有继承关系，子类重写父类的方法！
  1.方法名必须相同
  2.参数列表必须相同
  3.修饰符：范围可以扩大，但是不能缩小 private -> default -> protected -> public
  4.抛出的异常：范围，可以被缩小，但不能扩大 ClassNotFoundException -> Exception(大)
  重写，子类的方法和父类必须要一致，方法体（方法中的内容）不同

  为什么要重写：
  1.父类的功能，子类不一定需要，或者不一定满足
  alt + insert : override

public class A extends B{
    /*public static void test(){
        System.out.println("A=>test()");
    }*/
    //override  重写
    @Override   //注解：有功能的注释
    public void test() {
        System.out.println("A=>test()");
    }
}
===============================================
//重写都是方法的重写，和属性无关
public class B {
    /*public static void test(){			//静态方法
        System.out.println("B=>test()");
    }*/
    public void test(){						//非静态方法
        System.out.println("B=>test");
    }
}
================================================
import com.oop.demo05.B;
import com.oop.demo05.Person;
import com.oop.demo05.Student;

public class Application {
    //静态的方法和非静态的方法区别很大（static）
    //静态方法（有static）：方法的调用之和左边，定义的类型有关
    //非静态：重写
    public static void main(String[] args) {
        //方法的调用只和左边，定义的数据类型有关
        A a = new A();
        a.test();//A
        //父类的引用指向了子类
        B b = new A();//子类重写了父类的方法
        b.test();//B
    }
}

多态

• 动态编译：类型：可扩展性更强

• 同一方法可以根据发送对象的不同而采用多种不同的行为方式

• 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类，有关系的类）

• 多态存在的条件

  • 有继承关系
  • 子类重写父类方法
  • 父类引用类型指向子类对象

• 多态是方法的多态，属性没有多态性

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

  不能被重写的方法：

  1. static 方法，属于类，它不属于实例
  2. final 常量
  3. private 方法

• instanceof （类型转换）引用类型

public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}
=======================================================
public class Person {
    public void run(){
        System.out.println("run");
    }
}
=======================================================
import com.oop.demo06.Person;
import com.oop.demo06.Student;

public class Application {
    public static void main(String[] args) {

        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的引用类型就不确定了;父类的引用类型指向子类

        //Student能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        s2.run();//子类重写了父类的方法，执行子类的方法
        s1.run();

        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
        s1.eat();
        ((Student) s2).eat();   //Person类型转换为Student类型
    }
}

• instanceof的使用

public class Teacher extends Person{
}
===================================================================
public class Student extends Person{
    public void go(){
        System.out.println("go");
    }
}
===================================================================
public class Person {
    public void run(){
        System.out.println("run");
    }
}
===================================================================
import com.oop.demo06.Person;
import com.oop.demo06.Student;
import com.oop.demo06.Teacher;

public class Application {

    //Object > String
    //Object > Person > Teacher
    //Object > Person > Student

    public static void main(String[] args) {
        Object object = new Student();

        //System.out.println(X instanceof Y);   //X的引用类型与Y存在父子关系才能编译通过
        //引用类型 X 指向的实际对象与 Y 有父子关系才会报true

        System.out.println(object instanceof Student); //true
        System.out.println(object instanceof Person); //true
        System.out.println(object instanceof Object); //true
        System.out.println(object instanceof Teacher); //false
        System.out.println(object instanceof String); //false

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

        Person person = new Student();

        System.out.println(person instanceof Student); //true
        System.out.println(person instanceof Person); //true
        System.out.println(person instanceof Object); //true
        System.out.println(person instanceof Teacher); //false
        //System.out.println(person instanceof String); //编译报错，无直接上下级关系时就会报错

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

        Student student = new Student();

        System.out.println(student instanceof Student); //true
        System.out.println(student instanceof Person); //true
        System.out.println(student instanceof Object); //true
        //System.out.println(student instanceof Teacher); //编译报错
        //System.out.println(student instanceof String); //编译报错
    }
}

• 父类与子类引用类型转换
  • 引用类型转换：
    1.父类引用指向子类对象
    2.把子类转换为父类，向上转型，不用强制转换，可能会丢失一些方法
    3.把父类转换为子类，向下转型，强制转换
    4.方便方法的调用，减少重复代码！简洁

import com.oop.demo06.Person;
import com.oop.demo06.Student;

public class Application {
    public static void main(String[] args) {
        //类型之间的转换：基本类型转换    高-》低     强制转换

        //高                低    （父->子）
        Person obj = new Student();

        //student将这个对象转换为Student类型，我们就可以使用Student类型的方法了
        ((Student) obj).go();

        //子类转换为父类（不需强制转换），可能丢失自己的本来的一些方法
        Student student = new Student();
        student.go();
        Person person = student;//Student类型转换为Person类型
        //person.go();编译报错
    }
}