面向对象04[封装详解、继承（Object类、super详解、方法重写）]

封装

• 该露的露，该藏的藏

  • 我们程序设计要追求“高内聚，低耦合”。（牢牢地记住这个开发思想！）
  • 高内聚：就是类的内部数据操作细节自己完成，不允许外部干涉。
  • 低耦合：仅暴露少量的方法给外部使用。
  • 举个栗子：（对于一个普通用户来说）电脑厂家会将那些主板、线路等复杂的部件细节封装在外壳内，而只需要将用户需要使用功能对应的部件（如：键盘、电源开关、接口）暴漏在用户的眼前即可，用户不需要知道具体的内部实现。

• 封装（数据的隐藏）

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

• 记住这句话就够了：属性私有，get/set

• 封装的意义：

  1. 提高程序的安全性，保护数据
  2. 隐藏代码的实现细节
  3. 统一接口，形成规范
  4. 提高系统的可维护性

代码实现：
1.启动类

package com.oop.demo04;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/30 9:04
 */
public class Application {
    public static void main(String[] args) {
        Student stu1 = new Student();

        stu1.setName("若梦");
        System.out.println(stu1.getName());

        stu1.setAge(999);
        System.out.println(stu1.getAge());
    }
}

2.自定义Student类

package com.oop.demo04;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/30 9:05
 */
public class Student {
    //名字 年龄 学号 性别 学习() 睡觉()
    //属性私有

    private String name;
    private int age;
    private int id;
    private char sex;
    //提供一些可以操作这个属性的方法
    //这些方法指的就是 public 的get、set方法  需要什么就get/set对应的什么

    //get获得这个数据

    public String getName(){
        return this.name;
    }

    //set 给这个数据设置值

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

    //Alt + Insert 后点 getter and setter 自动生成get、set方法


    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        int max = 130;
        if (age>max || age<0){
            //不合法
            this.age = -1;
        }else{
            this.age = age;
        }
    }

    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;
    }
}

---

继承及其Object类

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

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

• Java中类只有单继承，没有多继承！（一个子类只能继承一个父类，一个父类可以被多个子类继承，但一个子类不能继承多个父类） 举个栗子：一个儿子只能有一个血亲，不存在有一个儿子有多个血亲（不太恰当但好理解的…）

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

• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。

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

代码实现：
1.启动类

package com.oop.demo05;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/30 15:56
 */
public class Application {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.say();
        System.out.println(stu.getMoney());
    }
}

2.父类Person类

package com.oop.demo05;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/30 15:57
 */
public class Person {
	
    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;
    }
}

3.子类Student类

package com.oop.demo05;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/30 15:58
 */
public class Student extends Person{
}

4.子类Teacher类

package com.oop.demo05;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/30 15:59
 */
public class Teacher extends Person{
}

代码中继承及其Object类相关知识点：

1.Person父类（基类） Student Teacher 子类（派生类）
2.子类通过关键字extends继承父类 子类可以继承父类的所有方法
3.在Java中所有的类都默认直接或间接继承Object类（即使你不去显式地定义它继承Object），Object类具体的细节问题先不要去纠结，后面具体会学
4.public protected default private      public为公有的，protected受保护的，default默认的(即不写) ，private为私有的
5.鼠标放在类的内部，快捷键Ctrl + H ，打开当前类的hierarchy(等级制度)，即继承结构
6.在面向对象学习里接触的很多时候属性为public，但是根据我们封装的思想我们应该知道（属性私有，get/set）
7.JDK7新特性，前面我们已经学过的应该会有印象，可以用下划线将数字进行分割，例如：1_0000

对 继承及Object 的代码做下解释： 通过个stu.getMoney()得到父类中私有属性money，这个过程可以看作是子类Student继承了父类Person中的getMoney()方法，而getMoney()方法将父类Person中的属性money获取到，而非继承了父类的私有属性！父类私有的东西（属性和方法），子类是无法继承的！

当父类中只有get方法而没有set方法时，get方法所要获取的那个属性(字段)可以转换为get方法局部变量，由return直接返回给get方法。如果get/set都有，那么就不能转了，因为get获取的数据最终取决于set设置的数据！

---

super详解

代码实现：
1.启动类

package com.oop.demo06;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/30 19:07
 */
public class Application {
    public static void main(String[] args) {
        Student student = new Student();

        student.test("归零");
        student.test1();
    }
}

2.子类Student类

package com.oop.demo06;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/30 19:08
 */
public class Student extends Person{

    private String name = "guiling";

    public Student() {
        //隐藏代码 super();     子类无参构造默认调用父类的无参构造！！！
        //调用父类的构造器，必须要在子类构造器主体的第一行
        super();
        System.out.println("Student无参构造执行了");
    }

    public void print(){
        System.out.println("Student");
    }
    public void test1(){
        //调用当前类中的print方法
        print();
        //当前类中的print方法
        this.print();
        //子类调用父类的print方法
        super.print();
    }

    public void test(String name){
        //形式参数传递的name
        System.out.println(name);
        //当前Student子类的属性name
        System.out.println(this.name);
        //子类调用的父类的属性name
        System.out.println(super.name);
    }
}

3.父类Person类

package com.oop.demo06;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/30 19:10
 */
public class Person {

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

    protected String name = "ruomeng";

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

注意点：子类无参构造是默认调用父类的无参构造！如果这时，父类存在 有参构造(无参构造将会被覆盖，必须显式定义)，那么我们是无法调到父类的 无参构造的！因此，这就凸现出了使用有参构造前，先显式定义无参构造的重要性！

super调用的对象

• 父类的构造方法（this调用本类的构造方法）

super调用的位置

• 必须只能出现在子类的方法或者构造方法中！(不能在父类中用super调自己本身)

为什么子父间构造器可以实现调用

• 其实很好理解，因为子父之间必然存在继承关系，构造器同样是方法，虽然特殊点，但也和普通方法一样遵循继承规则

构造器之间调用的规则

• 1.调用必须是构造器主体中的第一条语句！2.子类可以调用自己的构造器也可以调用父类的构造器3.子父构造器间的调用必然只存在子类(利用继承关系)调用父类这一种情况。因此，super和this不能同时调用构造器，要么调用子类的构造器，要么调用父类的构造器。不能出现如下这种情况：

public Student(){
	//调用父类的无参构造
	super();
	//调用子类（自己）的有参构造
	this("hello");
}
public Student(String name){
	this.name = name;
}

super与this的区别

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

---

方法重写

1.启动类

package com.oop.demo07;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/31 20:16
 */
public class Application {
    public static void main(String[] args) {

        //方法的调用只和左边有关，定义的数据类型有关
        A a = new A();
        a.test();

        //父类的引用指向了子类   先记着，紧接着会学
        B b = new A();
        b.test();
    }
}
//使用快捷键进行方法重写时，默认调用父类的方法，删掉写自己的方法

2.子类A类

package com.oop.demo07;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/31 20:17
 */
public class A extends B{

    //Override重写  @Override注解：有功能的注释（暂时先这样理解，后面会详细讲）

    @Override
    public void test() {
        System.out.println("A=>test()");
    }
}

3.父类B类

package com.oop.demo07;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/31 20:17
 */
public class B {
    public  void test(){
        System.out.println("B=>test()");
    }
}

• 方法重写规则：
  1.方法的方法名相同
  2.参数列表必须相同
  3.修饰符：范围可以扩大，但是不能缩小 public>protected>default>private
  4.方法体的实现不同
  5.抛出的异常：范围可以被缩小，但不能扩大，更不能抛出新的异常 先了解下：无法找到类异常ClassNotFoundException 其中的Exception范围特别大的 后面再去详细讲，先有个印象
• 为什么要重写：
  父类的功能子类不一定都需要 或者 子类需要的功能父类不一定能满足，因此需要重写方法来定义自己的
• 注意点：
  1.重写是子父类才有的，必须要有继承关系，子类重写父类的方法！
  2.重写是方法的重写，和属性无关
• Idea快捷键：Alt+Inset ： Override methods

如果我的博客对你有一点点帮助，望请大侠可以给文章点个赞再走~
声明：因个人能力有限，博文中必有不足之处，望学术同仁不吝赐教！一起学习一起进步！
以上内容均为原创，转载请注明出处！