知识点总结Day06——面向对象、封装继承和多态
目录
第一章 面向对象
一、面向对象的概述
1.1 面向过程和面向对象的区别
1.2 面向对象的三大特征
1.3 类和对象
二、对象在方法中的使用
2.1 对象类作为方法的参数
2.2 对象类作为方法的返回值
三、成员变量和局部变量的区别
第二章 封装、继承、多态
一、封装
1.1 封装的概述
1.2 封装的原则
1.3 封装的步骤
1.4 private的使用格式
1.5 this关键字
1.6 构造方法
1.7 JavaBean
二、继承
2.1 继承的定义
2.2 继承的格式（使用extends关键字）
2.3 继承关系中的特点：
2.4 super关键字和this关键字
三、多态（可以使程序编写的更简单，并有良好的扩展。）
3.1 多态的概述
3.2 多态的定义
3.2 引用类型转换
3.3 转型异常
声明：本文整理于黑马程序员的Java教学视频，仅可作为资料参考学习使用，侵权请联系删除。
第一章 面向对象
一、面向对象的概述
1.1 面向过程和面向对象的区别
1）面向过程：对需要实现的功能，每一个步骤都是自我完成。
2）面向对象：对需要实现的功能，不许关心具体的步骤是怎样执行的，而是使用一个具有功能的部分来执行。
例如：格式化输出数组[1,2,3,4,5]
public class Demo { public static void main(String[] args) { int[] arr = {1, 2, 3, 4, 5}; //面向过程 System.out.print("面向过程：\n["); for (int i = 0; i < arr.length; i++) { if (i < arr.length - 1) { System.out.print(arr[i] + ", "); } else { System.out.println(arr[arr.length - 1] + "]"); } } //面向对象 System.out.println("面向对象："); System.out.println(Arrays.toString(arr)); } }
1.2 面向对象的三大特征
1）封装
2）继承
3）多态
1.3 类和对象
1）类的定义：
类是一组相关属性和行为的集合。
属性：事物的状态信息
行为：事物的能力
类的定义格式：
public class 类名{ 成员变量; 成员方法; }
2）对象的定义：
对象是一类事物的具体体现。
3）类和对象的关系
① 类是抽象的：对一类事物的描述。
② 对象是具体的：一类事物的实例。
③ 类是对象的模板，对象是类的实体。
4）类和对象示例代码
① Person类
public class Person {
//成员变量
String name;//名字
int age;//年龄
//成员方法
public void work() {
System.out.println("上班班");
}
public void eat() {
System.out.println("吃饭饭");
}
public void sleep() {
System.out.println("睡觉觉");
}
}② 创建对象实现
对象的创建格式：类名称 名称 = new 类名称();
public class PersonImpl {
public static void main(String[] args) {
Person person = new Person();
person.name = "zhangsan";//给对象赋值名字
person.age = 32;//给对象赋值年龄
System.out.println("姓名：" + person.name + "\n" + "年龄：" + person.age);
person.eat();//实现“吃饭饭”方法
person.work();//实现“上班班”方法
person.sleep();//实现“睡觉觉”方法
}
}二、对象在方法中的使用
2.1 对象类作为方法的参数
public static void main(String[] args) {
Person person = new Person();
person.name = "zhangsan";//给对象赋值名字
person.age = 32;//给对象赋值年龄
Message(person);
}
public static void Message(Person person) {
System.out.println("姓名：" + person.name);
System.out.println("年龄：" + person.age);
}2.2 对象类作为方法的返回值
public static Person getPerson() {
Person hei = new Person();
hei.name = "金刚芭比";
hei.age = 18;
return hei;
}
public static void main(String[] args) {
Person person = getPerson();
System.out.println(person.name);//金刚芭比
System.out.println(person.age);//18
}三、成员变量和局部变量的区别
| 类型 | 区别 |
|---|---|
| 定义位置 | 局部变量：定义在方法内 成员变量：定义在方法外部 |
| 作用范围 | 局部变量：只有在方法中才可使用 成员变量：在整个类中均可使用 |
| 默认值 | 局部变量：没有默认值（可手动赋值） 成员变量：有默认值，规则同数组 |
| 内存的位置 | 局部变量：位于栈内存 成员变量：位于堆内存 |
| 生命周期 | 局部变量：跟随方法进栈产生，方法出栈后变量消失 成员变量：对象创建时诞生，对象被回收时变量消失 |
第二章 封装、继承、多态
一、封装
1.1 封装的概述
封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的方式。
1.2 封装的原则
将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。
1.3 封装的步骤
1）使用 private 关键字来修饰成员变量。
2）对需要访问的成员变量，提供对应的一对 getter 方法 、 setter 方法。
private的含义
① private是一个权限修饰符，代表最小权限。
② 可以修饰成员变量和成员方法。
③ 被private修饰后的成员变量和成员方法，只在本类中才能访问。
1.4 private的使用格式
private 数据类型 变量名；1）private修饰成员变量
public class MyPrivate {
private String name;
private int age;
}2）get()、set()方法，访问成员变量：
public class MyPrivate {
//private修饰成员变量
private String name;
private int age;
//get()、set()方法，访问成员变量
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}1.5 this关键字
当方法的局部变量和成员变量重名时，由于“就近原则”，程序优先使用局部变量。
如需访问成员变量，则使用this关键字：
this.成员变量名1.6 构造方法
构造方法是用来创建对象的方法，通过new关键字创建对象，就是在调用构造方法。
public 类名称(参数类型 参数名称) {
方法体
}注意事项：
① 构造方法的名称必须与所在类的名称完全一致。
② 构造方法不写返回值类型，甚至都不写void。
③ 如果不提供构造方法，系统会给出无参数构造方法。
④ 如果提供了构造方法，系统将不再提供无参数构造方法。
⑤ 构造方法是可以重载的，既可以定义参数，也可以不定义参数。
示例：
public class Student {
private String name;
private int age;
// 无参构造方法
public Student() {
}
// 有参构造方法
public Student(String name, int age) {
this.name = name;
this.age = age;
}
}1.7 JavaBean
JavaBean 是 Java语言编写类的一种标准规范。
符合 JavaBean 的类，要求类必须是具体的和公共的，并且具有无参数的构造方法，提供用来操作成员变量的 set 和 get 方法。
二、继承
继承是多态的前提；继承主要解决的问题：共性提取。
2.1 继承的定义
继承就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接 访问父类中的非私有的属性和行为。
继承的优点
① 提高代码的复用性。
② 类与类之间产生了关系，是多态的前提。
2.2 继承的格式（使用extends关键字）
class 父类 {
...
}
class 子类 extends 父类 {
...
}示例
class Farther {
public void method() {
System.out.println("爸爸会做饭");
}
}
class Sun extends Farther{
//子类无任何方法
}
public class MyExtends {
public static void main(String[] args) {
Sun sun = new Sun();
sun.method();
}
}2.3 继承关系中的特点：
1）子类可以拥有父类的“内容”
2）子类可以拥有自己独有的内容。
父类：基类、超类
子类：派生类
3）在继承关系中，如果成员变量重名，则创建对象时，成员变量的访问方式有两种：
① 直接通过子类对象访问成员变量
② 简介通过成员方法访问成员变量
4）区分重名的三种变量
| 变量类型 | 书写方式 |
|---|---|
| 局部变量 | 直接写成员变量名 |
| 本类中的成员变量 | this.成员变量名 |
| 父类中的成员变量 | super.成员变量名 |
5）如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。在对象调用方法时，会先在子类中查找有没有对应的方法，如果子类中存在就会执行子类中的方法，如果子类中不存在就会执行父类中相应的方法。
6）如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写 (Override)。
方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。
重写的注意事项： ① 子类方法覆盖父类方法，必须要保证权限大于等于父类权限。 ② 子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样。class Farther { public void method() { System.out.println("爸爸会做饭"); } } class Sun extends Farther{ public void method() { System.out.println("儿子也会做饭"); } } public class MyExtends { public static void main(String[] args) { Sun sun = new Sun(); sun.method(); } }
7）构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。 构造方法的作用是初始化成员变量的。所以在子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。
class Farther {
Farther() {
System.out.println("爸爸会做饭");
}
}
class Sun extends Farther{
Sun() {
super();
System.out.println("儿子也会做饭");
}
}
public class MyExtends {
public static void main(String[] args) {
Sun sun = new Sun();
}
}8）Java只支持单继承，不支持多继承。
9）Java支持多层继承(继承体系)。
10）子类和父类是一种相对的概念
2.4 super关键字和this关键字
1）super和this的含义
super ：代表父类的存储空间标识(可以理解为父亲的引用)。
this ：代表当前对象的引用(谁调用就代表谁)。
2）super和this的用法
①访问成员变量、成员方法
this.成员变量 ‐‐ 本类的
super.成员变量 ‐‐ 父类的
this.成员方法名() ‐‐ 本类的
super.成员方法名() ‐‐ 父类的② 访问构造方法
this(...) ‐‐ 本类的构造方法
super(...) ‐‐ 父类的构造方法三、多态（可以使程序编写的更简单，并有良好的扩展。）
3.1 多态的概述
多态是指同一行为，具有多个不同表现形式。
3.2 多态的定义
1）定义格式
父类类型 变量名 = new 子类对象；
变量名.方法名();父类类型：指子类对象继承的父类类型，或者实现的父接口类型。
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。
3.2 引用类型转换
1）向上转型
多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。当父类引用指向一个子类对象时，便是向上转型。
父类类型 变量名 = new 子类类型();2）向下转型
父类类型向子类类型向下转换的过程，这个过程是强制的。一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。
子类类型 变量名 = (子类类型) 父类变量名;3.3 转型异常
abstract class PersonMan {
abstract void eat();
}
class work extends PersonMan {
public void eat() {
System.out.println("吃鱼");
}
public void doWork() {
System.out.println("码代码");
}
}
class Cleaner extends PersonMan {
public void eat() {
System.out.println("吃面");
}
public void cleanHouse() {
System.out.println("打扫卫生");
}
}
public class TestDemo {
public static void main(String[] args) {
// 向上转型
PersonMan a = new work(); //调用work的eat()
a.eat();
// 向下转型
Cleaner c = (Cleaner) a; //调用CLeaner的cleanHouse 程序报错
c.cleanHouse();
}
}这段代码可以通过编译，但是运行时报出了 ClassCastException 类型转换异常，因为work对象不能转换成Cleaner对象，两者之间不存在继承关系。为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：
变量名 instanceof 数据类型
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false。程序修改如下：
abstract class PersonMan {
abstract void eat();
}
class work extends PersonMan {
public void eat() {
System.out.println("吃鱼");
}
public void doWork() {
System.out.println("码代码");
}
}
class Cleaner extends PersonMan {
public void eat() {
System.out.println("吃面");
}
public void cleanHouse() {
System.out.println("打扫卫生");
}
}
public class TestDemo {
public static void main(String[] args) {
// 向上转型
PersonMan a = new work(); //调用work的eat()
a.eat();
// 向下转型
if (a instanceof work) {
work c = (work)a;
c.doWork(); //调用work的doWork
} else if (a instanceof Cleaner) {
Cleaner d = (Cleaner) a; //调用CLeaner的cleanHouse
d.cleanHouse();
}
}
}