Java 面向对象知识超详细讲解（思维导图）

面向对象

面向对象总思维导图：

Java类及其类的成员

思维导图：

属性

属性格式:
权限修饰符 数据类型 变量名 = 赋值

权限修饰符：
public 、缺省 、private 、protected

数据类型:

变量名:
见名知意

方法

方法格式:
权限修饰符 返回值类型 方法名(形参列表){
方法体
}

返回值类型:
void类型 : 方法体中则可以不返回值
其它返回值类型:方法体中使用 return 返回

可变个数形参：
1.使用说明：

• 1.jdk 5.0新增的内容
• 2.具体使用：
• 2.1 可变个数形参的格式：数据类型 … 变量名
• 2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
• 2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
• 2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
• 2.5 可变个数形参在方法的形参中，必须声明在末尾
  2.6 可变个数形参在方法的形参中,最多只能声明一个可变形参。

代码示例:

public void show(int i){
		
	}
	
	public void show(String s){
		System.out.println("show(String)");
	}
	
	public void show(String ... strs){
		System.out.println("show(String ... strs)");
		
		for(int i = 0;i < strs.length;i++){
			System.out.println(strs[i]);
		}
	}
	//不能与上一个方法同时存在
//	public void show(String[] strs){
//		
//	}

构造器

构造器格式:
权限修饰符 类名 (){}

1.构造器（或构造方法）：Constructor
构造器的作用：

• 1.创建对象
• 2.初始化对象的信息

2.使用说明：

• 1.如果没显式的定义类的构造器的话，则系统默认提供一个空参的构造器
• 2.定义构造器的格式：权限修饰符 类名(形参列表){}
• 3.一个类中定义的多个构造器，彼此构成重载
• 4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
• 5.一个类中，至少会有一个构造器。

代码块

静态代码块：
内部可以输出语句
随着类的加载而执行,而且只执行一次
作用：初始化类的信息
如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
静态代码块的执行要优先于非静态代码块的执行
静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构

非静态代码块：
内部可以输出语句
随着对象的创建而执行
每创建一个对象，就执行一次非静态代码块
作用：可以在创建对象时，对对象的属性等进行初始化
如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法

内部类

定义： Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类

成员内部类的理解：
一方面，作为外部类的成员：
调用外部类的结构
可以被static修饰
可以被4种不同的权限修饰
.

另一方面，作为一个类：
类内可以定义属性、方法、构造器等
可以被final修饰，表示此类不能被继承。言外之意，

三大特性

封装性

1.为什么要引入封装性？
我们程序设计追求“高内聚，低耦合”。
高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉
低耦合 ：仅对外暴露少量的方法用于使用。

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

2.问题引入：
当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没其他制约条件。但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private).
–>此时，针对于属性就体现了封装性。

3.封装性思想具体的代码体现：
体现一：将类的属性xxx私化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值
private double radius;
public void setRadius(double radius){
this.radius = radius;
}
public double getRadius(){
return radius;
}
体现二：不对外暴露的私有的方法
体现三：单例模式（将构造器私有化）
体现四：如果不希望类在包外被调用，可以将类设置为缺省的。

继承性

1.为什么要有类的继承性？(继承性的好处）
① 减少了代码的冗余，提高了代码的复用性
② 便于功能的扩展
③ 为之后多态性的使用，提供了前提

2.继承性的格式：
class A extends B{}
A:子类、派生类、subclass
B:父类、超类、基类、superclass

3.子类继承父类以后有哪些不同？
3.1体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。
特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私的结构。只因为封装性的影响，使得子类不能直接调用父类的结构而已。
3.2 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。
// 子类和父类的关系，不同于子集和集合的关系。
//extends：延展、扩展

4.Java中继承性的说明
1.一个类可以被多个子类继承。
2.Java中类的单继承性：一个类只能有一个父类
3.子父类是相对的概念。
4.子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类
5.子类继承父类以后，就获取了直接父类以及所间接父类中声明的属性和方法

多态性

1.多态性的理解：可以理解为一个事物的多种形态。

2.何为多态性：
对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
举例：
Person p = new Man();
Object obj = new Date();

3.多态性的使用：虚拟方法调用
有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
总结：编译，看左边；运行，看右边。

4.多态性的使用前提：
① 类的继承关系 ② 方法的重写

代码:

举例一：
	public void func(Animal animal){//Animal animal = new Dog();
		animal.eat();
		animal.shout();
	}
举例二：
public void method(Object obj){
		
	}
举例三：
class Driver{
	
	public void doData(Connection conn){//conn = new MySQlConnection(); / conn = new OracleConnection();
		//规范的步骤去操作数据
//		conn.method1();
//		conn.method2();
//		conn.method3();
		
	}
	
}

关键字

this | super

1.可以调用的结构：属性、方法；构造器

2.this调用属性、方法：
this理解为：当前对象 或 当前正在创建的对象

2.1 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是，
通常情况下，我们都择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式
的使用"this.变量"的方式，表明此变量是属性，而非形参。

2.2 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。但是，通常情况下，我们都择省略"this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。

3.this调用构造器：
① 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器
② 构造器中不能通过"this(形参列表)“方式调用自己
③ 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)”
④ 规定：“this(形参列表)“必须声明在当前构造器的首行
⑤ 构造器内部，最多只能声明一个"this(形参列表)”，用来调用其他的构造器
package | import
3.super调用属性、方法：
3.1 我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super.”
3.2 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。
3.3 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。

4.super调用构造器：
4.1 我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
4.2 "super(形参列表)"的使用，必须声明在子类构造器的首行！
4.3 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)“只能二一，不能同时出现
4.4 在构造器的首行，没显式的声明"this(形参列表)“或"super(形参列表)”，则默认调用的是父类中空参的构造器：super()
4.5 在类的多个构造器中，至少一个类的构造器中使用了"super(形参列表)”，调用父类中的构造器

abstract | interface

abstract修饰类：抽象类
此类不能实例化
抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作 —>抽象的使用前提：继承性

abstract修饰方法：抽象方法
抽象方法只方法的声明，没方法体
包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
若子类重写了父类中的所的抽象方法后，此子类方可实例化
若子类没重写父类中的所的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰

stactic

static修饰属性：静态变量（或类变量）
2.1 属性，是否使用static修饰，又分为：静态属性 vs 非静态属性(实例变量)
静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。

2.2 static修饰属性的其他说明：
 ① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
     ② 静态变量的加载要早于对象的创建。
     ③ 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
    
     ④	类变量	实例变量
   类		yes		no
  对象	yes		yes
     
    2.3 静态属性举例：System.out; Math.PI;

final

final 用来修饰一个类:此类不能被其他类所继承。
比如：String类、System类、StringBuffer类

final 用来修饰方法：表明此方法不可以被重写
比如：Object类中getClass();

final 用来修饰变量：此时的"变量"就称为是一个常量
1. final修饰属性：可以考虑赋值的位置：显式初始化、代码块中初始化、构造器中初始化
2. final修饰局部变量：
尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。

static final 用来修饰属性：全局常量
main

main()方法作为程序的入口
main()方法也是一个普通的静态方法
main()方法可以作为我们与控制台交互的方式。（之前：使用Scanner）