面向对象三大特性

面向对象三大特性

封装

程序设计追求”高内聚，低耦合“。高内聚就是类的内部数据细节自己完成，不允许外部干涉；低耦合：尽量暴露少量的方法给外部使用

private关键字，属性私有，外部类无法直接调用被private修饰的属性，需要通过get、set方法来操作该属性

public class Student {
    //名字  private属性私有，外部不可直接调用
    private String name;
    //学号
    private int id;
    //性别
    private char sex;
    //学习（）
    //睡觉（）

    //提供一些可以操作这个属性的方法

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


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



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

        Student s1=new Student();

        s1.setName("夏小帅");
        System.out.println(s1.getName());
    }
    /*
    夏小帅
    */

public class Student {
    //名字  private属性私有，外部不可直接调用
    private String name;
    //学号
    private int id;
    //性别
    private char sex;
    //年龄
    private int age;
    //学习（）
    //睡觉（）

    //提供一些可以操作这个属性的方法


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    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关键字

继承是类与类之间的一种关系，一个为父类，一个为子类，子类可以继承父类的所有方法，属性(public)

java中只有单继承没有多继承

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KNGFjDMK-1630230985531)(C:\Users\夏占博\Desktop\截屏\Snipaste_2021-08-29_11-29-34.png)]

object类

在java中所有的类都默认继承Object类

Super详解

//父类
package com.OOP.Demo05;
//父类
public class Person {
    protected String name="夏小帅";

    public Person() {
        System.out.println("Person无参构造执行");
    }

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

//子类
package com.OOP.Demo05;
//子类
public class Student extends Person {
    private String name="夏展播";

    @Override
    public void print(){
        System.out.println("Student");
    }
    public void test1(String name){
        print();//Student
        this.print();//Student
        super.print();//Person,如果父类中的方法或者属性用private修饰，则无法调用
    }

    public Student() {
        //隐藏代码：调用了父类的无参构造
        super();//调用父类的构造器必须放在子类构造器的第一行
        System.out.println("Student无参构造执行");
    }
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }


}

//main方法
package com.OOP;


import com.OOP.Demo05.Student;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
//        student.test("下面人是本年度大帅哥名单：");
//        student.print();
    }



}

如果父类没有无参构造，子类也无法写无参构造

​ super注意点：

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

super和this的不同点

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

方法的重写

重写需要有继承关系，子类重写父类的方法

• 方法名必须相同
• 参数列表必须相同
• 修饰符：范围可以扩大：public>protect>Default>private
• 抛出的异常：可以被缩小，但不能扩大
• 子类的方法和父类的方法除了方法体，其余都相同

为什么要重写

• 弗雷德功能，子类不一定需要，或者不一定满足

多态

//父类
public class Person {
    public void run(){
        System.out.println("run");
    }

}

//子类
public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
    public void eat(){
        System.out.println("吃");
    }
}

//测试类
package com.OOP;

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 s2 = new Student();
        Object s3 = new Student();

        //对象能执行哪些方法，主要看对象左边的类型
        s2.run();//子类重写了父类的方法，则执行父类的方法
        s1.run();
        s1.eat();
        ((Student) s2).eat();
    }

    }
/*
son
son
吃
吃
*/

多态的注意事项：

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