面向对象的特征一：封装与隐藏 3W:what? why? how?
一、问题的引入：
- 当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到
- 属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值
- 加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()）
- 同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private).
- –>此时，针对于属性就体现了封装性。
二、封装性的体现：
-
我们将类的属性xxx私有化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值
-
拓展：封装性的体现：① 如上 ② 不对外暴露的私有的方法 ③ 单例模式 …
三、封装性的体现，需要权限修饰符来配合。
-
1.Java规定的4种权限（从小到大排列）：private、缺省、protected 、public
-
2.4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
-
3.具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
修饰类的话，只能使用：缺省、public -
总结封装性：Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。
-
JavaBean是一种Java语言写成的可重用组件。
所谓JavaBean，是指符合如下标准的Java类：
>类是公共的
>有一个无参的公共的构造器
>有属性，且有对应的get、set方法
四.类的结构之三：构造器（或构造方法、constructor）的使用
construct：建设、建造。 construction:CCB constructor:建设者
(1)、构造器的作用：
- 1.创建对象
- 2.初始化对象的信息
五、说明：
-
1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器
-
2.定义构造器的格式：权限修饰符 类名(形参列表){}
-
3.一个类中定义的多个构造器，彼此构成重载
-
4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
-
5.一个类中，至少会有一个构造器。
-
总结：属性赋值的先后顺序
-
① 默认初始化
-
② 显式初始化
-
③ 构造器中初始化
-
④ 通过"对象.方法" 或 "对象.属性"的方式，赋值
-
以上操作的先后顺序：① - ② - ③ - ④
六、package关键字的使用
-
1.为了更好的实现项目中类的管理，提供包的概念
-
2.使用package声明类或接口所属的包，声明在源文件的首行
-
3.包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”
-
4.每"."一次，就代表一层文件目录。
-
补充：同一个包下，不能命名同名的接口、类。
不同的包下，可以命名同名的接口、类。
七、import关键字的使用
(1) import:导入
- 1> 在源文件中显式的使用import结构导入指定包下的类、接口
- 2>声明在包的声明和类的声明之间
- 3>如果需要导入多个结构，则并列写出即可
- 4>可以使用"xxx.*"的方式，表示可以导入xxx包下的所有结构
- 5>如果使用的类或接口是java.lang包下定义的，则可以省略import结构
- 6>如果使用的类或接口是本包下定义的，则可以省略import结构
- 7>如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。
- 8>使用"xxx.*"方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入
- 9>import static:导入指定类或接口中的静态结构:属性或方法。
(2) 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(形参列表)"，用来调用其他的构造器
八. 面向对象的特征之二：继承性 why?
(1)、继承性的好处：
- ① 减少了代码的冗余，提高了代码的复用性
- ② 便于功能的扩展
- ③ 为之后多态性的使用，提供了前提
(2)、继承性的格式：
class A extends B{}
- A:子类、派生类、subclass
- B:父类、超类、基类、superclass
2.1体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。
- 特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。
- 只有因为封装性的影响，使得子类不能直接调用父类的结构而已。
2.2 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。 - 子类和父类的关系，不同于子集和集合的关系。
- extends：延展、扩展
(3)、Java中关于继承性的规定：
- 1.一个类可以被多个子类继承。
- 2.Java中类的单继承性：一个类只能有一个父类
- 3.子父类是相对的概念。
- 4.子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类
- 5.子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法
(4)、
-
- 如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类
-
- 所有的java类（除java.lang.Object类之外）都直接或间接的继承于java.lang.Object类
-
- 意味着，所有的java类具有java.lang.Object类声明的功能。
九. 方法的重写(override / overwrite)
1.重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作
2.应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。
3.重写的规定：
方法的声明： 权限修饰符 返回值类型 方法名(形参列表) throws 异常的类型{
//方法体
}
约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法
① 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
② 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
>特殊情况：子类不能重写父类中声明为private权限的方法
③ 返回值类型：
>父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
>父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
>父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本 数据类型(必须也是double)
④ 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型（具体放到异常处理时候讲）
子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的（不是重写）。
- 面试题：区分方法的重载与重写
十.子类对象实例化的全过程
1)从结果上来看：（继承性）
-
子类继承父类以后，就获取了父类中声明的属性或方法。 -
创建子类的对象，在堆空间中，就会加载所有父类中声明的属性。
2)从过程上来看：
- 当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器，…
- 直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中有
- 父类中的结构，子类对象才可以考虑进行调用。
- 明确：虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象。
十一. super关键字的使用
1.super理解为：父类的
2.super可以用来调用：属性、方法、构造器
*
- 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(形参列表)”，调用父类中的构造器
//面试题：多态是编译时行为还是运行时行为？
证明如下：
class Animal {
protected void eat() {
System.out.println("animal eat food");
}
}
class Cat extends Animal {
protected void eat() {
System.out.println("cat eat fish");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("Dog eat bone");
}
}
class Sheep extends Animal {
public void eat() {
System.out.println("Sheep eat grass");
}
}
public class InterviewTest {
public static Animal getInstance(int key) {
switch (key) {
case 0:
return new Cat ();
case 1:
return new Dog ();
default:
return new Sheep ();
}
}
public static void main(String[] args) {
int key = new Random().nextInt(3);
System.out.println(key);
Animal animal = getInstance(key);
animal.eat();
}
}
总结:
1.若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，
系统将不可能把父类里的方法转移到子类中：编译看左边，运行看右边
2.对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，
这个实例变量依然不可能覆盖父类中定义的实例变量：编译运行都看左边
252
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
