标签：abstract hub 过程 info 关键字 on() protected tor 子集
这一章主要涉及面向对象的三大特征，包括封装、继承、多态、（抽象）。
程序设计追求“高内聚，低耦合”：
通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来，这就是封装性的设计思想。
通过将数据声明为私有的（private），再提供公共的（public）方法：getXxx() 和 setXxx() 实现对该属性的操作，以实现下述目的：
四种访问权限修饰符：Java 权限修饰符 private、 default(缺省)、protected、public 置于类的成员定义前，用来限定对象对该类成员的访问权限。
| 权限修饰符 | 类内部 | 同一个包 | 不同包的子类 | 同一个工程 |
|---|---|---|---|---|
private |
Yes | |||
default(缺省) |
Yes | Yes | ||
protected |
Yes | Yes | Yes | |
public |
Yes | Yes | Yes | Yes |
注意：对于 class 的权限修饰符号只可以用 public 和 default(缺省)。
为什么呢？因为外部类和外部类之间访问权限就只有包内和包外。
封装性的体现：
构造器的特征：
构造器的作用：
语法格式：
修饰符 类名(参数列表) {
初始化语句;
}
构造器的分类：
使用注意：
例子：
public class ConstructorTest {
public static void main(String[] args) {
// StudentA s1 = new StudentA(); // Error
StudentA s2 = new StudentA("A", 11);
s2.printInfo();
StudentA s3 = new StudentA("A", 11, "B");
s3.printInfo();
StudentA s4 = new StudentA("A", 11, "B", "C");
s4.printInfo();
}
}
class StudentA {
String name;
int age;
String school;
String major;
StudentA(String n, int a) {
name = n;
age = a;
}
StudentA(String n, int a, String s) {
name = n;
age = a;
school = s;
}
StudentA(String n, int a, String s, String m) {
name = n;
age = a;
school = s;
major = m;
}
public void printInfo() {
System.out.println(name + " " + age + " " + school + " " + major);
}
}
JavaBean 是一种 Java 语言写成的可重用组件。
所谓 JavaBean，是指符合如下标准的 Java 类：
+ 表示 public 类型，- 表示 private 类型， # 表示 protected 类型;+、- ）方法名（参数名：参数类型）: 返回值类型。注意：
this(形参列表) 的方式，调用本类中重载的其他构造器；this(形参列表) 的方式调用自身构造器；this(形参列表)；this(形参列表) 必须声明在类的构造器的首行；this(形参列表)；package 顶层包名.子包名;；“.” 来指明包（目录）的层次；cn.parzulpan.xxx。包的作用：
MVC是常用的设计模式之一，将整个程序分为三个层次：视图模型层，控制器层，与数据模型层。这种将程序输入输出、数据处理，以及数据的展示分离开来的设计模式使程序结构变的灵活而且清晰，同时也描述了程序各个对象间的通信方式，降低了程序的耦合性。
为使用定义在不同包中的 Java 类，需用 import 语句来引入指定包层次下所需要的类或全部类(.*)。import 语句告诉编译器到哪里去寻找类。
语法格式：import 包名. 类名;
注意：
为什么要有继承？多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
多个类称为子类(派生类)，单独的这个类称为父类(基类 或 超类)。可以理解为:“子类 is a 父类”。
类继承语法规则：class SubClass extends SuperClass{}
继承的作用：
注意：
“extends”，即子类不是父类的子集，而是对父类的“扩展”。根据 UML 类图 实现功能：
重写：在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。
要求：
注意：
方法的重写，也是一种“多态性”：同名的方法，用不同的对象来区分调用的是哪一个方法。
在 Java 类中使用 super 来调用父类中的指定操作：
注意：
对于调用父类构造器：
this(参数列表) 或者 super(参数列表) 语句指定调用本类或者父类中相应的构造器。同时，只能”二选一”，且必须放在构造器的首行；package com.parzulpan.java.ch04;
import java.util.Date;
/**
* @Author : parzulpan
* @Time : 2020-11-20
* @Desc :
*/
public class SuperTest {
public static void main(String[] args) {
}
}
class SuperPerson {
private String name;
private int age;
private Date birthDate;
public SuperPerson(String name, int age, Date d) {
this.name = name;
this.age = age;
this.birthDate = d;
}
public SuperPerson(String name, int age) {
this(name, age, null);
}
public SuperPerson(String name, Date d) {
this(name, 30, d);
}
public SuperPerson(String name) {
this(name, 30);
}
}
class SuperStudent extends SuperPerson {
private String school;
public SuperStudent(String name, int age, String s) {
super(name, age);
school = s;
}
public SuperStudent(String name, String s) {
super(name);
school = s;
}
// 编译出错: no super()，系统将调用父类无参数的构造器。
public SuperStudent(String s) {
school = s;
}
}
this 和 super 的区别：
| 区别点 | this | super |
|---|---|---|
| 访问属性 | 访问本类中的属性，如果本类没有此属性则从父类中继续查找 | 直接访问父类中的属性 |
| 调用方法 | 访问本类中的方法，如果本类没有此方法则从父类中继续查找 | 直接访问父类中的方法 |
| 调用构造器 | 代表本类对象的引用，调用本类构造器，必须放在构造器的首行 | 代表父类的内存空间的标识，调用父类构造器，必须放在子类构造器的首行 |
从结果上看：
从过程上看：
理解多态性：可以理解为一个事物的多种状态。
对象的多态性：父类的引用指向子类的对象。它也可以直接应用在抽象类和接口上。
多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写的方法，即虚拟方法调用。
Java 引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，而运行时类型由实际赋给该变量的对象决定。所以，编译时，看左边；运行时，看右边。
若编译时类型和运行时类型不一致，就出现了对象的多态性（Polymorphism）。在多态情况下，看左边即看的是父类的引用（父类中不具备子类特有的方法），看右边即看的是子类的对象（实际运行的是子类重写父类的方法）。
子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象，即向上转型（upcasting）。
总结以上，多态性的使用前提是：1. 类的继承关系；2. 方法的重写。
为什么要有多态性？
// 使用举例一
package com.parzulpan.java.ch04;
/**
* @Author : parzulpan
* @Time : 2020-11-20
* @Desc : 多态的使用举例一
*/
public class PolymorphismTest {
public static void main(String[] args) {
PolymorphismTest polymorphismTest = new PolymorphismTest();
polymorphismTest.func(new Cat()); //
polymorphismTest.func(new Dog()); //
}
public void func(AnimalA animalA) {
animalA.eat();
animalA.shout();
}
}
class AnimalA {
public void eat() {
System.out.println("动物：进食！");
}
public void shout() {
System.out.println("动物：叫！");
}
}
class Cat extends AnimalA {
public void eat() {
System.out.println("猫：进食！");
}
public void shout() {
System.out.println("猫：叫！");
}
}
class Dog extends AnimalA {
public void eat() {
System.out.println("狗：进食！");
}
public void shout() {
System.out.println("狗：叫！");
}
}
// 使用举例二
package com.parzulpan.java.ch04;
import java.sql.Connection;
/**
* @Author : parzulpan
* @Time : 2020-11-20
* @Desc : 多态的使用举例二，操作不同的数据库
*/
public class PolymorphismTest1 {
public static void main(String[] args) {
DBDriver d = new DBDriver();
d.doData(new MySQLConnection);
d.doData(new OracleConnection);
d.doData(new Db2Connection);
}
}
class DBDriver {
public void doData(Connection connection) {
// 一些数据库操作
}
}
对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，
这称为“早绑定”或“静态绑定”；而对于多态而言，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”。
注意：多态性不适用于属性。
解释：这是由于 Java 为了实现多态的这个机制，选择让方法在运行期间绑定对应对象所对应实际类型，选择让属性在编译期间绑定其所对应实际类型。
语法：x instanceof A 检验 x 是否为类 A 的对象，返回值为 boolean 型。
基本数据类型的转换：
对 Java 对象的强制类型转换称为造型。需要注意：
Object 类是所有 Java 类的根父类，Object 只声明了一个空参的构造器；
如果在类的声明中未使用 extends 关键字指明其父类，则默认父类为 java.lang.Object 类；
public class Person {
// ...
}
// 等价于：
public class Person extends Object {
// ...
}
method(Object obj){…} //可以接收任何类作为其参数
Person o=new Person();
method(o);
Object 类的主要方法：
equals
标签：abstract hub 过程 info 关键字 on() protected tor 子集
原文地址：https://www.cnblogs.com/parzulpan/p/14130156.html
