首页 > 编程札记 > 编程

Java面向对象篇：封装、继承、多态

阅读：评论：0

Java面向对象篇：封装、继承、多态

文章目录

- 1. 类和对象
- - 1.1 类和对象的理解
  - 1.2 类的定义
  - 1.3 对象的使用
  - 1.4 学生对象-练习
- 2. 对象内存图
- - 2.1 单个对象内存图
  - 2.2 多个对象内存图
  - 2.3 多个对象指向相同内存图
- 3. 成员变量和局部变量
- - 3.1 成员变量和局部变量的区别
- 4. 封装
- - 4.1 private关键字
  - 4.2 private的使用
  - 4.3 this关键字
  - 4.4 this内存原理
  - 4.5 封装思想
- 5. 构造方法
- - 5.1 构造方法概述
  - 5.2 构造方法的注意事项
  - 5.3 标准类制作
- 6. 继承
- - 6.1 继承的实现
  - 6.2 继承的好处和弊端
- 7. 继承中的成员访问特点
- - 7.1 继承中变量的访问特点
  - 7.2 super
  - 7.3 继承中构造方法的访问特点
  - 7.4 继承中成员方法的访问特点
  - 7.5 super内存图
  - 7.6 方法重写
  - 7.7 方法重写的注意事项
  - 7.8. Java中继承的注意事项
- 8. 继承练习
- - 8.1 老师和学生
  - 8.2 猫和狗
- 9. 修饰符
- - 9.1 package
  - 9.2 import
  - 9.3 权限修饰符
  - 9.4 final
  - 9.5 final修饰局部变量
  - 9.6 static
  - 9.7 static访问特点
- 10. 多态
- - 10.1 多态的概述
  - 10.2 多态中的成员访问特点
  - 10.3 多态的好处和弊端
  - 10.4 多态中的转型
  - 10.5 多态的案例
- 11. 抽象类
- - 11.1 抽象类的概述
  - 11.2 抽象类的特点
  - 11.3 抽象类的成员特点
  - 11.4 抽象类的案例
- 12. 接口
- - 12.1 接口的概述
  - 12.2 接口的特点
  - 12.3 接口的成员特点
  - 12.4 接口的案例
  - 12.5 类和接口的关系
  - 12.6 抽象类和接口的区别
- 13. 综合案例
- - 13.1 案例需求
  - 13.2 代码实现
- 14. 参数传递
- - 14.1 类名作为形参和返回值
  - 14.2 抽象类作为形参和返回值
  - 14.3 接口名作为形参和返回值
- 15. 内部类
- - 15.1 内部类的基本使用
  - 15.2 成员内部类
  - 15.3 局部内部类
  - 15.4 匿名内部类
  - 15.5 匿名内部类在开发中的使用

1. 类和对象

1.1 类和对象的理解

客观存在的事物皆为对象，所以我们也常常说万物皆对象。

类
- 类的理解
  - 类是对现实生活中一类具有共同属性和行为的事物的抽象
  - 类是对象的数据类型，类是具有相同属性和行为的一组对象的集合
  - 简单理解：类就是对现实事物的一种描述
- 类的组成
  - 属性：指事物的特征，例如：手机事物（品牌，价格，尺寸）
  - 行为：指事物能执行的操作，例如：手机事物（打电话，发短信）
类和对象的关系
- 类：类是对现实生活中一类具有共同属性和行为的事物的抽象
- 对象：是能够看得到摸的着的真实存在的实体
- 简单理解：类是对事物的一种描述，对象则为具体存在的事物

1.2 类的定义

类的组成是由属性和行为两部分组成

属性：在类中通过成员变量来体现（类中方法外的变量）
行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）

类的定义步骤：

①定义类

②编写类的成员变量

③编写类的成员方法

public class 类名 {// 成员变量变量1的数据类型 变量1；变量2的数据类型 变量2;…// 成员方法方法1;方法2;	
}

示例代码：

/*手机类：类名：手机(Phone)成员变量：品牌(brand)价格(price)成员方法：打电话(call)发短信(sendMessage)*/
public class Phone {//成员变量String brand;int price;//成员方法public void call() {System.out.println("打电话");}public void sendMessage() {System.out.println("发短信");}
}

1.3 对象的使用

创建对象的格式：
- 类名对象名 = new 类名();
调用成员的格式：
- 对象名.成员变量
- 对象名.成员方法();
示例代码

/*创建对象格式：类名 对象名 = new 类名();范例：Phone p = new Phone();使用对象1：使用成员变量格式：对象名.变量名范例：p.brand2：使用成员方法格式：对象名.方法名()范例：p.call()*/
public class PhoneDemo {public static void main(String[] args) {//创建对象Phone p = new Phone();//使用成员变量System.out.println(p.brand);System.out.println(p.price);p.brand = "小米";p.price = 2999;System.out.println(p.brand);System.out.println(p.price);//使用成员方法p.call();p.sendMessage();}
}

1.4 学生对象-练习

需求：首先定义一个学生类，然后定义一个学生测试类，在学生测试类中通过对象完成成员变量和成员方法的使用
分析：
- 成员变量：姓名，年龄…
- 成员方法：学习，做作业…
示例代码：

class Student {//成员变量String name;int age;//成员方法public void study() {System.out.println("好好学习，天天向上");}public void doHomework() {System.out.println("键盘敲烂，月薪过万");}
}
/*学生测试类*/
public class StudentDemo {public static void main(String[] args) {//创建对象Student s = new Student();//使用对象System.out.println(s.name + "," + s.age);s.name = "林青霞";s.age = 30;System.out.println(s.name + "," + s.age);s.study();s.doHomework();}
}

2. 对象内存图

2.1 单个对象内存图

成员变量使用过程

成员方法调用过程

2.2 多个对象内存图

成员变量使用过程

成员方法调用过程

总结：

多个对象在堆内存中，都有不同的内存划分，成员变量存储在各自的内存区域中，成员方法多个对象共用的一份

2.3 多个对象指向相同内存图

总结

当多个对象的引用指向同一个内存空间（变量所记录的地址值是一样的）

只要有任何一个对象修改了内存中的数据，随后，无论使用哪一个对象进行数据获取，都是修改后的数据。

3. 成员变量和局部变量

3.1 成员变量和局部变量的区别

类中位置不同：成员变量（类中方法外）局部变量（方法内部或方法声明上）
内存中位置不同：成员变量（堆内存）局部变量（栈内存）
生命周期不同：成员变量（随着对象的存在而存在，随着对象的消失而消失）局部变量（随着方法的调用而存在，醉着方法的调用完毕而消失）
初始化值不同：成员变量（有默认初始化值）局部变量（没有默认初始化值，必须先定义，赋值才能使用）

4. 封装

4.1 private关键字

private是一个修饰符，可以用来修饰成员（成员变量，成员方法）

被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
- 提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
- 提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰

示例代码：

/*学生类*/
class Student {//成员变量String name;private int age;//提供get/set方法public void setAge(int a) {if(a<0 || a>120) {System.out.println("你给的年龄有误");} else {age = a;}}public int getAge() {return age;}//成员方法public void show() {System.out.println(name + "," + age);}
}
/*学生测试类*/
public class StudentDemo {public static void main(String[] args) {//创建对象Student s = new Student();//给成员变量赋值s.name = "林青霞";s.setAge(30);//调用show方法s.show();}
}

4.2 private的使用

需求：定义标准的学生类，要求name和age使用private修饰，并提供set和get方法以及便于显示数据的show方法，测试类中创建对象并使用，最终控制台输出林青霞，30

示例代码：

/*学生类*/
class Student {//成员变量private String name;private int age;//get/set方法public void setName(String n) {name = n;}public String getName() {return name;}public void setAge(int a) {age = a;}public int getAge() {return age;}public void show() {System.out.println(name + "," + age);}
}
/*学生测试类*/
public class StudentDemo {public static void main(String[] args) {//创建对象Student s = new Student();//使用set方法给成员变量赋值s.setName("林青霞");s.setAge(30);s.show();//使用get方法获取成员变量的值System.out.Name() + "---" + s.getAge());System.out.Name() + "," + s.getAge());}
}

4.3 this关键字

this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）
- 方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
- 方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

public class Student {private String name;private int age;public void setName(String name) {this.name = name;}public String getName() {return name;}public void setAge(int age) {this.age = age;}public int getAge() {return age;}public void show() {System.out.println(name + "," + age);}
}

4.4 this内存原理

this代表当前调用方法的引用，哪个对象调用的方法，this就代表哪一个对象

示例代码：

public class StudentDemo {public static void main(String[] args) {Student s1 = new Student();s1.setName("林青霞");Student s2 = new Student();s2.setName("张曼玉");}
}

图解：

4.5 封装思想

封装概述
是面向对象三大特征之一（封装，继承，多态）
是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的
封装原则
将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
成员变量private，提供对应的getXxx()/setXxx()方法
封装好处
通过方法来控制成员变量的操作，提高了代码的安全性
把代码用方法进行封装，提高了代码的复用性

5. 构造方法

5.1 构造方法概述

构造方法是一种特殊的方法

作用：创建对象 Student stu = new Student();
格式：

public class 类名{

修饰符类名( 参数 ) {

}

}
功能：主要是完成对象数据的初始化
示例代码：

class Student {private String name;private int age;//构造方法public Student() {System.out.println("无参构造方法");}public void show() {System.out.println(name + "," + age);}
}
/*测试类*/
public class StudentDemo {public static void main(String[] args) {//创建对象Student s = new Student();s.show();}
}

5.2 构造方法的注意事项

构造方法的创建

如果没有定义构造方法，系统将给出一个默认的无参数构造方法
如果定义了构造方法，系统将不再提供默认的构造方法

构造方法的重载

如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法

推荐的使用方式

无论是否使用，都手工书写无参数构造方法

重要功能！

可以使用带参构造，为成员变量进行初始化

示例代码

/*学生类*/
class Student {private String name;private int age;public Student() {}public Student(String name) {this.name = name;}public Student(int age) {this.age = age;}public Student(String name,int age) {this.name = name;this.age = age;}public void show() {System.out.println(name + "," + age);}
}
/*测试类*/
public class StudentDemo {public static void main(String[] args) {//创建对象Student s1 = new Student();s1.show();//public Student(String name)Student s2 = new Student("林青霞");s2.show();//public Student(int age)Student s3 = new Student(30);s3.show();//public Student(String name,int age)Student s4 = new Student("林青霞",30);s4.show();}
}

5.3 标准类制作

需求：定义标准学生类，要求分别使用空参和有参构造方法创建对象，空参创建的对象通过setXxx赋值，有参创建的对象直接赋值，并通过show方法展示数据。
示例代码：

class Student {//成员变量private String name;private int age;//构造方法public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}//成员方法public void setName(String name) {this.name = name;}public String getName() {return name;}public void setAge(int age) {this.age = age;}public int getAge() {return age;}public void show() {System.out.println(name + "," + age);}
}
/*创建对象并为其成员变量赋值的两种方式1:无参构造方法创建对象后使用setXxx()赋值2:使用带参构造方法直接创建带有属性值的对象
*/
public class StudentDemo {public static void main(String[] args) {//无参构造方法创建对象后使用setXxx()赋值Student s1 = new Student();s1.setName("林青霞");s1.setAge(30);s1.show();//使用带参构造方法直接创建带有属性值的对象Student s2 = new Student("林青霞",30);s2.show();}
}

6. 继承

6.1 继承的实现

继承的概念
- 继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法
实现继承的格式
- 继承通过extends实现
- 格式：class 子类 extends 父类 { }
  - 举例：class Dog extends Animal { }
继承带来的好处
- 继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员。

示例代码

public class Fu {public void show() {System.out.println("show方法被调用");}
}
public class Zi extends Fu {public void method() {System.out.println("method方法被调用");}
}
public class Demo {public static void main(String[] args) {//创建对象，调用方法Fu f = new Fu();f.show();Zi z = new Zi();z.method();z.show();}
}

6.2 继承的好处和弊端

继承好处
- 提高了代码的复用性(多个类相同的成员可以放到同一个类中)
- 提高了代码的维护性(如果方法的代码需要修改，修改一处即可)
继承弊端
- 继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性
继承的应用场景：
- 使用继承，需要考虑类与类之间是否存在is…a的关系，不能盲目使用继承
  - is…a的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类

7. 继承中的成员访问特点

7.1 继承中变量的访问特点

在子类方法中访问一个变量，采用的是就近原则。

子类局部范围找
子类成员范围找
父类成员范围找
如果都没有就报错(不考虑父亲的父亲…)

示例代码

class Fu {int num = 10;
}
class Zi {int num = 20;public void show(){int num = 30;System.out.println(num);}
}
public class Demo1 {public static void main(String[] args) {Zi z = new Zi();z.show();	// 输出show方法中的局部变量30}
}

7.2 super

this&super关键字：
- this：代表本类对象的引用
- super：代表父类存储空间的标识(可以理解为父类对象引用)
this和super的使用分别
- 成员变量：
  - this.成员变量 - 访问本类成员变量
  - super.成员变量 - 访问父类成员变量
- 成员方法：
  - this.成员方法 - 访问本类成员方法
  - super.成员方法 - 访问父类成员方法
构造方法：
- this(…) - 访问本类构造方法
- super(…) - 访问父类构造方法

7.3 继承中构造方法的访问特点

注意：子类中所有的构造方法默认都会访问父类中无参的构造方法

子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化，原因在于，每一个子类构造方法的第一条语句默认都是：super()

问题：如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？

1. 通过使用super关键字去显示的调用父类的带参构造方法
2. 在父类中自己提供一个无参构造方法

推荐方案：

自己给出无参构造方法

7.4 继承中成员方法的访问特点

通过子类对象访问一个方法

子类成员范围找
父类成员范围找
如果都没有就报错(不考虑父亲的父亲…)

7.5 super内存图

对象在堆内存中，会单独存在一块super区域，用来存放父类的数据

7.6 方法重写

1、方法重写概念
- 子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）
2、方法重写的应用场景
- 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容
3、Override注解
- 用来检测当前的方法，是否是重写的方法，起到【校验】的作用

7.7 方法重写的注意事项

方法重写的注意事项

私有方法不能被重写(父类私有成员子类是不能继承的)
子类方法访问权限不能更低(public > 默认 > 私有)

示例代码

public class Fu {private void show() {System.out.println("Fu中show()方法被调用");}void method() {System.out.println("Fu中method()方法被调用");}
}public class Zi extends Fu {/* 编译【出错】，子类不能重写父类私有的方法*/@Overrideprivate void show() {System.out.println("Zi中show()方法被调用");}/* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */@Overrideprivate void method() {System.out.println("Zi中method()方法被调用");}/* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */@Overridepublic void method() {System.out.println("Zi中method()方法被调用");}
}

7.8. Java中继承的注意事项

Java中继承的注意事项
1. Java中类只支持单继承，不支持多继承
  - 错误范例：class A extends B, C { }
2. Java中类支持多层继承

多层继承示例代码：

public class Granddad {public void drink() {System.out.println("爷爷爱喝酒");}}public class Father extends Granddad {public void smoke() {System.out.println("爸爸爱抽烟");}}public class Mother {public void dance() {System.out.println("妈妈爱跳舞");}}
public class Son extends Father {// 此时，Son类中就同时拥有drink方法以及smoke方法
}

8. 继承练习

8.1 老师和学生

需求：定义老师类和学生类，然后写代码测试；最后找到老师类和学生类当中的共性内容，抽取出一个父类，用继承的方式改写代码，并进行测试
步骤：

①定义老师类(姓名，年龄，教书())

②定义学生类(姓名，年龄，学习())

③定义测试类，写代码测试

④共性抽取父类，定义人类(姓名，年龄)

⑤定义老师类，继承人类，并给出自己特有方法：教书()

⑥定义学生类，继承人类，并给出自己特有方法：学习()

⑦定义测试类，写代码测试

示例代码：

class Person {private String name;private int age;public Person() {}public Person(String name, int age) {this.name = name;this.age = age;}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;}
}class Teacher extends Person {public Teacher() {}public Teacher(String name,int age) {super(name,age);}public void teach() {System.out.println("用爱成就每一位学员");}}class Student extends Person{public Student() {}public Student(String name, int age) {super(name,age);}public void study(){System.out.println("学生学习");}}class PersonDemo {public static void main(String[] args){//创建老师类对象并进行测试Teacher t1 = new Teacher();t1.setName("林青霞");t1.setAge(30);System.out.Name() + "," + t1.getAge());t1.teach();Teacher t2 = new Teacher("风清扬", 33);System.out.Name() + "," + t2.getAge());t2.teach();// 创建学生类对象测试Student s = new Student("张三"，23)；System.out.Name() + "," + s.getAge());s.study();}
}

8.2 猫和狗

需求：请采用继承的思想实现猫和狗的案例，并在测试类中进行测试
分析：

①猫：

成员变量：姓名，年龄

构造方法：无参，带参

成员方法：get/set方法，抓老鼠()

②狗：

成员变量：姓名，年龄

构造方法：无参，带参

成员方法：get/set方法，看门()

③共性：

成员变量：姓名，年龄；构造方法：无参，带参；成员方法：get/set方法
步骤：

1、定义动物类(Animal)

【成员变量：姓名，年龄】【构造方法：无参，带参】【成员方法：get/set方法】

2、定义猫类(Cat)，继承动物类

【构造方法：无参，带参】【成员方法：抓老鼠() 】

3、定义狗类(Dog)，继承动物类

【构造方法：无参，带参】【成员方法：看门() 】

4、定义测试类(AnimalDemo)，写代码测试

示例代码：

class Animal {private String name;private int age;public Animal() {}public Animal(String name, int age) {this.name = name;this.age = age;}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;}
}
class Cat extends Animal {public Cat() {}public Cat(String name, int age) {super(name, age);}public void catchMouse() {System.out.println("猫抓老鼠");}
}
class Dog extends Animal {public Dog() {}public Dog(String name, int age) {super(name, age);}public void lookDoor() {System.out.println("狗看门");}
}
/*测试类*/
public class AnimalDemo {public static void main(String[] args) {//创建猫类对象并进行测试Cat c1 = new Cat();c1.setName("加菲猫");c1.setAge(5);System.out.Name() + "," + c1.getAge());c1.catchMouse();Cat c2 = new Cat("加菲猫", 5);System.out.Name() + "," + c2.getAge());c2.catchMouse();}
}

9. 修饰符

9.1 package

1、包的概念
- 包就是文件夹，用来管理类文件的
2、包的定义格式
- package 包名; (多级包用.分开)
- 例如：package com.heima.demo;
3、带包编译&带包运行
- 带包编译：javac –d . 类名.java
  - 例如：javac -d . com.heima.demo.HelloWorld.java
- 带包运行：java 包名+类名
  - 例如：java com.heima.demo.HelloWorld

9.2 import

导包的意义

使用不同包下的类时，使用的时候要写类的全路径，写起来太麻烦了

为了简化带包的操作，Java就提供了导包的功能
导包的格式

格式：import 包名;

范例：import java.util.Scanner;
示例代码（没有使用导包，创建的Scanner对象）

package com.heima;public class Demo {public static void main(String[] args) {// 1. 没有导包，创建Scnaner对象java.util.Scanner sc = new java.util.Scanner(System.in);}
}

示例代码（使用导包后，创建的Scanner对象）

package com.heima;import java.util.Scanner;public class Demo {public static void main(String[] args) {// 1. 没有导包，创建Scnaner对象Scanner sc = new Scanner(System.in);}
}

9.3 权限修饰符

9.4 final

fianl关键字的作用
- final代表最终的意思，可以修饰成员方法，成员变量，类
final修饰类、方法、变量的效果
- fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）
- final修饰方法：该方法不能被重写
- final修饰变量：表明该变量是一个常量，不能再次赋值

9.5 final修饰局部变量

fianl修饰基本数据类型变量
- final 修饰指的是基本类型的数据值不能发生改变
final修饰引用数据类型变量
- final 修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的
- 举例：
```
public static void main(String[] args){final Student s = new Student(23);s = new Student(24);  // 错误s.setAge(24);  // 正确
}
```

9.6 static

static的概念
- static关键字是静态的意思，可以修饰【成员方法】，【成员变量】
static修饰的特点
1. 被类的所有对象共享，这也是我们判断是否使用静态关键字的条件
2. 可以通过类名调用当然，也可以通过对象名调用**【推荐使用类名调用】**
示例代码：

class Student {public String name; //姓名public int age; //年龄public static String university; //学校	共享数据！所以设计为静态！public void show() {System.out.println(name + "," + age + "," + university);}}public class StaticDemo {public static void main(String[] args) {// 为对象的共享数据赋值Student.university = "传智大学";Student s1 = new Student();s1.name = "林青霞";s1.age = 30;s1.show();Student s2 = new Student();s2.name = "风清扬";s2.age = 33;s2.show();}
}

9.7 static访问特点

static的访问特点
- 非静态的成员方法
  - 能访问静态的成员变量
  - 能访问非静态的成员变量
  - 能访问静态的成员方法
  - 能访问非静态的成员方法
- 静态的成员方法
  - 能访问静态的成员变量
  - 能访问静态的成员方法
- 总结成一句话就是：
  - 静态成员方法只能访问静态成员

10. 多态

10.1 多态的概述

什么是多态

同一个对象，在不同时刻表现出来的不同形态
多态的前提
- 要有继承或实现关系
- 要有方法的重写
- 要有父类引用指向子类对象

10.2 多态中的成员访问特点

成员访问特点
- 成员变量
  
  编译看父类，运行看父类
- 成员方法
  
  编译看父类，运行看子类

代码演示

动物类

public class Animal {public int age = 40;public void eat() {System.out.println("动物吃东西");}
}

猫类

public class Cat extends Animal {public int age = 20;public int weight = 10;@Overridepublic void eat() {System.out.println("猫吃鱼");}public void playGame() {System.out.println("猫捉迷藏");}
}

测试类

public class AnimalDemo {public static void main(String[] args) {//有父类引用指向子类对象Animal a = new Cat();System.out.println(a.age);
//        System.out.println(a.weight);a.eat();
//        a.playGame();}
}

10.3 多态的好处和弊端

好处

提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作
弊端

不能使用子类的特有成员

10.4 多态中的转型

向上转型

父类引用指向子类对象就是向上转型
向下转型

格式：子类型对象名 = (子类型)父类引用;

代码演示

动物类

public class Animal {public void eat() {System.out.println("动物吃东西");}
}

猫类

public class Cat extends Animal {@Overridepublic void eat() {System.out.println("猫吃鱼");}public void playGame() {System.out.println("猫捉迷藏");}
}

测试类

public class AnimalDemo {public static void main(String[] args) {//多态//向上转型Animal a = new Cat();a.eat();
//      a.playGame();//向下转型Cat c = (Cat)a;c.eat();c.playGame();}
}

10.5 多态的案例

案例需求

请采用多态的思想实现猫和狗的案例，并在测试类中进行测试

代码实现

动物类

public class Animal {private String name;private int age;public Animal() {}public Animal(String name, int age) {this.name = name;this.age = age;}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;}public void eat() {System.out.println("动物吃东西");}
}

猫类

public class Cat extends Animal {public Cat() {}public Cat(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println("猫吃鱼");}
}

狗类

public class Dog extends Animal {public Dog() {}public Dog(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println("狗吃骨头");}
}

测试类

public class AnimalDemo {public static void main(String[] args) {//创建猫类对象进行测试Animal a = new Cat();a.setName("加菲");a.setAge(5);System.out.Name() + "," + a.getAge());a.eat();a = new Cat("加菲", 5);System.out.Name() + "," + a.getAge());a.eat();}
}

11. 抽象类

11.1 抽象类的概述

当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了！

在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类！

11.2 抽象类的特点

抽象类和抽象方法必须使用 abstract 关键字修饰

//抽象类的定义
public abstract class 类名 {}
//抽象方法的定义
public abstract void eat();

抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
抽象类不能实例化

抽象类如何实例化呢？参照多态的方式，通过子类对象实例化，这叫抽象类多态
抽象类的子类

要么重写抽象类中的所有抽象方法

要么是抽象类

11.3 抽象类的成员特点

成员的特点
- 成员变量
  - 既可以是变量
  - 也可以是常量
- 构造方法
  - 空参构造
  - 有参构造
- 成员方法
  - 抽象方法
  - 普通方法

代码演示

动物类

public abstract class Animal {private int age = 20;private final String city = "北京";public Animal() {}public Animal(int age) {this.age = age;}public void show() {age = 40;System.out.println(age);//        city = "上海";System.out.println(city);}public abstract void eat();}

猫类

  public class Cat extends Animal {@Overridepublic void eat() {System.out.println("猫吃鱼");}}

测试类

  public class AnimalDemo {public static void main(String[] args) {Animal a = new Cat();a.eat();a.show();}}

11.4 抽象类的案例

案例需求

请采用抽象类的思想实现猫和狗的案例，并在测试类中进行测试

代码实现

动物类

  public abstract class Animal {private String name;private int age;public Animal() {}public Animal(String name, int age) {this.name = name;this.age = age;}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;}public abstract void eat();}

猫类

  public class Cat extends Animal {public Cat() {}public Cat(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println("猫吃鱼");}}

狗类

  public class Dog extends Animal {public Dog() {}public Dog(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println("狗吃骨头");}}

测试类

  public class AnimalDemo {public static void main(String[] args) {//创建对象，按照多态的方式Animal a = new Cat();a.setName("加菲");a.setAge(5);System.out.Name()+","&#Age());a.eat();System.out.println("--------");a = new Cat("加菲",5);System.out.Name()+","&#Age());a.eat();}}

12. 接口

12.1 接口的概述

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。

Java中的接口更多的体现在对行为的抽象！

12.2 接口的特点

接口用关键字interface修饰
```
public interface 接口名 {} 
```

类实现接口用implements表示

public class 类名 implements 接口名 {}

接口不能实例化

接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫接口多态。

多态的形式：具体类多态，抽象类多态，接口多态。
接口的子类

要么重写接口中的所有抽象方法

要么子类也是抽象类

12.3 接口的成员特点

成员特点
- 成员变量
  
  只能是常量
  默认修饰符：public static final
- 构造方法
  
  没有，因为接口主要是扩展功能的，而没有具体存在
- 成员方法
  
  只能是抽象方法
  
  默认修饰符：public abstract
  
  关于接口中的方法，JDK8和JDK9中有一些新特性，后面再讲解

代码演示

接口

  public interface Inter {public int num = 10;public final int num2 = 20;//    public static final int num3 = 30;int num3 = 30;//    public Inter() {}//    public void show() {}public abstract void method();void show();}

实现类

  public class InterImpl extends Object implements Inter {public InterImpl() {super();}@Overridepublic void method() {System.out.println("method");}@Overridepublic void show() {System.out.println("show");}}

测试类

  public class InterfaceDemo {public static void main(String[] args) {Inter i = new InterImpl();//        i.num = 20;System.out.println(i.num);//        i.num2 = 40;System.out.println(i.num2);System.out.println(Inter.num);}}

12.4 接口的案例

案例需求

对猫和狗进行训练，他们就可以跳高了，这里加入跳高功能。

请采用抽象类和接口来实现猫狗案例，并在测试类中进行测试。

代码实现

动物类

  public abstract class Animal {private String name;private int age;public Animal() {}public Animal(String name, int age) {this.name = name;this.age = age;}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;}public abstract void eat();}

跳高接口

  public interface Jumpping {public abstract void jump();}

猫类

  public class Cat extends Animal implements Jumpping {public Cat() {}public Cat(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println("猫吃鱼");}@Overridepublic void jump() {System.out.println("猫可以跳高了");}}

测试类

  public class AnimalDemo {public static void main(String[] args) {//创建对象，调用方法Jumpping j = new Cat();j.jump();System.out.println("--------");Animal a = new Cat();a.setName("加菲");a.setAge(5);System.out.Name()+","&#Age());a.eat();//        a.jump();a = new Cat("加菲",5);System.out.Name()+","&#Age());a.eat();System.out.println("--------");Cat c = new Cat();c.setName("加菲");c.setAge(5);System.out.Name()+","&#Age());c.eat();c.jump();}}

12.5 类和接口的关系

类与类的关系

继承关系，只能单继承，但是可以多层继承
类与接口的关系

实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
接口与接口的关系

继承关系，可以单继承，也可以多继承

12.6 抽象类和接口的区别

成员区别
- 抽象类
  
  变量,常量；有构造方法；有抽象方法,也有非抽象方法
- 接口
  
  常量；抽象方法
关系区别
- 类与类
  
  继承，单继承
- 类与接口
  
  实现，可以单实现，也可以多实现
- 接口与接口
  
  继承，单继承，多继承
设计理念区别
- 抽象类
  
  对类抽象，包括属性、行为
- 接口
  
  对行为抽象，主要是行为

13. 综合案例

13.1 案例需求

我们现在有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练。

为了出国交流，跟乒乓球相关的人员都需要学习英语。

请用所学知识分析，这个案例中有哪些具体类，哪些抽象类，哪些接口，并用代码实现。

13.2 代码实现

抽象人类

public abstract class Person {private String name;private int age;public Person() {}public Person(String name, int age) {this.name = name;this.age = age;}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;}public abstract void eat();
}

抽象运动员类

public abstract class Player extends Person {public Player() {}public Player(String name, int age) {super(name, age);}public abstract void study();
}

抽象教练类

public abstract class Coach extends Person {public Coach() {}public Coach(String name, int age) {super(name, age);}public abstract void teach();
}

学英语接口

public interface SpeakEnglish {public abstract void speak();
}

蓝球教练

public class BasketballCoach extends Coach {public BasketballCoach() {}public BasketballCoach(String name, int age) {super(name, age);}@Overridepublic void teach() {System.out.println("篮球教练教如何运球和投篮");}@Overridepublic void eat() {System.out.println("篮球教练吃羊肉，喝羊奶");}
}

乒乓球教练

public class PingPangCoach extends Coach implements SpeakEnglish {public PingPangCoach() {}public PingPangCoach(String name, int age) {super(name, age);}@Overridepublic void teach() {System.out.println("乒乓球教练教如何发球和接球");}@Overridepublic void eat() {System.out.println("乒乓球教练吃小白菜，喝大米粥");}@Overridepublic void speak() {System.out.println("乒乓球教练说英语");}
}

乒乓球运动员

public class PingPangPlayer extends Player implements SpeakEnglish {public PingPangPlayer() {}public PingPangPlayer(String name, int age) {super(name, age);}@Overridepublic void study() {System.out.println("乒乓球运动员学习如何发球和接球");}@Overridepublic void eat() {System.out.println("乒乓球运动员吃大白菜，喝小米粥");}@Overridepublic void speak() {System.out.println("乒乓球运动员说英语");}
}

篮球运动员

public class BasketballPlayer extends Player {public BasketballPlayer() {}public BasketballPlayer(String name, int age) {super(name, age);}@Overridepublic void study() {System.out.println("篮球运动员学习如何运球和投篮");}@Overridepublic void eat() {System.out.println("篮球运动员吃牛肉，喝牛奶");}
}

14. 参数传递

14.1 类名作为形参和返回值

1、类名作为方法的形参

方法的形参是类名，其实需要的是该类的对象

实际传递的是该对象的【地址值】
2、类名作为方法的返回值

方法的返回值是类名，其实返回的是该类的对象

实际传递的，也是该对象的【地址值】

示例代码：

class Cat {public void eat() {System.out.println("猫吃鱼");}
}
class CatOperator {public void useCat(Cat c) { //Cat c = new Cat();c.eat();}public Cat getCat() {Cat c = new Cat();return c;}
}
public class CatDemo {public static void main(String[] args) {//创建操作类对象，并调用方法CatOperator co = new CatOperator();Cat c = new Cat();co.useCat(c);Cat c2 = co.getCat(); //new Cat()c2.eat();}
}

14.2 抽象类作为形参和返回值

抽象类作为形参和返回值
- 方法的形参是抽象类名，其实需要的是该抽象类的子类对象
- 方法的返回值是抽象类名，其实返回的是该抽象类的子类对象

示例代码：

abstract class Animal {public abstract void eat();
}
class Cat extends Animal {@Overridepublic void eat() {System.out.println("猫吃鱼");}
}
class AnimalOperator {public void useAnimal(Animal a) { //Animal a = new Cat();a.eat();}public Animal getAnimal() {Animal a = new Cat();return a;}
}
public class AnimalDemo {public static void main(String[] args) {//创建操作类对象，并调用方法AnimalOperator ao = new AnimalOperator();Animal a = new Cat();ao.useAnimal(a);Animal a2 = ao.getAnimal(); //new Cat()a2.eat();}
}

14.3 接口名作为形参和返回值

接口作为形参和返回值
- 方法的形参是接口名，其实需要的是该接口的实现类对象
- 方法的返回值是接口名，其实返回的是该接口的实现类对象

示例代码：

interface Jumpping {void jump();
}
class JumppingOperator {public void useJumpping(Jumpping j) { //Jumpping j = new Cat();j.jump();}public Jumpping getJumpping() {Jumpping j = new Cat();return j;}
}
class Cat implements Jumpping {@Overridepublic void jump() {System.out.println("猫可以跳高了");}
}
public class JumppingDemo {public static void main(String[] args) {//创建操作类对象，并调用方法JumppingOperator jo = new JumppingOperator();Jumpping j = new Cat();jo.useJumpping(j);Jumpping j2 = jo.getJumpping(); //new Cat()j2.jump();}
}

15. 内部类

15.1 内部类的基本使用

内部类概念
- 在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类

内部类定义格式

格式&举例：

/*格式：class 外部类名{修饰符 class 内部类名{}}
*/class Outer {public class Inner {}
}

内部类的访问特点
- 内部类可以直接访问外部类的成员，包括私有
- 外部类要访问内部类的成员，必须创建对象

示例代码：

/*内部类访问特点：内部类可以直接访问外部类的成员，包括私有外部类要访问内部类的成员，必须创建对象*/
public class Outer {private int num = 10;public class Inner {public void show() {System.out.println(num);}}public void method() {Inner i = new Inner();i.show();}
}

15.2 成员内部类

成员内部类的定义位置
- 在类中方法，跟成员变量是一个位置
外界创建成员内部类格式
- 格式：外部类名.内部类名对象名 = 外部类对象.内部类对象;
- 举例：Outer.Inner oi = new Outer().new Inner();
成员内部类的推荐使用方案
- 将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。

示例代码：

class Outer {private int num = 10;private class Inner {public void show() {System.out.println(num);}}public void method() {Inner i = new Inner();i.show();}
}
public class InnerDemo {public static void main(String[] args) {//Outer.Inner oi = new Outer().new Inner();//oi.show();Outer o = new Outer();o.method();}
}

15.3 局部内部类

局部内部类定义位置
- 局部内部类是在方法中定义的类
局部内部类方式方式
- 局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用
- 该类可以直接访问外部类的成员，也可以访问方法内的局部变量

示例代码

class Outer {private int num = 10;public void method() {int num2 = 20;class Inner {public void show() {System.out.println(num);System.out.println(num2);}}Inner i = new Inner();i.show();}
}
public class OuterDemo {public static void main(String[] args) {Outer o = new Outer();o.method();}
}

15.4 匿名内部类

匿名内部类的前提
- 存在一个类或者接口，这里的类可以是具体类也可以是抽象类
匿名内部类的格式
- 格式：new 类名 ( ) { 重写方法 } new 接口名 ( ) { 重写方法 }
- 举例：
```
new Inter(){@Overridepublic void method(){}
} 
```
匿名内部类的本质
- 本质：是一个继承了该类或者实现了该接口的子类匿名对象
匿名内部类的细节
- 匿名内部类可以通过多态的形式接受
```
Inter i = new Inter(){@Overridepublic void method(){}
}
```

匿名内部类直接调用方法

interface Inter{void method();
}
class Test{public static void main(String[] args){new Inter(){@Overridepublic void method(){System.out.println("我是匿名内部类"); }}.method();	// 直接调用方法}
}

15.5 匿名内部类在开发中的使用

匿名内部类在开发中的使用
- 当发现某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的代码

示例代码：

  public class JumppingDemo {public static void main(String[] args) {//需求：创建接口操作类的对象，调用method方法JumppingOperator jo = new JumppingOperator();Jumpping j = new Cat();jo.method(j);Jumpping j2 = new Dog();jo.method(j2);System.out.println("--------");jo.method(new Jumpping() {@Overridepublic void jump() {System.out.println("猫可以跳高了");}});jo.method(new Jumpping() {@Overridepublic void jump() {System.out.println("狗可以跳高了");}});}}

本文发布于:2024-01-29 14:23:19，感谢您对本站的认可！

本文链接：https://www.4u4v.net/it/170650940115900.html

上一篇：羊大师讲解，肺病患者喝羊奶的惊人好处

下一篇：黑马Java第十一讲笔记—多态抽象类接口

标签：面向对象多态 Java

留言与评论（共有 0 条评论）