java12 三大基本特性 - 封装+继承+多态

封装

- 该露的露，该藏的藏
- 我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装（数据的隐藏）
- 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
记住这句话就够了：属性私有， get/set

package com.oop;

import com.oop.dome04.Student;
/*
封装的意义
1.提高程序的安全性，保护数据

2.隐藏代码的实现细节

3.统一接口。都是getset

4.系统可维护性增加了
 */



public class Application {

    public static void main(String[] args) {

        Student student = new Student();
        student.setName("guansuo");
        System.out.println(student.getName());
        student.setAge(23);
        System.out.println(student.getAge());

    }

}

package com.oop.dome04;

public class Student {

    private String name;
    private int age;
    private char sex;

    //获得这个数据
    public String getName(){
        return this.name;
    }
    //设置这个数据
    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;
        }
    }
    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
}

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
extands的意思是“扩展”。子类是父类的扩展。
JAVA中类只有单继承，没有多继承！
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
继承关系的俩个类，一个为子类（派生类），一个为父类（基类）。
子类继承父类，使用关键字extends来表示。子类和父类之间，从意义上讲应该具有"is a”的关系，
object类

super

super注意点

super调用父类的构造方法，必须在构造方法的第一个
super必须只能出现子类的方法或构造方法中！
super和this不能同时出现

public class Student extends Person {

    public Student() {
        //隐藏代码，默认调用了父类的无参构造 super();
        super();//如果显示构造 必须在子类构造器代码的上方

        System.out.println("Student无参执行le");
    }
 }

public class Person {
    //一个类先执行无参构造
    public Person() {
        System.out.println("Person无参构造执行");
    }
}

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
    }
}

结果：
Person无参构造执行
Student无参执行le

VS this：
1. 代表的对象不同“
  
  this：本身调用者这个对象
  
  super：只能在继承条件下才可以使用
2. 前提
this：没有继承也能使用

super：只能在继承条件才可以使用
1. 构造方法
  
  this（）；本类的构造
  
  super（）：父类的构造！

方法重写：需要有继承关系，子类重写父类的方法。如果子类重写了父类就调用子类，没重写就调用父类
1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大但不能缩小 public>Protected>Default>private
4. 抛出异常：范围，可以被缩小，但不能扩大 ClassNoteFoundException --> Exception（扩大）
重写，子类的方法和父类必须一致：方法体不同

为什么要重写

父类的功能子类不一定需要，后者不一定满足。


    public static void main(String[] args) {
        //非静态方法： 重写只和非静态方法有关
        //静态方法： //方法的调用只和左边有关（定义的数据类型有关）

        /*
        静态方法是类的方法，而非静态方法是对象的方法
        有static时，b调用了B类的方法，因为b是用b类定义的
        没有static时，b调用的是对象的方法，而b是用A类new的
         */



        B b = new B();
        b.test();//B类

        //父类的引用指向了子类（爹可以new儿子）
        A a = new B();
        a.test();//静态时，是A类
        //非静态时：子类重写了父类的方法，B重写了A的方法

结果
B==>test()
B==>test()

在java中所有的类都直接或者间接的继承object类

多态

即同一方法可以根据发送的对象的不同采用多种不同的行为方式。
一个对象的实际类型确认的，但可以指向对象的引用的类型有很多（父类或者有关系的类）。
多态的存在条件。
- 有继承关系。
- 子类重写父类方法。
- 父类引用执行子类对象（强制转换）((Student)student1).eat();
注意：多态是方法的多态，属性没有多态。

instaceof （类型转换）引用类型转换，判断一个对象是什么类型。（只能判断父类或者子类别，没法判断同级别的（同级别的编译直接报错））

        //Object > Person > Student
        //Object > Person > Teacher
        //Object > String
        //System.out.println(X instanceof Y); 能否编译通过取决于X和Y有咩有父子关系


        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(person instanceof Teacher);//false
        //System.out.println(person instanceof String);//编译报错。person与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);//编译报错。student与String无关

类型转换

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

多态的注意事项
1. 多态是方法的多态，属性没有多态。
2. 父类和子类，有联系，没有关系的话会产生转换类型异常。ClassCastException
3. 存在的条件：继承关系，方法需要重写。父类引用指向子类！ Father f1 = new Son()；
  - 无法重写的
    - static 方法，属于类，它不属于实例；
    - final 常量；
    - private方法；

    public static void main(String[] args) {
       //Student能调用的方法都是自己的或者继承父类的
        Student student = new Student();
      //Person 父类型 ，可以指向子类，但是不能调用子类型独有的方法
        Person student1 = new Student();
        Object student2 = new Student();


        //对象能执行那些方法主要看左边的类型，和右边关系不大。（看左面有咩有）
        student1.run();
        student.run();//子类重写了父类的方法
        student.eat();

        ((Student)student1).eat();//父类引用子类对象（自我理解：强制类型转换）

    }
结果：
son
son
eat
eat

//子类
public class Student extends Person{

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

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

//父类
public class Person {

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

    }
}

posted @ 2022-08-14 22:30 干饭人减肥魂阅读(43) 评论(0) 收藏举报

刷新页面返回顶部

aohongchang

java12 三大基本特性 - 封装+继承+多态

封装

继承

多态

公告