Java基础----面向对象编程OOP之三

老丁家的加菲猫

已于 2022-02-07 14:55:22 修改

阅读量602

点赞数 1

文章标签： java 开发语言后端

于 2022-01-31 10:50:10 首次发布

本文链接：https://blog.csdn.net/gmdjx2012/article/details/122758575

版权

8.封装—OOP特征之一

封装 Encapsulation

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

public class Application {
    public static void main(String[] args) {
        Student student01 = new Student();
        student01.setName("lding");
        System.out.println(student01.getName());
    }
}

//类  private 私有
//封装大多是对属性来讲的：属性私有
public class Student {
    //属性私有：private属性，只能本类才能访问，其他类都访问不了
    private String name;    //姓名:name
    private int id;     //学号:id
    private char sex;   //性别:sex

    //对外提供属性的公共访问方法！
    //提供一些public的get/set方法，用于取值/赋值
    //get：获取数据的值
    public String getName() {
        return this.name;
    }
    // set：设置数据的值
    public void setName(String name) {
        this.name = name;
    }
}

封装的意义
- 提高程序的安全性，保护数据
- 隐藏代码细节，可以在set中进行代码处理
- 统一接口（get/set）
- 系统的可维护性增加了，内部的结构可以自由修改
方法的重载：如println();方法，有好多个方法重载！

9.继承—OOP特征之二

继承extends
- 继承是Java面向对象编程技术的基石，因为它允许创建分等级层次的类
- 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
- extends的意思是“扩展”，子类是父类的扩展
- 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法。
- 继承需要符合的关系是：is-a，父类更通用，子类更具体
Java中类只有单继承，不支持多继承！但支持多重继承！
- 单继承就是一个子类只能继承一个父类
- 多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类
- 多继承就是：一个子类同时继承多个父类（Java是不支持的！！！）
继承是类跟类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。

Java的访问控制修饰符：

default：默认，可以不写。在同一包内可见，不使用任何修饰符，使用对象：类、接口、变量、方法
public：对所有类可见。使用对象：类、接口、变量、方法
private：在同一类内可见。使用对象：变量、方法
protected：对同一包内的类和所有子类可见。使用对象：变量、方法

package com.oop.demo09;
//Person 人: 父类，基类
//Java中，所有的类默认都直接或间接继承自Object类
public class Person {
    //父类的属性:money
    public int money = 10_0000_0000;
    //父类的方法：say()
    public void say() {
        System.out.println("say something");
    }
}
//快捷键：ctrl+h，打开继承体系

package com.oop.demo09;
//Student 学生 is Person ：派生类，子类
public class Student extends Person {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();      //继承自父类的方法say()
        System.out.println(student.money);  //继承自父类的属性
    }
}

package com.oop.demo09;
//Teacher 老师 is Person：派生类，子类
public class Teacher extends Person{
}

10.Super详解：重点理解

super需要注意的地方
- super调用父类的构造方法，必须在构造方法的第一行
- super必须只能出现在子类的方法或者构造方法中！
- super和this不能同时调用构造方法！

this与super的对比

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

//Person 人: 父类，基类
//Java中，所有的类默认都直接或间接继承自Object类
public class Person {
    protected String name = "lding";
    public void print(){
        System.out.println("Person");
    }
    public Person() {
        System.out.println("Person无参构造执行了");
    }
}
//快捷键：ctrl+h，打开继承体系

//Student 学生 is Person ：派生类，子类
public class Student extends Person {
    public Student() {
        隐藏代码：调用了父类的无参构造器
        //super();    //显式调用父类的构造器时，必须要在子类的第一行
        System.out.println("Student无参构造执行了");
    }
    private String name = "xding";
    @Override  //方法重写
    public void print(){
        System.out.println("Student");
    }
    public  void test(String name){
        System.out.println(name);	//参数传递过来的name
        System.out.println(this.name);	//本类的name
        System.out.println(super.name);	//父类的name
        print();	//本类的方法print()
        this.print();	//本类的方法print()
        super.print();	//父类的方法print()
    }
}

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

11.方法重写：重点理解

重写都是指方法的重写，以属性无关

static静态方法，与调用

public class Animal {
    public static void test(){		//此处使用static定义静态方法
        System.out.println("Animal=>test()");
    }
}

//继承
public class Cat extends Animal{
    public static void test(){		//此处使用static定义静态方法
        System.out.println("Cat=>test()");
    }
}

public class Application {
    public static void main(String[] args) {
        //静态方法的调用只与定义类实例的类有关
        Cat a = new Cat();
        Cat.test();		//此处不可以使用a.test(); 不应该通过类实例访问静态成员
        //父类的引用指向了子类
        Animal b = new Cat();
        Animal.test();	//此处不可以使用b.test(); 不应该通过类实例访问静态成员
    }
}
输出结果：
Cat=>test()
Animal=>test()

非静态方法的重写，与调用

public class Animal {
    public void test(){
        System.out.println("Animal=>test()");
    }
}

//继承
public class Cat extends Animal{
    @Override	//注解：重写，有功能的注解
    public void test(){
        System.out.println("Cat=>test()");
    }
}

public class Application {
    public static void main(String[] args) {
        Cat a = new Cat();
        a.test();
        //父类的引用指向了子类
        Animal b = new Cat();	//子类Cat重写了父类Animal的方法
        b.test();
    }
}
输出结果：
Cat=>test()
Cat=>test()

重写小结：需要有继承关系，子类重写父类的方法
- 方法名必须相同
- 参数列表必须相同
- 修饰符：范围可以扩大但不能缩小 private < default < protected < public
- 抛出的异常：范围可以被缩小但不能扩大。
重写：子类的方法和父类的必须一致，只是方法体不同！
为什么需要重写？
- 父类的功能，子类不一定需要，或者不一定满足