文章目录
前言
Java面向对象中的一些琐碎的知识点
一、学习面向对象的主线
学习面向对象（ Object Oriented Programming ）内容的三条主线
1.Java类及类的成员：属性、方法、构造器；代码块、内部类
2.面向对象的三大特征：封装、继承、多态、（抽象性）
3.其他关键字：this、super、abstract、interface、static、final、package、import等
二、面向对象与面向过程（理解）
1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。
2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
三、类和对象的创建和执行操作有哪三步
1.创建类（创建类的对象=类的实例化=实例化类）
2.类的实例化（属性=成员变量=field=域、字段）（方法=成员方法=函数=method）
3.调用对象的结构：“对象.属性”“对象.方法”
四、类的语法格式
修饰符 class 类名 {
属性声明; （类型名 变量名 = 数据值）
方法声明;（权限修饰符 返回值类型 方法名（形参列表））
}
说明：修饰符public：类可以被任意访问
类的正文要用{ }括起来
举例： public class Person{
private int age ; //声明私有变量 age
public void showAge(int i) { //声明方法
showAge( ) age = i;
}
}
属性赋值的先后顺序
① 默认初始化
② 显式初始化
③ 构造器中初始化
④ 通过"对象.方法" 或 "对象.属性"的方式，赋值
⑤ 通过代码块赋值
以上操作的先后顺序：① - ② / ⑤ - ③ - ④
类的结构之构造器
构造器（或构造方法、constructor）的使用
construct：建设、建造。 construction:CCB constructor:建设者
一、构造器的作用：1.创建对象 2.初始化对象的信息
二、说明：
1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器
2.定义构造器的格式：权限修饰符 类名(形参列表){}
3.一个类中定义的多个构造器，彼此构成重载
4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
5.一个类中，至少会有一个构造器。
代码块（初始化块）
总结：由父及子，静态先行
- 代码块的作用：用来初始化类、对象
- 代码块如果有修饰的话，只能使用static.
- 分类：静态代码块 vs 非静态代码块
- 静态代码块
内部可以有输出语句
随着类的加载而执行,而且只执行一次
作用：初始化类的信息
如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
静态代码块的执行要优先于非静态代码块的执行
静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构 - 非静态代码块
内部可以有输出语句
随着对象的创建而执行
每创建一个对象，就执行一次非静态代码块
作用：可以在创建对象时，对对象的属性等进行初始化
如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法
五、JavaBean
JavaBean是一种Java语言写成的可重用组件。
所谓JavaBean，是指符合如下标准的Java类：
>类是公共的
>有一个无参的公共的构造器
>有属性，且有对应的get、set方法
六、包装类
包装类的使用:
1.java提供了8种基本数据类型对应的包装类，使得基本数据类型的变量具有类的特征
2.基本数据类型、包装类、String三者之间的相互转换：
String类型 —>基本数据类型、包装类：调用包装类的parseXxx(String s)
基本数据类型、包装类—>String类型：调用String重载的valueOf(Xxx xxx)
七、Object类
java.lang.Object类
1.Object类是所有Java类的根父类
2.如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
3.Object类中的功能(属性、方法)就具有通用性。
属性：无
方法：equals() / toString() / getClass() /hashCode() / clone() / finalize()
wait() 、 notify()、notifyAll()
4. Object类只声明了一个空参的构造器
八、方法的重载（overload）loading…
1.定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
2.“两同一不同”:
同一个类、相同方法名
参数列表不同（参数个数不同，参数类型不同）
举例：
Arrays类中重载的sort() / binarySearch()
3.判断是否是重载：
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！
4. 在通过对象调用方法时，如何确定某一个指定的方法：
方法名 —> 参数列表
九、方法的重写（继承中才有）：
1.解释：
子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作。
2.应用：
重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。
3.重写的规定：
方法的声明： 权限修饰符 返回值类型 方法名 （形参列表） throws 异常的类型{
// 方法体 }
约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法。
①、子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
②、子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符（子类不能重写父类中声明private权限的方法）
③、返回值类型：
>父类中的方法是void，子类只能是void
>父类是A，则子类重写的可以是A类或A类的子类
>父类中是基本数据类型（比如double），则子类中必须是相同的基本数据类型（double）
④、子类重写的方法抛出的异常类型不大于父类中被重写的方法抛出的异常类型
方法名、形参列表相同；权限修饰符；返回值；抛出的异常
十、关键字
“this”关键字
1.this可以用来修饰、调用：属性、方法、构造器。
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(形参列表)”，用来调用其他的构造器
“super”关键字
1.super关键字可以理解为： 父类的
2.可以用来调用的结构： 属性、方法、构造器
3.super调用属性、方法：
3.1 我们可以在子类的方法或构造器中，通过使用“super.属性”或“super.方法”的方式，显式的调用父类中声明的属性或方法。通常我们习惯省略。
3.2特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用“super.属性”的方式，表明调用的是父类中声明的属性。
3.3特殊情况：当子类重写了父类中的方法以后，我们想在子类中调用父类中被重写的方法时，则必须显式的使用“super.方法“的方式，表明调用的是父类中被重写的方法。
4.super调用构造器：
4.1我们可以在子类的构造器中显式的使用”super（形参列表）“的方式，调用父类中声明的指定的构造器
4.2我们在类的构造器中，针对于”this（形参列表）“或”super（形参列表）“只能二选一，不能同时出现
4.3”super（形参列表）“的使用，必须声明在子类构造器的首行！
4.4在构造器的首行，没有显式的声明这两种，则默认调用父类中的空参构造器：super（）
4.5在类的多个构造器中，至少一个类的构造器中使用了”super（形参列表）“，调用父类中的构造器
“import”关键字
import:导入
- 在源文件中显式的使用import结构导入指定包下的类、接口
- 声明在包的声明和类的声明之间
- 如果需要导入多个结构，则并列写出即可
- 可以使用"xxx.*"的方式，表示可以导入xxx包下的所有结构
- 如果使用的类或接口是java.lang包下定义的，则可以省略import结构
- 如果使用的类或接口是本包下定义的，则可以省略import结构
- 如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。
- 使用"xxx.*"方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入
- import static:导入指定类或接口中的静态结构:属性或方法。
“package”关键字
1.为了更好的实现项目中类的管理，提供包的概念
2.使用package声明类或接口所属的包，声明在源文件的首行
3.包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”
4.每"."一次，就代表一层文件目录。
补充：同一个包下，不能命名同名的接口、类。
不同的包下，可以命名同名的接口、类。
“static”关键字
1.static:静态的
2.static可以用来修饰：属性、方法、代码块、内部类
3.使用static修饰属性：静态变量（或类变量）
3.1 属性，按是否使用static修饰，又分为：静态属性 vs 非静态属性(实例变量)
实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的
非静态属性时，不会导致其他对象中同样的属性值的修改。
静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致
其他对象调用此静态变量时，是修改过了的。
3.2 static修饰属性的其他说明：
① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
② 静态变量的加载要早于对象的创建。
③ 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
④
类变量 实例变量
类 yes no
对象 yes yes
3.3 静态属性举例：System.out; Math.PI;
4.使用static修饰方法：静态方法
① 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
②
静态方法 非静态方法
类 yes no
对象 yes yes
③ 静态方法中，只能调用静态的方法或属性
非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
- static注意点：
5.1 在静态的方法内，不能使用this关键字、super关键字
5.2 关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。 - 开发中，如何确定一个属性是否要声明为static的？
属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
类中的常量也常常声明为static
开发中，如何确定一个方法是否要声明为static的？
操作静态属性的方法，通常设置为static的
工具类中的方法，习惯上声明为static的。 比如：Math、Arrays、Collections
十一、面向对象的三性
封装性
面向对象的特征一：封装与隐藏 3W:what? why? how?
一、问题的引入：
当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()）同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private).–>此时，针对于属性就体现了封装性。
二、封装性的体现：
我们将类的属性xxx私有化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值
拓展：封装性的体现：① 如上 ② 不对外暴露的私有的方法 ③ 单例模式 …
三、封装性的体现，需要权限修饰符来配合。
1.Java规定的4种权限（从小到大排列）：private、缺省、protected 、public
2.4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
3.具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
修饰类的话，只能使用：缺省、public
总结封装性：Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。
继承性
面向对象的特征之二：继承性 why?
1、继承性的好处：
① 减少了代码的冗余，提高了代码的复用性
② 便于功能的扩展
③ 为之后多态性的使用，提供了前提
2、继承性的格式：
class A extends B{} A:子类、派生类、subclass B:父类、超类、基类、superclass
2.1体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。
特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。
只有因为封装性的影响，使得子类不能直接调用父类的结构而已。
2.2 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。
子类和父类的关系，不同于子集和集合的关系。
extends：延展、扩展
3、Java中关于继承性的规定：
3.1.一个类可以被多个子类继承。
3.2.Java中类的单继承性：一个类只能有一个父类
3.3.子父类是相对的概念。
3.4.子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类
3.5.子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法
4.1. 如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类
4.2. 所有的java类（除java.lang.Object类之外）都直接或间接的继承于java.lang.Object类
4.3. 意味着，所有的java类具有java.lang.Object类声明的功能。
多态性
1.理解多态性：可以理解为一个事物的多种形态。
2.何为多态性：
对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）Person p2 = new Man();
3. 多态的使用：虚拟方法调用
有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
4. 如何才能调用子类特有的属性和方法？
向下转型：使用强制类型转换符。使用强转时，可能出现ClassCastException的异常。这时可以使用instanceof关键字：a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false。
使用情境：
为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。如果 a instanceof A返回true,则 a instanceof B也返回true.其中，类B是类A的父类。
总结：编译，看左边；运行，看右边。Man m1 = (Man)p2;
4.多态性的使用前提： ① 类的继承关系 ② 方法的重写
5.对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）
十二、单例设计模式
- 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。
- 如何实现？
饿汉式 vs 懒汉式 - 区分饿汉式 和 懒汉式
饿汉式：
坏处：对象加载时间过长。
好处：饿汉式是线程安全的
懒汉式：好处：延迟对象的创建。
目前的写法坏处：线程不安全。—>到多线程内容时，再修改
总结
面向对象的丰富知识还有很多，只有理解了细小的知识点，基础才能更扎实。
1210
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
