狂神说JAVA 面向对象编程 封装 继承

JAVA核心思想就是OOP

初识面向对象

1、物以类聚 类=属性+方法
面向对象编程（Object-Oriented Programming，OOP）
面向对象编程的本质：以类的方式组织代码，以对象的形式（封装）数据。

也可以这么理解：对象名，属性，操作。

2、抽象
编程思想！持续的学习，直到茅塞顿开！多实践，多测试大脑中的想法！实践出真知~

从认识论角度考虑：先有对象后有类。对象，是具体的事物。对象是抽象概念的具体实例。

类，是抽象的，是对一类事物整体描述/定义，但是并不能代表某一个具体的事物,一个模板，它描述一类对象的行为和状态。

从代码运行的角度考虑：先有类后又对象。类是对象的模板。

在面向对象的系统中，对象是基本的运行时实体，他包括数据（属性）和用于数据的操作（行为或方法）。对象是其数据以及其上的操作的封装体。

3、面向对象设计思路
针对接口编程，不要针对实现编程
设计职责单一的类
尽量使用已有的类库
开闭原则：
面向扩展开放，面向修改关闭
里式转换原则：超类存在的地方，子类是可以替换的
依赖倒转原则：实现尽量依赖抽象，不依赖具体实现，依赖接口和抽象类，不依赖具体类
接口隔离原则：为客户提供尽可能小的单独的接口，而不是提供大的总的接口
组合/复用原则：
尽量使用合成达到复用，尽量少用继承。就是在一个新的对象里面使用一些已有的对象,使之成为新对象的一部分;新的对象通过向这些对象的委派达到复用已有功能的目的。
迪米特原则：一个软件实体应当尽可能少的与其他实体相互作用，降低类之间的耦合。

方法回顾和加深

1、方法的定义
修饰符
返回类型

break和return的区别
break：跳出switch，结束循环
continue：结束一次循环
return：结束方法

方法名
参数列表
异常抛出

2、方法的调用
静态方法 类名.方法名调用即可
非静态方法 实例化后调用 //类实例化之后才存在

静态方法之间可以相互调用 //静态方法是和类一起加载的，一开始就存在

形参和实参
值传递和引用传递，见狂神说JAVA JAVA方法详解
this关键字

对象的创建分析

使用NEW关键字创建对象

除了分配内存空间之外，还会给创建好的对象进行默认的初始化，以及对类中构造器的调用
使用NEW关键字，必须要有适配的构造器

构造器

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的，其有以下两个特点
1、必须和类名相同
2、必须没有返回类型、也不能写void

析构函数

也称析构函数，是在对象消失之前的瞬间自动调用的函数
1、析构函数没有任何参数，不能被重载，但可以是虚函数，一个类只有一个析构函数
2、析构函数没有返回值，构造也没有
3、析构函数名与类名相同，但在类名之前加上一个逻辑非运算符"~",以示与构造函数的区别
4、析构函数一般由用户自己定义，在对象消失之前由系统自己调用，如果用户没有定义析构函数系统将自动生成一个不做任何事情的默认析构函数。

会存在默认的构造器，生成的class文件中可以看到
使用NEW关键字，必须要有适配的构造器，一旦定义了有参构造，无参构造就必须显式的方式写出

super - this

子类的构造方法（有参或无参），默认先执行父类的无参构造方法，即第一行代码是super,若显式的写出super调用有参或无参，必须是第一行，this同理

this没有继承也可以使用，super只能在继承的条件下才可以使用

package Oop;

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

package Oop;

public class Person {
    private String name= "父类名字";

    public Person(){
        /*
        * 子类的无参构造方法，默认先执行父类的无参构造方法，即第一行代码是super,若显式的写出super，必须是第一行，this同理
        * */
        //super();
        System.out.println("Person 无参构造");

    }

    public Person(String struct){
        /*
         * 子类的无参构造方法，默认先执行父类的无参构造方法，即第一行代码是super,若显式的写出super，必须是第一行，this同理
         * */
        //super();
        System.out.println("Person 有参构造");

    }

    public String getName() {
        return name;
    }

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

package Oop;

public class Student extends Person {

    public Student() {
        System.out.println("Student 无参构造");
    }

    public Student(String struct) {
        //默认调用父类无参构造方法
        super(struct);
        System.out.println("Student 有参构造");
    }

    private String name = "子类名字";

    @Override
    public String getName() {
        return name;
    }

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

    public void test() {
        System.out.println(this.getName());
        System.out.println(super.getName());
    }


}

Person 无参构造
Student 无参构造
子类名字
父类名字
Person 有参构造
Student 有参构造

this代表当前对象
作用：
1、一个构造函数调用另一个构造函数，对构造函数的调用必须是第一条语句
2、将对象自身作为参数调用一个函数

super代表当前对象
1、在子类中调用父类的同名方法（大部分这么用），子类可以调用父类的任何非私有方法
2、在子类中调用父类的构造函数，此时也必须是第一条语句

面向对象三大特性

封装

在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

要访问该类的代码和数据，必须通过严格的接口控制。

封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。

适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

封装是一种信息隐蔽技术，其目的是使对象的使用者和生产者分离，使对象的定义和实现分开。

封装的优点

1. 良好的封装能够减少耦合。

2. 类内部的结构可以自由修改。

3. 可以对成员变量进行更精确的控制。

4. 隐藏信息，实现细节。

该露的露，该藏的藏

我们的程序要求“高内聚，低耦合”。
内聚：模块内部各元素之间联系的紧密程度，也就是代码功能的集中程度。
耦合：某块之间相互联系的紧密程度。

从高到低	描述
顺序内聚	处理元素相关，而且必须顺利执行
通信内聚	所有处理元素集中在一个数据结构的区域上
过程内聚	处理元素相关，而且必须按特定的次序执行
瞬时内聚	所包含的任务必须在同一时间间隔内执行
逻辑内聚	完成逻辑上相关的一组任务（如组件通过功能码决定干什么）
偶然内聚	完成一组没有关系或松散关系的任务
功能内聚	完成一个单一功能，各个部分协同工作，缺一不可

从高到低	描述
内容耦合	1、直接访问另一模内部数据 2、不通过正常入口访问另一模块内部数据 3、两个模块有代码重叠 4、模块有多入口
公共耦合	公共数据环境
外部耦合	访问同一简单变量，而不是同一全局数据结构，而且不是通过参数表传递全局变量
控制耦合	通过传送开关标志、名字等，明显地控制选择另一个模块的功能
标记耦合	访问通过公共数据结构 ，而不是简单变量
数据耦合	一个模块访问另一模块时，访问通过简单数据参数（非控制、非公共数据结构、非外部变量）
非直接耦合	没有直接关系，互不依赖。联系完全是通过主模块的控制和调用来实现

高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：仅暴露少量的方法给外部使用。
数据隐藏:应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问；

简单来说：就是属性私有，get/set

继承

本质：是对某一批类的抽象，从而实现对现实世界更好的建模。
extends的意思是“扩展”。子类是父类的扩展。
Java类中只有单继承，没有多继承,需要注意的是 Java 不支持多继承，但支持多重继承.

为什么需要继承

接下来我们通过实例来说明这个需求。
开发动物类，其中动物分别为企鹅以及老鼠，要求如下：

企鹅：属性（姓名，id），方法（吃，睡，自我介绍）
老鼠：属性（姓名，id），方法（吃，睡，自我介绍）

继承的特性

子类拥有父类非 private 的属性、方法。

子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

子类可以用自己的方式实现父类的方法。

提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

不同权限的访问能力

继承方式	public	protected	private
公有继承	public	protected	不可见
保护继承	protected	protected	不可见
私有继承	private	private	不可见

泛化

一般（父类）与特殊（子类）的关系。继承是泛化的反关系。