【Java基础】面向对象

面向对象

面向过程和面向对象

面向过程（Procedure Oriented Programming）：强调的是功能行为，以函数为最小单位，考虑怎么做；
面向对象（Object Oriented Programming）：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做；
（1）现实世界中的实体
（2）概念世界中的类
（3）形成计算机世界中类的定义
（4）将类实例化成计算机世界中的对象

类和对象

类：对现实生活中一类具有共同属性和行为的事物的抽象；
对象：客观存在的事物；
类是对事物的一种描述，对象则为具体存在的事物；
类的成员：成员变量、成员方法、构造器、内部类、代码块；

修饰符 class 类名{
    // 类中的五大成分
    // 1.成员变量（属性）
    // 2.成员方法（行为） 
    // 3.构造器（初始化类的对象数据的）
    // 4.内部类
    // 5.代码块
}

属性：指事物的特征，对应类中的成员变量；
Field = 属性 = 成员变量
行为：指事物能执行的操作，对应类中的成员方法；
Method = 成员方法 = 函数

类的定义

定义类就是定义类的成员，包括成员变量和成员方法；

// 1.定义类
public class 类名 {
    // 2.编写类中的成员变量
    修饰符 数据类型 属性名 = 初始化值 ; 
    
    // 3.编写类中的成员方法
    修饰符 返回值类型 方法名(参数列表) {
        方法体;
        return 返回值;
    }        
}

对象的创建和使用

创建对象：

类名 对象名 = new 类名();

使用对象：

//使用成员变量
对象名.成员变量

//使用成员方法
对象名.成员方法()

类的访问机制：
（1）在一个类中的访问机制：类中的方法可以直接访问类中的成员变量；
（2）在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中定义的成员；

成员变量和局部变量

区别	成员变量	局部变量
类中位置	类中方法外	方法内部或方法声明上
作用范围	类中	方法中
内存加载位置	堆内存	局部变量
修饰符	private、public、static、final等	不能用权限修饰符修饰，可以用final修饰
声明位置	直接声明在类中	方法形参或内部、代码块内、构造器内等
初始化值	有默认初始化值	没有默认初始化值，必须先显式初始化才能使用
生命周期	随着对象的创建而存在，随着对象的消失而消失	随着方法的调用而存在，随着方法的调用完毕而消失

成员变量的默认值

匿名对象

调用情况：

1. 对一个对象只需要进行一次方法调用；
2. 将匿名对象作为实参传递给一个方法调用；

---

面向对象三大特征之封装性

封装

是面向对象三大特征之一，是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的；
原则：将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问；
步骤 ：
（1）使用 private 关键字来修饰成员变量；
（2）提供 getXxx 方法 和 setXxx 方法，可以访问成员变量；
好处：
（1）通过方法来控制成员变量的操作，提高了代码的安全性；
（2）把代码用方法进行封装，提高了代码的复用性；
（3）便于修改，提高了代码的可维护性；

private关键字

1. private是一个修饰符，可以用来修饰成员变量、成员方法；
2. 被private修饰后的成员变量和成员方法，只在本类中才能访问；
3. 针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作：
   （1）提供“ get变量名() ”方法，用于获取成员变量的值，方法用public修饰；
   （2）提供“ set变量名(参数) ”方法，用于设置成员变量的值，方法用public修饰；

权限修饰符

成员变量使用private，隐藏细节；
成员方法使用public，方便调用方法；
构造方法使用public，方便创建对象；
注意：不加权限修饰符，其访问能力与default修饰符相同 ；

this关键字

1. this修饰的变量用于指代成员变量，可以用来区分局部变量和成员变量；
   （1）方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量；
   （2）方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量；
2. 当在方法内需要用到调用该方法的对象时就用this；
3. this代表当前调用方法的引用，哪个对象调用的方法，this就代表哪一个对象；
4. this可以在方法内部和构造器内部使用，调用类的属性、方法和构造器；
   （1）this在方法内部使用，表示该方法所属对象的引用；
   （2）this在构造器内部使用，表示该构造器正在初始化的对象；

构造方法

当一个对象被创建时，用构造方法来初始化该对象，给对象的成员变量赋初始值；

修饰符 构造器方法名(参数列表) {
    方法体;
}

注意：无论你与否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个无参数构造方法， 一旦自己定义了构造方法，Java自动提供的默认无参数构造方法就会失效；

JavaBean

JavaBean 是 Java语言编写类的一种标准规范。符合 JavaBean 的类，要求类必须是具体的和公共的，并且具有无 参数的构造方法，提供用来操作成员变量的 set 和 get 方法。

public class 类名 {
    // 成员变量
    // 构造方法
    // 无参构造方法【必须】
    // 有参构造方法【建议】
    // 成员方法
    // getXxx()
    // setXxx()
}

面向对象三大特征之继承性

继承

是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法；

class 子类 extends 父类 {}

好处：
（1）让类与类之间产生了关系，提供了多态的前提；
（2）多个类相同的成员放到同一个类中，提高了代码的复用性；
（3）便于修改，提高了代码的可维护性，有利于功能的扩展；
弊端：
让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时，子类实现也不得不跟着变化，削弱了子类的独立性；
应用场景：
is…a的关系：谁是谁的一种
使用继承，需要考虑类与类之间是否存在is…a的关系；
注意事项：
Java中类只支持单继承、多层继承，不支持多继承；

super关键字

this：代表本类对象的引用（谁调用就代表谁）
super：代表父类存储空间的标识（父类对象的引用）

区别	this	super
成员变量	this.成员变量：访问本类成员变量	super.成员变量：访问父类成员变量
成员方法	this.成员方法：访问本类成员方法	super.成员方法：访问父类成员方法
构造方法	this(…)： 访问本类构造方法	super(…)：访问父类构造方法

注意：子类的每个构造方法中均有默认的super()，调用父类的空参构造方法；手动调用父类构造方法会覆盖默认的super()；super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现；

继承中成员变量访问特点

在子类方法中访问一个变量：
（1）子类局部范围找
（2）子类成员范围找
（3）父类成员范围找
（4）如果都没有就报错(不考虑父亲的父亲…)

继承中成员方法访问特点

通过子类对象访问一个方法：
（1）子类成员范围找
（2）父类成员范围找
（3）如果都没有就报错(不考虑父亲的父亲…)

继承中构造方法访问特点

子类中所有的构造方法默认都会访问父类中无参构造方法
子类会继承父类中的数据，可能还会使用父类的数据，所以子类初始化之前，一定要先完成父类数据的初始化，原因在于每一个子类构造方法的第一条语句默认都是：super()；
如果父类中没有无参构造方法，只有带参构造方法：

• 通过使用super关键字去显示的调用父类的带参构造方法；
• 在父类中自己提供一个无参构造方法；

方法重写

子类出现了和父类中一模一样的方法声明（返回值类型、方法名和参数列表都一样）
应用场景：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样既沿袭了父类的功能，又定义了子类特有的内容；
注意事项：
私有方法不能被重写（父类私有成员子类是不能继承的）
子类方法访问权限不能更低（public > 默认 > 私有）
Override注解：
用来检测当前的方法，是否是重写的方法，起到校验的作用；

fianl关键字

可以修饰成员方法、成员变量、类；
final修饰特点：

• 修饰类：表明该类是最终类，不能被继承；
• 修饰方法：表明该方法是最终方法，不能被重写；
• 修饰变量：表明该变量是常量，不能再次被赋值；
• 修饰基本数据类型局部变量：只能赋值一次，数据值不能再更改；
• 修饰引用数据类型局部变量：只能指向一个对象，地址值不能再更改，但不影响对象内部的成员变量值的修改；

static关键字

可以修饰成员方法、成员变量；
static修饰特点：
（1）被类的所有对象共享，这是判断是否使用static的条件；
（2）可以通过类名调用当然，也可以通过对象名调用；
static访问特点：静态成员方法只能访问静态成员

• 非静态的成员方法：
  能访问静态的成员变量
  能访问静态的成员方法
  能访问静态的成员变量
  能访问非静态的成员变量
• 静态的成员方法：
  能访问静态的成员方法
  能访问非静态的成员方法

package包

包就是文件夹，用来管理类文件的；

package 包名; //(多级包用.分开)

带包编译：

javac –d . 类名.java

带包运行：

java 包名+类名

导包：

import 包名;

面向对象三大特征之多态性

多态

同一个对象，在不同时刻表现出来的不同形态；
前提：
（1）要有继承或实现关系
（2）要有方法的重写
（3）要有父类引用指向子类对象
形式：具体类多态，抽象类多态，接口多态；
好处：提高了程序的扩展性（定义方法时使用父类型作为参数，使用方法时使用具体的子类型参与操作）
弊端：不能使用子类的特有成员；

多态中成员访问特点

• 成员变量：编译看父类，运行看父类；
• 成员方法：编译看父类，运行看子类；

多态中的转型

向上转型：
从子到父，父类引用指向子类对象
向下转型：
从父到子，父类引用转为子类对象

子类型 对象名 = (子类型)父类引用;

抽象类

抽象方法 ： 没有方法体的方法；
抽象类：包含抽象方法的类；

// 抽象类的定义：
public abstract class 类名 {
        // 抽象方法的定义：        
    修饰符 abstract 返回值类型 方法名(参数列表) {}
}

• 抽象类不能创建对象，只能创建其非抽象子类的对象；
• 抽象类中可以有构造方法，是供子类创建对象时初始化父类成员使用的；
• 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类；
• 抽象类的子类必须重写抽象父类中所有的抽象方法，除非该子类也是抽象类；

抽象类的成员特点

• 成员变量：可以是常量，也可以是变量；
• 构造方法：有构造方法，但不能实例化，用于子类访问访问父类数据的初始化；
• 成员方法：可以有抽象方法，限定子类必须完成某些动作，也可以有非抽象方法，提高代码复用性；

接口

接口的定义：

public interface 接口名 {
    // 抽象方法：可以省略，没有方法体，供子类实现使用；
    public abstract void 方法名(); 
    // 默认方法：不可省略，供子类调用或子类重写；
    public default void 方法名() {}
    // 静态方法：供接口直接调用；
    public static void 方法名() {}
    // 私有方法：供接口中的默认方法或静态方法调用;
    private void 方法名() {}
}

接口的实现：

public class 类名 implements 接口名 {
    // 重写接口中抽象方法【必须】
    // 重写接口中默认方法【可选】
}

接口的成员特点

• 成员变量：只能是常量，默认修饰符：public static final ；
• 构造方法：没有，接口主要是扩展功能的，而没有具体存在；
• 成员方法：只能是抽象方法，默认修饰符：public abstract ；

类与类的关系

继承关系，只能单继承，但可以多层继承；

类与接口的关系

实现关系，可以单实现、多实现，还可以在继承一个类的同时实现多个接口；

接口与接口的关系

继承关系，可以单继承，也可以多继承

抽象类和接口的区别

区别	抽象类	接口
成员	变量、常量；构造方法；抽象方法、普通方法	常量；抽象方法
设计理念区别	对类抽象，包括属性、行为	对行为抽象，主要是行为