Java SE 2.面向对象

面向对象编程的三条主线：
1）类及类的构成成分：属性 方法 构造器 代码块 内部类
2）面向对象编程的特征：封装性 继承性 多态性 （抽象性）
3）其它的关键字：this super package import static final abstract interface

1.关注于类的设计

2.类的组成成分：
1） 属性（成员变量，Field）
2）方法（成员方法，函数，Method）

2.1属性：
* 成员变量 vs 局部变量
* 相同点：1.遵循变量声明的格式： 数据类型 变量名 = 初始化值
* 2.都有作用域
* 不同点：1.声明的位置的不同 ：成员变量：声明在类里，方法外
* 局部变量：声明在方法内，方法的形参部分，代码块内
* 2.成员变量的修饰符有四个：public private protected 缺省
* 局部变量没有修饰符，与所在的方法修饰符相同。
* 3.初始化值：一定会有初始化值。
* 成员变量:如果在声明的时候，不显式的赋值，那么不同数据类型会有不同的默认初始化值。
* byte short int long ==>0
* float double ==>0.0
* char ==>空格
* boolean ==>false
* 引用类型变量==>null
* 局部变量：一定要显式的赋值。（局部变量没有默认初始化值）
* 4.二者在内存中存放的位置不同:成员变量存在于堆空间中；局部变量：栈空间中
*
* 总结：关于变量的分类：1）按照数据类型的不同：基本数据类型（8种） & 引用数据类型
* 2）按照声明的位置的不同：成员变量 & 局部变量

2.2 方法：提供某种功能的实现
* 1）实例：public void eat(){//方法体}
* public String getName(){}
* public void setName(String n){}
* 格式：权限修饰符 返回值类型（void:无返回值/具体的返回值） 方法名(形参){}
*
* 2)关于返回值类型：void：表明此方法不需要返回值
* 有返回值的方法：在方法的最后一定有return + 返回值类型对应的变量
* 记忆：void 与return不可以同时出现一个方法内。像一对“冤家”。
*
* 3)方法内可以调用本类的其他方法或属性，但是不能在方法内再定义方法！

3.面向对象编程的思想的落地法则一：
1）设计并创建类及类的成分
2）实例化类的对象
3）通过“对象.属性”或”对象.方法”的形式完成某项功能

4.类的初始化的内存解析
4.1 内存划分的结构：
栈(stack):局部变量 、对象的引用名、数组的引用名
堆(heap):new 出来的“东西”（如：对象的实体，数组的实体），含成员变量
方法区:含字符串常量
静态域：声明为static的变量

4.2 理解的基础上，学会基本的创建的类的对象在内存中的运行。

* 方法的重载（overload）
* 要求：1.同一个类中 2.方法名必须相同 3.方法的参数列表不同（①参数的个数不同②参数类型不同）
* 补充：方法的重载与方法的返回值类型没有关系！

* 可变个数的形参的方法：
* 1.格式：对于方法的形参： 数据类型 … 形参名
* 2.可变个数的形参的方法与同名的方法之间构成重载
* 3.可变个数的形参在调用时，个数从0开始，到无穷多个都可以。
* 4.使用可变多个形参的方法与方法的形参使用数组是一致的。
* 5.若方法中存在可变个数的形参，那么一定要声明在方法形参的最后。
* 6.在一个方法中，最多声明一个可变个数的形参。

5.Java的值传递机制

* 1.形参：方法声明时，方法小括号内的参数
* 实参：调用方法时，实际传入的参数的值
*
* 2.规则：java中的参数传递机制：值传递机制
* 1）形参是基本数据类型的：将实参的值传递给形参的基本数据类型的变量
* 2）形参是引用数据类型的：将实参的引用类型变量的值（对应的堆空间的对象实体的首地址值）传递给形参的引用类型变量。

6.面向对象的特征一：封装与隐藏

* 问题：当创建了类的对象以后，如果直接通过”对象.属性”的方式对相应的对象属性赋值的话，可能会出现不满足实际
* 情况的意外，我们考虑不让对象来直接作用属性，而是通过”对象.方法”的形式，来控制对象对属性的访问。实际
* 情况中，对属性的要求就可以通过方法来体现。

7.面向对象思想的落地法则二：

（封装性的思想）①将类的属性私有化，②提供公共的方法（setter & getter）来实现调用。

8.四种权限修饰符
1.权限从大到小为：public protected 缺省 private
2.四种权限都可以用来修饰属性、方法、构造器
3.修饰类的话：public 缺省

9.构造器

* 构造器的作用：①创建对象 ②给创建的对象的属性赋值
*
* 1.设计类时，若不显式声明类的构造器的话，程序会默认提供一个空参的构造器.
* 2.一旦显式的定义类的构造器，那么默认的构造器就不再提供。
* 3.如何声明类的构造器。格式：权限修饰符 类名(形参){ }
* 4.类的多个构造器之间构成重载

* 类对象的属性赋值的先后顺序：
* ①属性的默认初始化
* ②属性的显式初始化
* ③通过构造器给属性初始化
* ④通过”对象.方法”的方式给属性赋值

10.this
1.使用在类中，可以用来修饰属性、方法、构造器
2.表示当前对象或者是当前正在创建的对象
3.当形参与成员变量重名时，如果在方法内部需要使用成员变量，必须添加this来表明该变量时类成员
4.在任意方法内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性
5.在构造器中使用“this(形参列表)”显式的调用本类中重载的其它的构造器
>5.1 要求“this(形参列表)”要声明在构造器的首行！
>5.2 类中若存在n个构造器，那么最多有n-1构造器中使用了this。

11.package & import

* package:声明源文件所在的包，写在程序的第一行。
* 每“.”一次，表示一层文件目录。
* 包名都要小写。

* import:
* 1)显式导入指定包下的类或接口
* 2)写在包的声明和源文件之间
* 3)如果需要引入多个类或接口，那么就并列写出
* 4)如果导入的类是java.lang包下的，如：System String Math等，就不需要显式的声明。
* 5)理解.*的概念。比如java.util.*;
* 6)如何处理同名类的导入。如：在util包和sql包下同时存在Date类。
* 7)import static 表示导入指定类的static的属性或方法
* 8)导入java.lang.*只能导入lang包下的所有类或接口，不能导入lang的子包下的类或接口

11.面向对象的特征二：继承性

* 1.通过”class A extends B”类实现类的继承。
* 子类：A 父类（或基类 SuperClass）：B
*
* 2.子类继承父类以后，父类中声明的属性、方法，子类就可以获取到。
* 明确：当父类中有私有的属性或方法时，子类同样可以获取得到，只是由于封装性的设计，使得子类不可以直接
* 调用罢了。
* 子类除了通过继承，获取父类的结构之外，还可以定义自己的特有的成分。
*
* extends：子类是对父类功能的“扩展”，明确子类不是父类的子集。
*
* 3.java中类的继承性只支持单继承：一个类只能继承一个父类。反之，一个父类可以有多个子类。
* 4.子父类是相对的概念。

12.super

*1.super，相较于关键字this，可以修饰属性、方法、构造器

*2.super修饰属性、方法：在子类的方法、构造器中，通过super.属性或者super.方法的形式，显式的调用父类的指定
属性或方法。尤其是，当子类与父类有同名的属性、或方法时，调用父类中的结构的话，一定要用“super.”

*3.通过“super(形参列表)”，显式的在子类的构造器中，调用父类指定的构造器！
>任何一个类(除Object类)的构造器的首行，要么显式的调用本类中重载的其它的构造器“this(形参列表)”或显式的调用父类中
指定的构造器“super(形参列表)”,要么默认的调用父类空参的构造器”super()”
>建议在设计类时，提供一个空参的构造器！

13.面向对象的特征二：多态性

1.多态性的表现：①方法的重载与重写 ②子类对象的多态性
2.使用的前提：①要有继承关系 ②要有方法的重写
3.格式：Person p = new Man();//向上转型
// 虚拟方法调用：通过父类的引用指向子类的对象实体，当调用方法时，实际执行的是子类重写父类的方法
p1.eat();
p1.walk();
// p1.entertainment();

4.>编译时，认为p是Person类型的，故只能执行Person里才有的结构，即Man里特有的结构不能够调用
>子类对象的多态性，并不适用于属性。

5.关于向下转型：
①向下转型,使用强转符：()
②为了保证不报ClassCastException，最好在向下转型前，进行判断： instanceof
// 若a是A类的实例，那么a也一定是A类的父类的实例。
if (p1 instanceof Woman) {
System.out.println(“hello!”);
Woman w1 = (Woman) p1;
w1.shopping();
}

if (p1 instanceof Man) {
Man m1 = (Man) p1;
m1.entertainment();
}

14.Object类

1.java.lang.Object 类，是所有类的根父类！

2.Object类仅有一个空参的构造器 public Object(){ }

3.关于方法：
① equals(Object obj)

public boolean equals(Object obj) {
return (this == obj);
}

// ==
// 1.基本数据类型：根据基本数据类型的值判断是否相等。相等返回true，反之返回false
// 注：两端数据类型可以不同，在不同的情况下，也可以返回true。
// 2.引用数据类型：比较引用类型变量的地址值是否相等。

//equals():
>①只能处理引用类型变量②在Object类，发现equals()仍然比较的两个引用变量的地址值是否相等
>像String 包装类 File类 Date类这些重写Object类的equals()方法，比较是两个对象的
//”实体内容”是否完全相同。
>若我们自定义一个类，希望比较两个对象的属性值都相同的情况下返回true的话，就需要重写Object类的
equals(Object obj)方法

② toString()方法
当我们输出一个对象的引用时，会调用toString()方法。
1.public String toString() {
return getClass().getName() + “@” + Integer.toHexString(hashCode());
}
当我们没有重写Object类的toString()方法时，打印的就是对象所在的类，以及对象实体在堆空间的位置
2.一般我们需要重写Object类的toString()方法，将此对象的各个属性值返回。
3.像String类、Date、File类、包装类都重写了toString()方法。

15.包装类

基本数据类型由于不是类，不能够使用java类库里提供的大量的方法。所有在设计上，我们让每一个基本数据类型都对应一个类，同时数据存储的范围还不变。此时相当于基本数据类型就具有了类的特点。这些类即为包装类（wrapper 或封装类）

基本数据类型、包装类、String类之间的转换如下：

16.static关键字

1.static:静态的，可以用来修饰属性、方法、*代码块（或初始化块）、*内部类

2.static修饰属性（类变量）:
* 1.由类创建的所有的对象，都共用这一个属性
* 2.当其中一个对象对此属性进行修改，会导致其他对象对此属性的一个调用。vs 实例变量（非static修饰的属性，各个对象各自拥有一套副本）
* 3.类变量随着类的加载而加载的，而且独一份
* 4.静态的变量可以直接通过“类.类变量”的形式来调用
* 5.类变量的加载是要早于对象。所以当有对象以后，可以“对象.类变量”使用。但是”类.实例变量”是不行的。
* 6.类变量存在于静态域中。
*
* static修饰方法（类方法）:
* 1.随着类的加载而加载，在内存中也是独一份
* 2.可以直接通过“类.类方法”的方式调用
* 3.内部可以调用静态的属性或静态的方法，而不能调用非静态的属性或方法。反之，非静态的方法是可以调用静态的属性或静态的方法
* >静态的方法内是不可以有this或super关键字的！
* 注：静态的结构(static的属性、方法、代码块、内部类)的生命周期要早于非静态的结构，同时被回收也要晚于非静态的结构

17.单例模式
解决的问题：如何只让设计的类只能创建一个对象
如何实现：饿汉式 & 懒汉式
//饿汉式1
class Bank{
//1.私有化构造器
private Bank(){}
//2.创建类的对象，同时设置为private的，通过公共的来调用，体现封装性
//4.要求此对象也为static的
private static Bank instance = new Bank();
//3.此公共的方法，必须为static
public static Bank getInstance(){
return instance;
}
}

//饿汉式2
class Bank{
//1.私有化构造器
private Bank(){}
//2.创建类的对象，同时设置为private的，通过公共的来调用，体现封装性
//4.要求此对象也为static的
private static Bank instance = null;
static{
instance = new Bank();
}
//3.此公共的方法，必须为static
public static Bank getInstance(){
return instance;
}
}

//懒汉式
class Bank{
private Bank(){}

private static Bank instance = null;

public static Bank getInstance(){
if(instance == null){//可能存在线程安全问题的！
instance = new Bank();
}
return instance;
}
}

18.main()方法

main()是一个方法，是主方法，为程序的入口

19.代码块

代码块：是类的第4个成员
作用：用来初始化类的属性
分类：只能用static来修饰。

* 静态代码块：
* 1.里面可以有输出语句
* 2.随着类的加载而加载，而且只被加载一次
* 3.多个静态代码块之间按照顺序结构执行
* 4.静态代码块的执行要早于非静态代码块的执行。
* 5.静态的代码块中只能执行静态的结构(类属性，类方法)
*
* 非静态代码块：
* 1.可以对类的属性(静态的 & 非静态的)进行初始化操作，同时也可以调用本类声明的方法(静态的 & 非静态的)
* 2.里面可以有输出语句
* 3.一个类中可以有多个非静态的代码块，多个代码块之间按照顺序结构执行
* 4.每创建一个类的对象，非静态代码块就加载一次。
* 5.非静态代码块的执行要早于构造器
*
* 关于属性赋值的操作：
①默认的初始化
②显式的初始化或代码块初始化(此处两个结构按照顺序执行)
③构造器中；
—————————以上是对象的属性初始化的过程—————————————
④通过方法对对象的相应属性进行修改

20.final关键字

* final:最终的 ，可以用来修饰类、属性、方法
*
* 1.final修饰类：这个类就不能被继承。如：String类、StringBuffer类、System类
*
* 2.final修饰方法：不能被重写。如：Object类的getClass()
*
* 3.final修饰属性：此属性就是一个常量，一旦初始化后，不可再被赋值。习惯上，常量用大写字符表示。
* 此常量在哪里赋值：①此常量不能使用默认初始化 ②可以显式的赋值、代码块、构造器。
*
* 变量用static final修饰：全局常量。比如：Math 类的PI

21.抽象：abstract

abstract：抽象的，可以用来修饰类、方法

* 1.abstract修饰类：抽象类
* 1)不可被实例化
* 2)抽象类有构造器 (凡是类都有构造器)
* 3)抽象方法所在的类，一定是抽象类。
* 4)抽象类中可以没有抽象方法。
* >当我们设计一个类，不需要创建此类的实例时候，就可以考虑将其设置为抽象的，由其子类实现这个类的抽象方法以后，就行实例化
*
* 2.abstract修饰方法：抽象方法
* 1)格式：没有方法体，包括{}.如：public abstract void eat();
* 2)抽象方法只保留方法的功能，而具体的执行，交给继承抽象类的子类，由子类重写此抽象方法。
* 3)若子类继承抽象类，并重写了所有的抽象方法，则此类是一个”实体类”,即可以实例化
* 4)若子类继承抽象类，没有重写所有的抽象方法，意味着此类中仍有抽象方法，则此类必须声明为抽象的！

22.接口interface

* 接口（interface） 是与类并行的一个概念
* 1.接口可以看做是一个特殊的抽象类。是常量与抽象方法的一个集合，不能包含变量、一般的方法。
* 2.接口是没有构造器的。
* 3.接口定义的就是一种功能。此功能可以被类所实现（implements）。
* 比如：class CC extends DD implements AA
* 4.实现接口的类，必须要重写其中的所有的抽象方法，方可实例化。若没有重写所有的抽象方法，则此类仍为一个抽象类
* 5.类可以实现多个接口。—-java 中的类的继承是单继承的
* 6.接口与接口之间也是继承的关系，而且可以实现多继承
* >5,6描述的是java中的继承的特点。
* 7.接口与具体的实现类之间也存在多态性

23. 内部类

* 类的第5个成员：内部类
* 1.相当于说，我们可以在类的内部再定义类。外面的类：外部类。里面定义的类：内部类
* 2.内部类的分类：成员内部类（声明在类内部且方法外的） vs 局部内部类(声明在类的方法里)
* 3.成员内部类：
* 3.1是外部类的一个成员：①可以有修饰符（4个）②static final ③可以调用外部类的属性、方法
*
* 3.2具体类的特点：①abstract ②还可以在其内部定义属性、方法、构造器
*
* 4.局部内部类：
*
* 5.关于内部类，掌握三点：
* ①如何创建成员内部类的对象（如：创建Bird类和Dog类的对象）
* ②如何区分调用外部类、内部类的变量(尤其是变量重名时)
* ③局部内部类的使用

总结：

面向对象的三条主线：
1.类及类的成分
2.面向对象的三大特性：封装、继承、多态
3.其他的关键字：this super import package abstract static final interface等

1.java程序是关注于类的设计。类从代码的角度：并列关系！ 从执行、设计的角度：关联关系、继承关系、聚合关系
class A{

}

class B{
A a = new A();
}
2.类的成分：属性 方法 构造器 代码块 内部类
2.1 属性：①变量的分类：成员变量（属性 Field） vs 局部变量(方法的形参、方法内部、代码块内部)
基本数据类型（8种，不同的数据类型对应不同的默认初始化值） vs 引用数据类型（数组、类、接口 默认初始化值为null）
②属性的声明格式：修饰符 数据类型 变量名 = 初始化值；//java是强数据类型的语言
③对属性的赋值的操作：1.默认初始化 2.显式的初始化 3.代码块的初始化 4.构造器的初始化；5.调用方法、属性进行赋值
2.2 方法 ①格式：修饰符 （其它的关键字：static/final/abstract）返回值类型 方法名（形参列表）{ //方法体 }
②方法的重载(overload) vs 方法的重写(override overwrite)
③ 方法的参数传递机制：值传递（难点）
2.3构造器 ①构造器的作用：1.创建类的对象 2.初始化对象的成员变量
②构造器也是可以重载的。
2.4 代码块 主要作用：用来初始化类的成员变量
分类：静态的代码块 vs 非静态的代码块
2.5 内部类 ①分类：成员内部类（static的成员 vs 非static的成员） vs 局部内部类（方法内部声明的类）
②掌握 :①如何创建成员内部类的对象（如：创建Bird类和Dog类的对象）
②如何区分调用外部类、内部类的变量(尤其是变量重名时)
③局部内部类的使用 （见TestInnerClass1.java）
3. 类的初始化（创建类的对象）
3.1 如何创建类的对象。如： Person p = new Person(); Date d = new Date();
3.2 内存解析：
①

栈：局部变量、对象的引用名、数组的引用名
堆：new 出来的“东西”
方法区：（字符串常量池）
静态域：存放类中静态的变量
②如何理解创建的对象在内存中加载的过程（理解）
3.3 子类对象实例化的全过程： SubClass sc = new SubClass();
4.面向对象的三大特性：
4.1 封装性：
① 通过私有化类的成员变量，通过公共的getter和setter方法来调用和修改
② 还可以对类的其他结构进行“封装”
③ 权限修饰符：public protected 缺省 private
4.2 继承性：
通过让一个类A继承另一个类B，就可以获取类B中的结构（主要的：属性、方法、构造器）。子类：类A 父类：类B
>java中的类的继承性：单继承的。
4.3 多态性：
①体现：方法的重载与重写 ； 子类对象的多态性 Person p = new Student();
②子类对象多态性的使用：虚拟方法调用。
③向上转型 向下转型 Student s = (Student)p; //建议在向下转型之前： if ( p instanceof Student)避免出现ClassCastException的异常

5.其它关键字：
5.1 this:修饰属性、方法、构造器 。表示：当前对象或当前正在创建的对象
5.2 super：修饰属性、方法、构造器。显式的调用父类的相应的结构，尤其是子父类有重名的方法、属性
5.3 static : 修饰属性、方法、代码块、内部类。随着类的加载而加载！
5.4 final：修饰类、属性、方法。表示“最终的”
5.5 abstract : 修饰类、方法
5.6 interface：表示是一个接口，（接口是与类并列的一个结构）。类与接口之间同时“implements”发生关系。
5.7 package import 。。。
>abstract不能修饰属性、构造器、不能与final static private共用。