封装 继承 多态

封装

• 该露的露 该藏的藏

  • 程序设计追求"高内聚 低耦合"

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

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

• 封装：（数据的隐藏）

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

• 属性私有 set/get

​

package com.ntru.demo.test.OOP.Demo04;

/*
封装的意义
1. 提高程序的安全性 保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 系统可维护性增加
 */
public class Application {

    public static void main(String[] args) {

        Student s1 = new Student();
        s1.name = "秦疆";
        System.out.println(s1.getName());

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

}

​

package com.ntru.demo.test.OOP.Demo04;

//类 private: 私有
public class Student {

    //名字
    public String name;//名字
    private int id;//学号
    private char sex;//性别
    private int age;

    //学号
    //性别
    //学习()
    //睡觉()

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

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

    public void getId(){
        this.id = id;
    }

    public char getSex(){
        return sex;
    }

    public int getAge(){
        return age;
    }

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

继承

• 继承的本质是对某一批类的抽象, 从而实现对现实世界更好的建模
• extends的意思是"扩展". 子类是父类的扩展
• JAVA中类只有单继承 没有多继承

package com.ntru.demo.test.OOP.Demo05;

import org.omg.CORBA.PUBLIC_MEMBER;

//person
/*
学生 is 人
 */
public class Person {

   protected String name = "kuangshen";

}

package com.ntru.demo.test.OOP.Demo05;
/*
学生 is 人
 */
//子类继承父类  就会拥有父类的全部方法
public class Student extends Person {

//ctur + H
    private String name = "qinjiang";

    public void test(String name){
        System.out.println(name);//秦疆
        System.out.println(this.name);//qinjiang
        System.out.println(super.name);//kuangsheng

    }
}

• 继承是类和类之间的一种关系. 除此之外, 类和类之间的关系还有依赖、组合、聚合等.

• 继承关系的两个类, 一个为子类(派生类), 一个为父类(基类). 子类继承父类, 使用换剪字extends来表示.

• 子类和父类之间 从意义上讲应该具有"is a"的关系

• object类

• super

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

• this

  1. 代表的对象不同

​ this:　本身调用这个对象

super: 代表父类对象的应用

前提

​ this:　没有继承也可以使用

super：　只能在继承条件下才可以使用

构造

this(); 本类的构造

super(); 父类的构造

• 方法重写

重写: 需要有继承关系, 子类重写父类的方法
  1. 方法名必须相同
  2. 参数列表必须相同
  3. 修饰符  范围可扩大  public proteced Default private
  4. 抛出的异常  范围 可以被缩小  不能被扩大
      ClassNotFoundException--> Exception


重写:　子类的方法必须和父类必须一致，　方法体不同

为什么需要重写
　１．父类的功能, 子类不一定需要， 或者不一定满足!
     Alt + Insert: override;

多态(动态编译 可扩展性)

• 即同一方法可以根据发送对象的不同而采用多种不同的行为方式
• 一个对象的实际类型是确定的, 但可以指向对象的引用类型有很多
• 多态存在的条件
  • 有继承关系
  • 子类重写父类方法
  • 父类引用指向子类对象
• 多态是方法的多态 属性没有多态性
• instance of类型转换

package com.ntru.demo.test.OOP.Demo06;

public class Person {

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


/*
多态注意事项:

1.  多态是方法的多态 属性没有多态
2.  父类和子类 有联系 类型转换异常! ClassCastException
3.  存在条件  继承关系  方法需要重写  父类的引用指向子类对象

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

package com.ntru.demo.test.OOP.Demo06;

public class Student extends Person{

    @Override
    public void run() {
        System.out.println("son");
    }

    public  void eat(){
        System.out.println("eat");
    }
}

package com.ntru.demo.test.OOP;

import com.ntru.demo.test.OOP.Demo06.Person;
import com.ntru.demo.test.OOP.Demo06.Student;

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

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

        //可以指向的引用类型不确定
        //学生的多种状态
        /*
        Student 能调用的方法都是自己的或者父类的
        Person  父类  可以指向子类, 但是不能调用子类独有的方法
         */
        Student s1 = new Student();
        Person s2 = new Student();//父类的引用指向子类的类型
        Object s3 = new Student();//父类的引用指向子类的类型

        //对象能执行哪些方法 主要看对象左边的类型  和右边关系不大
        s2.run();//子类重写了父类的方法  执行子类的方法
        //无法运行 s2.eat();
        //强制转转
        ((Student)s2).eat();//子类重写了父类的方法  执行子类的方法
        s1.run();

    }
}