一、面向对象特征之封装性
-
为什么要引入封装性？
1、我们程序设计追求“高内聚，低耦合”
-
高内聚：类的内部数据操作细节自己完成，不允许外部干涉
-
低耦合：仅对外暴露少量的方法用于使用。
2、问题的引入
当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没其他制约条件。但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setName()同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private)。此时，针对于属性就体现了封装性。
3. 封装性思想具体的代码体现：
体现一：
将类的属性xxx私化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值
private double radius;
public void setRadius(double radius){
this.radius = radius;
}
public double getRadius(){
return radius;
}
体现二：不对外暴露的私有的方法
体现三：单例模式（将构造器私有化）
体现四：如果不希望类在包外被调用，可以将类设置为缺省的。
4. Java规定的四种权限修饰符：
权限修饰符可用来修饰的结构说明：
- 4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
- 修饰类，只能使用：缺省、public
通过对不同的方法属性设置不同的权限修饰符来达到对类进行封装的目的。
-
权限从小到大顺序为：private < 缺省 < protected < public
-
具体的修饰范围
| 修饰符 | 类内部 | 同一个包 | 不同包的子类 | 同一个工程 |
| private | yes | |||
| 缺省 | yes | yes | ||
| protected | yes | yes | yes | |
| public | yes | yes | yes | yes |
二、面向对象特征之继承性
1. 引入继承性的好处
- 减少了代码的冗余，提高了代码的复用性
- 便于功能的扩展
- 为之后多态性的使用，提供了前提
2、什么是方法的重写(override 或 overwrite)？
子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作.
重写的应用：
重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。
重写的规则：
权限修饰符 返回值类型 方法名(形参列表) throws 异常的类型{
//方法体
}
class A extends B{}
* A:子类、派生类、subclass
* B:父类、超类、基类、superclass
约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法
- 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
- 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
- 特殊情况：子类不能重写父类中声明为private权限的方法
3、Java中继承性的说明
- 一个类可以被多个子类继承。
- Java中类的单继承性：一个类只能有一个父类
- 子父类是相对的概念。
- 子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类
- 子类继承父类以后，就获取了直接父类以及所间接父类中声明的属性和方法
-
返回值类型：
- 父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
- 父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
- 父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)
- 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型（具体放到异常处理时候讲）
子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写，要么都声明为static的（不是重写)。
开发中一般保持子父类一致
4、区分方法的重写和重载？
- 二者的概念：
- 方法的重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作.
- 方法的重载：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
- 重载和重写的具体规则：重载：两同一不同，重写
- 重载：不表现为多态性。 重写：表现为多态性。
- 从编译和运行的角度看：
- 重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。
- 所以对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；
- 而对于多态，只等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”。
五、关键字：super--父类的
1. super关键字概述
super 关键字可以理解为：父类的，可以用来调用的结构：属性、方法、构造器
- 尤其当子父类出现同名成员时，可以用supe表明调用的是父类中的成员
- super的追溯不仅限于直接父类
- super和this的用法相像，this代表本类对象的引用， super代表父类的内存空间的标识
2. super关键字使用
2.1super调用属性、方法：
与this关键字使用方式相同，只不过调用的是父类的属性
2.2 在子类的方法或构造器中使用
通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
特殊情况
-
当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。
-
当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。
2.3 super调用构造器：
- 我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
- "super(形参列表)"的使用，必须声明在子类构造器的首行！
- 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一，不能同时出现
- 在构造器的首行，没显式的声明"this(形参列表)"或"super(形参列表)"，则默认调用的是父类中空参的构造器：super()
- 在类的多个构造器中，至少一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器
3. this与super的区别
| 区别点 | this | super |
| 访问属性 | 访问本类中的属性，如果本类没有此属性则从父类中继续查找 | 直接访问父类中的属性 |
| 调用方法 | 访问本类中的方法，如果本类没有此方法则从父类中继续查找 | 直接访问父类中的方法 |
| 调用构造器 | 调用本类构造器，必须放在构造器的首行 | 调用父类构造器，必须放在子类构造器的首行 |
4.子类实例化的全过程
从结果来看来：继承性
子类继承父类以后，就获取了父类中属性和方法
创建子类的对象，堆空间中，就会加载所有父类声明的属性
从过程上来看：当我们通过子类的构造器创建对象时，我们一定会直接的或间接的调用父类的构造器，进而调用父类的父类的构造器，直到调用了java.lang.object类中的空参构造器为止，正因为加载过父类中的结构，所以才可以看到内存中有父类的结构，子类才可以调用
明确：虽热创建子类对象时，调用过父类的构造器，自始自终只创建一个子类的对象
三、面向对象的特征之多态性
1. 多态性的理解：
可以理解为一个事物的多种形态。比如数据库的连接方式，我们定义好了数据库的连接，也规定了连接时的步骤，但是我们并不知道用户会采用什么数据库，在没有多态以前我们只能针对不同的数据库写不同的连接方法，而有了多态以后我们只需要定义好数据库的类并书写好连接方法，让所有的数据库继承数据库类并重写数据库连接方法。
这样我们在调用的时候只需要通过声明数据库类并指向数据库的子类的方式，**（即数据库类的引用指向继承了数据库类的具体实现类的对象）**就可以进行数据库连接。而不是需要针对不同的数据库书写不同的连接方式。
2. 何为多态性：
对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
编译时和运行时类型不一致，产生了多态
Person p = new Man();
Object obj = new Date();
3. 多态性的使用：虚拟方法调用
- 有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
- 总结：编译，看左边；运行，看右边。
- 对象的多态：在Java中，子类的对象可以替代父类的对象使用
- 一个变量只能有一种确定的数据类型
- 一个引用类型变量可能指向（引用）多种不同类型的对象
3.1多态性的使用前提：
① 类的继承关系 ② 方法的重写
3.3 多态性使用的注意点：
-
对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）
-
个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就==不能==再访问子类中添加的属性和方法
3.4 多态使用总结
-
多态的作用：提高了代码的通用性，常称作接口重用
-
使用前提：①需要存在继承或者实现关系 ②有方法的重写
-
成员方法：
- 编译时：要查看引用变量所声明的类中是否有所调用的方法
- 运行时：调用实际new的对象所属的类中的重写方法
-
成员变量：不具备多态性，只看引用变量所声明的类
4. 关于向上转型与向下转型：
向上转型：多态
4.1 为什么使用向下转型：
有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。如何才能调用子类特的属性和方法？使用向下转型。
4.2 如何实现向下转型：
使用强制类型转换符：()
Person p = new Man();
Man m1=（Man）p2；//向下转型
.3 使用时的注意点：
① 使用强转时，可能出现ClassCastException的异常。
② 为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。
③ 只有对象A是B的子类实例化对象或者在下层的子类，才能向下转型
4.4 instanceof的使用：
① a instanceof A:==判断对象a==是否是==类A的实例==。如果是，返回true；如果不是，返回false。
② 如果 a instanceof A返回true,则 a instanceof B也返回true.其中，类B是类A的父类。
③ 要求a所属的类与类A必须是子类和父类的关系，否则编译错误。
p instanceif Man//左边是变量名，右边是类的类型
5. 面试题：
1.谈谈你对多态性的理解？
- 实现代码的通用性。
- 举例：
- Object类中定义的public boolean equals(Object obj){ }
- JDBC:使用java程序操作(获取数据库连接、CRUD)数据库(MySQL、Oracle、DB2、SQL Server）
- 抽象类、接口的使用肯定体现了多态性。（抽象类、接口不能实例化）
**2.多态是编译时行为还是运行时行为？**运行时行为
class Base {
int count = 10;
public void display() {
System.out.println(this.count);
}
}
class Sub extends Base {
int count = 20;
public void display() {
System.out.println(this.count);
}
}
public class FieldMethodTest {
public static void main(String[] args) {
Sub s = new Sub();
System.out.println(s.count);//20
s.display();//20
Base b = s;//多态性
//==：对于引用数据类型来讲，比较的是两个引用数据类型变量的地址值是否相同
System.out.println(b == s);//true
System.out.println(b.count);//10
b.display();//20
}
}
- 若子类重写了父类方法，就意味着子类里面定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中：编译看左边，运行看右边
- 对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量：编译运行都看左边
5. Object类
5.1 java.lang.Object类的理解
是Java中所有类的父类，类似于二叉树中的根节点，定义了一些通用的方法。
- 如果我们没显式的声明一个类的父类的话，则此类继承于java.lang.Object类
- 所的java类（除java.lang.Object类之外都直接或间接的继承于java.lang.Object类
- 意味着，所的java类具有java.lang.Object类声明的功能。
- java.lang.Object类中定义的一些方法
| 方法名 | 类型 | 描述 |
|---|---|---|
| public Object() | 构造方法 | 构造器 |
| public boolean equals( Object obj) | 普通方法 | 对象比较 |
| public int hashCode() | 普通方法 | 获取Hash码 |
| public String toString() | 普通方法 | 对象打印时调用 |
5.2. java.lang.Object类的说明：
-
Object类是所Java类的根父类
-
如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
-
Object类中的功能(属性、方法)就具通用性。
-
属性：无
-
方法：equals() / toString() / getClass() /hashCode() / clone() / finalize()
wait() 、 notify()、notifyAll()
- Object类只声明了一个空参的构造器
- 数组也作为 Object类的子类出现，可以调用 Object类中声明的方法
5.3. equals()方法
- 是一个方法，而非运算符
- 只能适用于引用数据类型
-
public boolean equals(Object obj) { return (this == obj); }使用说明：
- Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
- 像==String、Date、File、包装类==等都重写了Object类中的equals()方法。==重写==以后，比较的不是两个引用的地址是否相同，而是==比较两个对象的"实体内容"是否相同==。
- 通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同。那么，我们就需要对Object类中的equals()进行重写.
- 重写的原则：比较两个对象的实体内容是否相同.
6. static关键字使用
2.1static修饰属性：静态变量（或类变量）
属性是否使用static修饰，可分为：静态属性 vs 非静态属性(实例变量)
- 实例变量：我们创建了类的多个对象，每个对象都独立的拥一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。
- 静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。
static修饰属性的其他说明：
-
静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
-
静态变量的加载要早于对象的创建。
-
由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
| 类变量 | 实例变量 | |
| 类 | yes | no |
| 对象 | yes | yes |
静态属性举例：System.out; Math.PI;
静态变量内存解析：
static修饰方法：静态方法、类方法
-
随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
-
静态方法中，只能调用静态的方法或属性
-
非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
| 静态方法 | 非静态方法 | |
| 类 | yes | no |
| 对象 | yes | yes |
使用的注意点：
- 在静态的方法内，不能使用this关键字、super关键字
- 关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。
2.3. 如何判定属性和方法应该使用static关键字：
关于属性：
- 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
- 类中的常量也常常声明为static
关于方法：
- 操作静态属性的方法，通常设置为static的
- 工具类中的方法，习惯上声明为static的。 比如：Math、Arrays、Collections
七、关键字：final--最终的
可以用来修饰：类、方法、变量
-
final 用来修饰一个类:此类不能被其他类所继承。
比如：String类、System类、StringBuffer类
-
final 用来修饰方法：表明此方法不可以被重写
比如：Object类中getClass();
-
final 用来修饰变量：此时的"变量"就称为是一个常量
- final修饰属性：可以考虑赋值的位置：显式初始化、代码块中初始化、构造器中初始化
- final修饰局部变量：尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。
-
static final 用来修饰属性：全局常量
八、关键字：abstract--抽象的
1. abstract关键字简述
abstract: 抽象的，可以用来修饰：类、方法
2. abstract关键字的使用
2.1 abstract修饰类：抽象类
- 此类不能实例化
- 抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
- 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作 --->抽象的使用前提：继承性
2.2 abstract修饰方法：抽象方法
- 抽象方法只方法的声明，没方法体
- 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
- 若子类重写了父类中的所的抽象方法后，此子类方可实例化
- 若子类没重写父类中的所的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰
注意点：
- abstract不能用来修饰：属性、构造器等结构
- abstract不能用来修饰私有方法、静态方法（静态方法不能被重写，抽象方法不能调用）、final的方法、final的类
八、关键字：interface--接口
1.interface关键字简述
-
接口使用interface来定义
-
Java中，接口和类是并列的两个结构
1.interface关键字使用说明：
-
如何定义接口：定义接口中的成员
-
接口中不能定义构造器的！意味着接口不可以实例化
-
Java开发中，接口通过让类去实现(implements)的方式来使用.
- 如果实现类覆盖了接口中的所抽象方法，则此实现类就可以实例化
- 如果实现类没覆盖接口中所的抽象方法，则此实现类仍为一个抽象类
-
Java类可以实现多个接口 --->弥补了Java单继承性的局限性
格式：class AA extends BB implements CC,DD,EE
-
接口与接口之间可以继承，而且可以多继承
-
接口的具体使用，体现多态性
-
接口，实际上可以看做是一种规范
使用举例：不同的设备通过USB口接入电脑
class Computer{
public void transferData(USB usb){//USB usb = new Flash();
usb.start();
System.out.println("具体传输数据的细节");
usb.stop();
}
}
interface USB{
//常量：定义了长、宽、最大最小的传输速度等
void start();
void stop();
}
class Flash implements USB{
@Override
public void start() {
System.out.println("U盘开启工作");
}
@Override
public void stop() {
System.out.println("U盘结束工作");
}
}
class Printer implements USB{
@Override
public void start() {
System.out.println("打印机开启工作");
}
@Override
public void stop() {
System.out.println("打印机结束工作");
}
}
使用总结
- 接口使用上也满足多态性
- 接口，实际上就是定义了一种规范
- 开发中，体会面向接口编程！
2. 面向接口编程的思想
面向接口编程：我们在应用程序中，调用的结构都是JDBC中定义的接口，不会出现具体某一个 数据库厂商的API。
3. Java8中关于接口的新规范
-
JDK7及以前：只能定义全局常量和抽象方法
- 全局常量：public static final的，书写时可以省略不写
- 抽象方法：public abstract的
-
JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法
-
Java8中，可以为接口添加静态方法和默认方法。从技术角度来说，这是完全合法的，只是它看起来违反了接口作为一个抽象定义的理念。
-
静态方法：使用 static关键字修饰。
可以通过接口直接调用静态方法，并执行其方法体。我们经常在相互一起使用的类中使用静态方法。你可以在标准库中找到像 Collection/co| ections或者Path/ Paths这样成对的接口和类。
-
默认方法：默认方法使用 default关键字修饰。
-
可以通过实现类对象来调用。我们在已有的接口中提供新方法的同时，还保持了与旧版本代码的兼容性比如：java8API中对 Collection、List、 Comparator等接口提供了丰富的默认方法。
-
JDK 8后接口使用总结
-
知识点1：接口中定义的静态方法，只能通过接口来调用。
-
知识点2：通过实现类的对象，可以调用接口中的默认方法。
如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
-
知识点3：如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，那么子类在没重写此方法的情况下，默认调用的是父类中的同名同参数的方法。-->类优先原则
-
知识点4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，
那么在实现类没重写此方法的情况下，报错。-->接口冲突。
这就需要我们必须在实现类中重写此方法
-
知识点5：如何在子类(或实现类)的方法中调用父类、接口中被重写的方法
public void myMethod(){
method3();//调用自己定义的重写的方法
super.method3();//调用的是父类中声明的
//调用接口中的默认方法
CompareA.super.method3();
CompareB.super.method3();
}
4. 面试题：
抽象类和接口的异同？ 相同点：都不能实例化；都可以被继承；都可以包含抽象方法的。
不同点：
抽象类：有构造器。接口：没有构造器
1）把抽象类和接口(java7,java8,java9)的定义、内部结构解释说明
2）类：单继承性 接口：多继承
类与接口：多实现
5. 代理模式
5.1. 解决的问题
代理模式是Java开发中使用较多的一种设计模式。代理设计就是为其他对象提供一种代理以控制对这个对象的访问。
interface NetWork{
public void browse();
}
//被代理类
class Server implements NetWork{
@Override
public void browse() {
System.out.println("真实的服务器访问网络");
}
}
//代理类
class ProxyServer implements NetWork{
private NetWork work;
public ProxyServer(NetWork work){
this.work = work;
}
public void check(){
System.out.println("联网之前的检查工作");
}
@Override
public void browse() {
check();
work.browse();
}
}
5.2 应用场景
-
安全代理：屏蔽对真实角色的直接访问
-
远程代理：通过代理类处理远程方法调用（RM）
-
延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象 比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有100MB，在打开文件时，不可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用 proxy来进行大图片的打开。
5.3 分类
- 静态代理（静态定义代理类）
- 动态代理（动态生成代理类）JDK自带的动态代理，需要反射等知识
6. 工厂的设计模式
解决的问题
实现了创建者与调用者的分离，即将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。
具体模式：
- 简单工厂模式：用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码）
- 工厂方法模式：用来生产同一等级结构中的固定产品。（支持增加任意产品)
- 抽象工厂模式：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族)
扫一扫
807
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
