JAVA封装、继承和多态详解

封装

• 该露的露，该藏的藏

  • 追求"高内聚，低耦合"。

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

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

• 封装（数据的隐藏）

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

• 属性私有：private；get/set

//类 private：私有
public class Student {
​
    //属性私有
    private String name;//姓名
    private int age;//年龄
​
    //快捷键 alt+insert
    //public 让值可以被调用
    //get 获得这个数据
    public String getName() {
        return name;
    }
​
    //set 给这个数据设置值
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        if (age > 120 || age < 0) {
            System.out.println("年龄不合法");
        }
            return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
}
​
/*
//1.提高程序得安全性，保护数据
//2.隐藏代码的实现细节
//3.统一接口
//4.系统可维护增加了
​
public class Application {
    public static void main(String[] args) {
​
​
        Student xm = new Student();
        xm.setName("小明");//赋值name
        xm.setAge(-1);//赋值不合法
        System.out.println(xm.getName());
        System.out.println(xm.getAge());
    }
}
 */

继承

• 继承的本质是对某一批类的抽象

• extends的意思是"扩展"。子类是父类的扩展

• JAVA中类只有单继承，没有多继承

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

• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，要用extends

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

//在JAVA中，所有的类，都默认直接或间接继承Object
//Person 人   父类
public class Person /*extends Object*/ {
​
    //public
    //protected
    //default
    //private
​
    public String name;//默认是default
    private int age;//私有的属性无法继承,可以使用方法调用
​
    public  void  say(){
        System.out.println("说了一句话");
    }
​
    public int getAge() {
        return age = 1_0000_0000 ;
    }
}
​
/*
// 学生  is  人   子类（派生类）
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{
}
*/
​
​
/*
public class Application {
    public static void main(String[] args) {
​
​
        Student student = new Student();
        student.say();
        System.out.println(student.getAge());
​
    }
}
 */

• super和this

  1. super调用父类的构造方法，必须在构造方法的第一个

  2. super必须只能出现在子类的方法或者构造方法中

  3. super和this不能同时调用构造方法

  4. super和this区别

     • 代表的对象不同：

       this：本身调用者这个对象

       super：代表父类对象的应用

     • 前提：

       this：没有继承也可以使用

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

     • 构造方法：

       this()：本类的构造

       super()：父类的构造

public class Student extends Person {
    private String name = "学习";
​
    public Student() {
        //隐藏代码super()：调用了父类的无参构造
        super();//调用父类的构造器，必须在子类构造器的第一行
        System.out.println("Student无参执行了");
    }
​
    public void print(){
        System.out.println("Student");
    }
​
    public void test (String name) {
        System.out.println(name);//天天
        System.out.println(this.name);//学习
        System.out.println(super.name);//教学
    }
​
    public void test1(){
        print();//Student
        this.print();//Student
        super.print();//Person
​
    }
}
​
/*
public class Person {
    protected String name = "教学";
​
    public Person() {
        System.out.println("Person无参执行了");
    }
​
    public void print () {
        System.out.println("Person");
    }
}
​
 
 /*
public class Application {
    public static void main(String[] args) {
​
        Student student = new Student();
        student.test("天天");
        student.test1();
​
​
    }
}
*/

• 重写：需要有继承关系，子类重写父类的方法；Override 重写 快捷键：alt+insert

  1. 方法名必须相同

  2. 参数列表列表必须相同

  3. 修饰符：范围可以扩大但不能缩小： public>Protected>Default>private

  4. 抛出的异常：范围可以缩小但不能扩大：classNotFoundException - - > Exception(大)

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

• 为什么要重写：父类的功能，子类不一定需要，或者不一定满足

public class Application {
    public static void main(String[] args) {
​
        //静态方法：方法的调用只和左边有关，定义的数据类型有关
        A a = new A();
        a.test();//A
        a.test1();//A
​
        //父类的引用指向了子类
        B b = new A();//子类重写了父类的方法
        b.test();//A
        b.test1();//B
​
    }
}
​
/*
静态方法是类的方法，非静态是对象的方法
有static，b调用了B类的方法，因为b是用b类定义的
没有static，b调用了A对象的方法，b是用A类new的
 */
​
/*
public class A extends B {
​
    //Override 重写 快捷键：alt+insert
    @Override//注解：有功能的注释
    public void test() {
        System.out.println("A");;
    }
    public static void test1(){
        System.out.println("A");
    }
}
 */
​
/*
//重写都是方法的重写，和属性无关
public class B {
​
    public  void test (){
        System.out.println("B");
    }
​
    public static void test1(){
        System.out.println("B");
    }
}
 */

多态

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

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

• 多态存在的条件

  • 有继承关系

  • 子类重写父类方法

  • 父类引用指向子类对象

• 注意：多态是方法的多态，属性没有多态性。

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();
​
​
        s1.run();//Student
        s2.run();//Student  子类重写了父类的方法，执行子类的方法
​
        //对象能执行哪些方法，主要是看对象左边的类型，跟右边关系不大
        s1.eat();
        ((Student)s2).eat();
    }
}
​
/*
public class Person {
​
    public void run() {
        System.out.println("Person");
    }
}
 */
​
/*
public class Student extends Person{
​
    @Override
    public void run() {
        System.out.println("Student");
    }
​
    public  void eat(){
        System.out.println("eat");
    }
}
​
 */
​
/*
多态的注意事项：
1.多态是方法的多态，属性没有多态
2.父类和子类，有联系  类型转换异常  classCastException
3.存在条件：有继承关系，方法需要重写，父类引用指向子类对象  Father f1 = new Son()
4.无法重写的方法：
    1.static 方法，属于类，它不属于实例
    2.final 常量
    3.private 私有 
 */

• instanceof (类型转换)

public class Application {
    public static void main(String[] args) {
        
        /*
        Object > String
        Object > Person > Studet
        Object > Person > Teacher
         */
​
        //System.out.println(x instanceof y);能不能编译通过 x和y存不存在父子关系；是否为true主要看x
        
        Object object = new Student();
​
        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(object 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);编译错误
        
        
        //高              低
        Person s1 = new Student();
        s1.run();
        //将这个对象转换为子类Student类型，就能使用Student的方法
        ((Student)s1).go();//父转子，强制转换
​
        Student s2 = new Student();
        s2.run();//子转父，自动转换
        s2.go();
​
        //Student s2 = new Person(); 编译错误，子类引用不能指向父类的对象
    }
}
​
/*
public class Person {
​
    public void run() {
        System.out.println("Person");
    }
}
*/
​
/*
public class Student extends Person{
    public void go (){
    }
}
*/
​
/*
public class Teacher extends  Person {
}
*/