文章目录
面向对象编程（下）
1、static关键字
1.1、static关键字的使用
引入:
当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上的对象，
只有通过 new 关键字才会产生出对象，这时系统才会分配内存空间给对象，其方法才可以供外部调用。
我们有时候希望无论是否产生了对象或无论产生了多少对象的情况下，某些特定的数据在内存空间里只有一份。
例如所有的中国人都有个国家名称，每一个中国人的国籍名称，不必在每一个中国人的实例对象中都单独分配
一个用于代表国家名称的变量。
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1gLLqF88-1635522256730)(object_images3/image-20211028095525815.png)]](https://i-blog.csdnimg.cn/blog_migrate/9312457e9a512bd25710ffc88eb7d371.png)
static关键字的使用:
1)、static关键字: 静态的。
2)、static关键字: 可修饰 属性、方法、代码块、内部类。
3)、使用static修饰的：静态变量（类变量）
3.1)、属性: 是否使用static修饰，又分为：静态属性 && 非静态属性（实例变量）
3.2)、实例变量: 当我们创建了类的多个对象，每个对象都独立的拥有了一套类中的非静态属性。当修改其中一个非静态属性时，不会导致其他对象中同样的属性值的修饰。
静态变量: 我们创建了类的多个对象，多个对象共享同一个静态变量。当某一个对象修改该变量时，
会导致其他对象调用此静态变量时，是修改过的。
3.3)、static修饰属性的其他说明:
①.静态属性随着类的加载而加载，可以通过"类.属性"的方式进行调用。
②.静态属性的加载要早于对象的创建
③.由于类只加载一次，则静态变量在内存也只会存在一次，存在方法区的静态域中。
④ 类变量 实例变量
类 yes no
对象 yes yes
代码演示：
package com.rucoding.day13;
/**
* @author LiuYiXin
*
*/
/*
* static 关键字的使用
*
* 1.static:静态的。
* 2.static 可以用来修饰:属性、方法、代码块、内部类。
*
* 3.使用 static 修饰属性:静态变量(或类变量)。
* 3.1 属性:是否使用 static 修饰，又分为:静态属性 VS 非静态属性(实例变量)
* 实例变量:我们创建了类的多个对象，每个对象都独立的拥有了一套类中的非静态属性。
* 当修改其中一个非静态属性时，不会导致其他对象中同样的属性值的修饰。
* 静态变量:我们创建了类的多个对象，多个对象共享同一个静态变量。当通过静态变量去修改某一个变量时，
* 会导致其他对象调用此静态变量时，是修改过的。
* 3.2 static 修饰属性的其他说明:
* ① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用。
* ② 静态变量的加载要早于对象的创建。
* ③ 由于类只会加载一次，则静态变量在内存中也只会存在一次。存在方法区的静态域中。
*
* ④ 类变量 实例变量
* 类 yes no
* 对象 yes yes
*
* 3.3 静态属性举例:System.out.Math.PI;
*
*/
public class StaticTest {
public static void main(String[] args) {
//类变量的加载是优于对象的创建的
Chinese.nation = "中国";
//创建对象，通过对象.属性 调用对象的内部结构
Chinese c1 = new Chinese();
c1.name = "一花";
c1.age = 21;
c1.nation = "CHN";
Chinese c2 = new Chinese();
c2.name = "三花";
c2.age = 22;
c2.nation = "CHINA";
System.out.println(c1.nation); //输出为 CHINA
//编译不通过
// Chinese.name = "张继科";
}
}
//创建类，设计类的属性和方法
class Chinese{
//
String name;
int age;
static String nation; //加static关键字修饰
}
1.2、类变量和实例变量的内存解析
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-svVQEtPt-1635522256733)(object_images3/image-20211028101328950.png)]](https://i-blog.csdnimg.cn/blog_migrate/d0160aa8e243f446e7c6be4a43e07f80.png)
1.3、static修饰的方法
/*
* 4).使用 static 修饰方法:静态方法
* ① 随着类的加载而加载，可以通过"类.静态方法"的方式调用
* ② 静态方法 非静态方法
* 类 yes no
* 对象 yes yes
* ③ 静态方法中，只能调用静态的方法或属性 (生命周期，静态属性、方法是优于对象的存在的)
* 非静态的方法中，可以调用所有的方法或属性
*
* 5).static 注意点:
* 5.1 在静态的方法内，不能使用 this 关键字、super 关键字 （this涉及到对象的创建，基于生命周期，静态是优于对象的创建）
* 5.2 关于静态属性和静态方法的使用，大家从生命周期的角度去理解。
*
* 6).开发中，如何确定一个属性是否需要声明 static 的？
* 》 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
* 》 类中的常量也常常声明为 static 【常量】
*
* 开发中，如何确定一个方法是否要声明为 static 的？
* 》 操作静态属性的方法，通常设置为 static 的 (静态方法调用静态属性的)
* 》 工具类中的方法，习惯上声明为 static 的。比如：Math、Arrays、Collections (工具类的使用)
*
*/
代码演示:
package com.rucoding.day13;
/**
* @author LiuYiXin
*
*/
/*
* static 关键字的使用
*
* 1.static:静态的。 2.static 可以用来修饰:属性、方法、代码块、内部类。
*
* 3.使用 static 修饰属性:静态变量(或类变量)。 3.1 属性:是否使用 static 修饰，又分为:静态属性 VS 非静态属性(实例变量)
* 实例变量:我们创建了类的多个对象，每个对象都独立的拥有了一套类中的非静态属性。 当修改其中一个非静态属性时，不会导致其他对象中同样的属性值的修饰。
* 静态变量:我们创建了类的多个对象，多个对象共享同一个静态变量。当通过静态变量去修改某一个变量时， 会导致其他对象调用此静态变量时，是修改过的。 3.2
* static 修饰属性的其他说明: ① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用。 ② 静态变量的加载要早于对象的创建。 ③
* 由于类只会加载一次，则静态变量在内存中也只会存在一次。存在方法区的静态域中。
*
* ④ 类变量 实例变量 类 yes no 对象 yes yes
*
* 3.3 静态属性举例:System.out.Math.PI;
*
*/
public class StaticTest {
public static void main(String[] args) {
// 类变量的加载是优于对象的创建的
Chinese.nation = "中国";
// 创建对象，通过对象.属性 调用对象的内部结构
Chinese c1 = new Chinese();
c1.name = "一花";
c1.age = 21;
c1.nation = "CHN";
Chinese c2 = new Chinese();
c2.name = "三花";
c2.age = 22;
c2.nation = "CHINA";
System.out.println(c1.nation); // 输出为 CHINA
// 编译不通过
// Chinese.name = "张继科";
//静态的方法可以直接调用
Chinese.show();
//基于生命周期考虑，静态修饰的属性和方法是随着类的加载而加载的，
//是优先于对象的创建的，所以，静态的方法只能调用静态的属性和方法
//不能调用非静态的属性和方法（实例变量，非静态方法是基于对象创建的）
//而对象是可以调用无论是否静态修饰的属性和方法的。
}
}
// 创建类，设计类的属性和方法
class Chinese {
//
String name;
int age;
static String nation; // 加static关键字修饰
public void eat() {
System.out.println("中国人吃中餐");
// 调用非静态结构
this.info();
System.out.println("name : " + name);
//调用静态方法
show();
//调用静态的属性
System.out.println(Chinese.nation);
}
public static void show(){
System.out.println("我是一个中国人！");
//可以调用静态的结构
System.out.println(Chinese.nation);
// eat();//静态的方法不能调用非静态的属性和方法
}
public void info(){
System.out.println("name : " + name + ",age : " + age);
}
}
1.4、static的应用举例
package com.rucoding.day13;
/**
* @author LiuYiXin
*
*/
public class CircleTest {
public static void main(String[] args) {
Circle c1 = new Circle();
Circle c2 = new Circle();
Circle c3 = new Circle(2.4);
System.out.println("圆的个数: " + Circle.getTotalCircle());
System.out.println("c1圆的id: " + c1.getId());
System.out.println("c2圆的id: " + c2.getId());
System.out.println("c3圆的id: " + c3.getId());
System.out.println("c3圆的面积: " + c3.findArea());
}
}
//创建类，设计类的属性和方法
class Circle{
private double radius;
private int id;//自动赋值操作，记录每个圆得编号
private static int totalCircle;//记录圆的个数
private static int intitId = 1001; //初始化id
//初始化构造器
/**
*
*/
public Circle() {
id = intitId++;
totalCircle++;
}
/**
* @param radius
* @param id
*/
public Circle(double radius) {
this();
// id = intitId++;
// totalCircle++;
this.radius = radius;
}
/**
* @return the radius
*/
public double getRadius() {
return radius;
}
/**
* @param radius the radius to set
*/
public void setRadius(double radius) {
this.radius = radius;
}
/**
* @return the totalCircle
*/
public static int getTotalCircle() {
return totalCircle;
}
/**
* @return the intitId
*/
public static int getIntitId() {
return intitId;
}
public double findArea(){
return Math.PI * radius * radius;
}
/**
* @return the id
*/
public int getId() {
return id;
}
}
1.5、static关键字的练习题
/*
* 编写一个类实现银行账户的概念，包含的属性有“帐号”、“密码”、“存款余额”、
* “利率”、“最小余额”，定义封装这些属性的方法。
* 账号要自动生成。编写主类，使用银行账户类，输入、输出 3 个储户的上述信息。
* 考虑：哪些属性可以设计成 static 属性。
*
*/
代码演示：
Account类：
package com.rucoding.day13;
/**
* @author LiuYiXin
*
*/
/*
* 编写一个类实现银行账户的概念，包含的属性有“帐号”、“密码”、“存款余额”、 “利率”、“最小余额”，定义封装这些属性的方法。
* 账号要自动生成。编写主类，使用银行账户类，输入、输出 3 个储户的上述信息。 考虑：哪些属性可以设计成 static 属性。
*
*/
public class Account {
// 定义属性
private int id; // 账号 id自动生成
private String pwd; // 密码
private double balance;// 存款余额
// 静态属性，可以被所有对象共享
private static double yearRate;
private static double minMoney = 1.0; // 办卡初始充值余额
// 定义初始化的id值
private static int initId = 1001;
/**
* @param pwd
* @param balance
*/
public Account(String pwd, double balance) {
this();
this.pwd = pwd;
this.balance = balance;
}
/**
*
*/
public Account() {
id = initId++;
}
/**
* @return the yearRate
*/
public static double getYearRate() {
return yearRate;
}
/**
* @param yearRate
* the yearRate to set
*/
public static void setYearRate(double yearRate) {
Account.yearRate = yearRate;
}
/**
* @return the minMoney
*/
public static double getMinMoney() {
return minMoney;
}
/**
* @param minMoney
* the minMoney to set
*/
public static void setMinMoney(double minMoney) {
Account.minMoney = minMoney;
}
/**
* @return the id
*/
public int getId() {
return id;
}
/**
* @return the balance
*/
public double getBalance() {
return balance;
}
/**
* @return the initId
*/
public static int getInitId() {
return initId;
}
/**
* @param pwd
* the pwd to set
*/
public void setPwd(String pwd) {
this.pwd = pwd;
}
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
return "Account [id=" + id + ", pwd=" + pwd + ", balance=" + balance + "]";
}
}
AccountTest测试类：
package com.rucoding.day13;
/**
* @author LiuYiXin
*
*/
public class AccountTest {
public static void main(String[] args) {
Account acct1 = new Account();
Account acct2 = new Account("123456", 2000);
Account.setYearRate(0.045); //静态属性，直接通过 “类.变量” 调用
Account.setMinMoney(50);
System.out.println(acct1);
System.out.println(acct2.toString());
System.out.println(acct1.getYearRate());
System.out.println(acct2.getMinMoney());
}
}
1.6、单例设计模式（Singleton）
单例设计模式:
1)、所谓的单例设计模式，即是采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例
2)、单例模式的类别: 饿汉式 & 懒汉式
3)、如何区别 饿汉式 && 懒汉式
饿汉式: 一上来就直接创建对象的属性，
坏处: 对象的加载时间长
好处: 饿汉式是线程安全的
懒汉式: 先赋值为null，需要的时候再创建对象
坏处: 目前的写法是线程不安全的（后续完善）
好处: 延迟对象的创建。
代码演示：
1.6.1、单例模式&饿汉式:
package com.rucoding.day14;
/**
* @author LiuYiXin
*
*/
public class SingletoeHungryTest {
//静态属性或者方法，通过 类.属性 调用
public static void main(String[] args) {
ConnectPool instance1 = ConnectPool.getInstance();
ConnectPool instance2 = ConnectPool.getInstance();
//比较两个对象实例的地址
System.out.println(instance1 == instance2); //true
}
}
// 创建类
class ConnectPool {
// 单例模式，意味着这个类在内存中只有一份实例对象
// 1.构造器设置为私有化，不允许再通过new创建,保证单一性
private ConnectPool() {
}
// 2.创建对象
// 4.静态方法，调用静态属性
private static ConnectPool instance = new ConnectPool();
// 3.对外提供公共的方法，获取实例
public static ConnectPool getInstance(){
return instance;
}
}
1.6.2、单例模式&懒汉式:
package com.rucoding.day14;
/**
* @author LiuYiXin
*
*/
public class SingletonLazyTest {
public static void main(String[] args) {
Application instance1 = Application.getInstance();
Application instance2 = Application.getInstance();
//比较两个实例对象的地址值是否相同
System.out.println(instance1 == instance2); //true
}
}
// 创建类
class Application {
// 单例模式，意味着在类的内存中只有一份内存
// 1.构造方法，new对象的本质就是调用构造方法，设置为private
Application() {
}
// 2.声明实例属性，懒得初始化
// 4.静态方法调用静态属性
private static Application instance = null;
// 3.对外提供获取实例的方法
public static Application getInstance(){
//判断是否创建对象了, 没有就创建对象
if(instance == null){ //这里是线程安全问题出现点，假如堵塞了，某一瞬间，同时存在两个进入if语句，此时就相同于new两次了
instance = new Application();
}
return instance;
}
}
1.6.3、单例模式的优点
由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，
如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后
永久驻留内存的方式来解决。
举例 java.lang.Runtime类（单例模式 饿汉式）
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bwEyqGLL-1635522256736)(object_images3/image-20211028155414396.png)]](https://i-blog.csdnimg.cn/blog_migrate/f97ac1d82613ac5af56d6e8b3c024900.png)
1.6.4、单例(Singleton)设计模式-应用场景
网站的计数器，一般也是单例模式实现，否则难以同步。
应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。
项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，都生成一个对象去读取。
Application也是单例的典型应用
Windows 的 **Task Manager (任务管理器)**就是很典型的单例模式
Windows 的 **Recycle Bin(回收站)**也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。
2、main()方法的语法理解 （了解）
由于 Java 虚拟机需要调用类的 main()方法，所以该方法的访问权限必须是 public，又因为 Java 虚拟机
在执行 main()方法时不必创建对象，所以该方法必须是 static 的，该方法接收一个 String 类型的数组参数，
该数组中保存执行 Java 命令时传递给所运行的类的参数。
又因为 main() 方法是静态的，我们不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，
才能通过这个对象去访问类中的非静态成员，这种情况，我们在之前的例子中多次碰到。
代码演示：
package com.rucoding.day14;
/**
* @author LiuYiXin
*
*/
public class MainMethodTest {
//选择运行的程序主入口
public static void main(String[] args) {
Main.main(new String[100]);
// show(); //静态方法无法调用非静态方法show()
MainMethodTest test = new MainMethodTest();
test.show(); //通过类的创建，调用非静态方法
}
public void show(){
}
}
class Main {
public static void main(String[] args) {
//遍历形参数组
for(int i=0;i < args.length;i++){
args[i] = "args_" + i;
System.out.println(args[i]);
}
}
}
main()方法命令行参数用法举例
package com.rucoding.day14;
/**
* @author LiuYiXin
*
*/
public class MainMethodArgsTest {
//main()方法的 形参String[] args数组，可以用作交互
public static void main(String[] args) {
for (int i = 0; i < args.length; i++) {
System.out.println(args[i]);
}
}
}
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YXkzVzez-1635522256737)(object_images3/image-20211028160712253.png)]](https://i-blog.csdnimg.cn/blog_migrate/1470f054ceb13c65cc367a024a281bad.png)
控制台执行，（运行时期，传实参给形参）：
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kKa3JrM9-1635522256738)(object_images3/image-20211028160939739.png)]](https://i-blog.csdnimg.cn/blog_migrate/a4f385a719f3a3594db205b825682eb4.png)
3、类的成员之四：代码块
/*
* 类的成员之四:代码块（或初始化块）
*
* 1.代码块的作用：用来初始化类、对象的
* 2.代码块如果有修饰的话，只能使用 static
* 3.分类:静态代码块 vs 非静态代码块
*
* 4.静态代码块
* 》内部可以有输出语句
* 》随着类的加载而执行,而且只执行一次
* 》作用:初始化类的信息
* 》如果一个类中，定义了多个静态代码块，则按照声明的先后顺序执行
* 》静态代码块的执行，优先于非静态代码块的执行
* 》静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构
*
* 5.非静态代码块
* >内部可以有输出语句
* >随着对象的创建而执行
* >每创建一个对象，就执行一次非静态代码块。
* >作用:可以在创建对象时，对对象的属性等进行初始化。
* >如果一个类中，定义了多个非静态代码块，则按照声明的先后顺序执行
* >非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法。
*
* 对属性可以赋值的位置:
* ①默认初始化
* ②显式初始化
* ③构造器中初始化
* ④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值。
* ⑤在代码块中赋值
*/
代码演示：
package com.rucoding.day14;
/**
* @author LiuYiXin
*
*/
public class BlockTest {
public static void main(String[] args) {
//随着类的加载而执行,而且只执行一次
String desc = Person.desc; //此时静态的代码块的内容会输出
System.out.println(desc);
Person p1 = new Person(); //创建对象，非静态代码块会执行
Person p2 = new Person();
System.out.println(p1.age);
//
Person.info(); //此时的静态方法是随着类的加载而加载的，而static是随着类的加载而执行的
}
}
class Person{
//设置属性
String name;
int age;
static String desc = "我是人嘛?";
//代码块
//①.静态代码块
static{
//静态代码块 内部可以有输出语句
System.out.println("我是加了static修饰的静态代码块");
// 作用:初始化类的信息
//静态代码块，调用静态的属性结构
desc = "我不是人嘛";
//静态的方法不能调用非静态的属性和方法
// eat();
// name = "Jack";
}
//②.非静态代码块
{
System.out.println("我是非静态代码块哦");
//给属性赋值
age = 18;
//非静态的可以调用静态的属性和方法
info();
name = "Tom";
desc = "我确实是个人！";
}
//构造器
public Person(){}
/**
* @param name
* @param age
*/
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
//方法 非静态方法
public void eat(){
System.out.println("恰饭");
}
//静态方法
public static void info(){
System.out.println("我是一个很爱学习的人哦！");
}
//打印对象信息toString()方法
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
静态初始化块举例 1
package com.rucoding.day14;
class Root{
static{
System.out.println("Root的静态初始化块");
}
{
System.out.println("Root的普通初始化块");
}
public Root(){
System.out.println("Root的无参数的构造器");
}
}
class Mid extends Root{
static{
System.out.println("Mid的静态初始化块");
}
{
System.out.println("Mid的普通初始化块");
}
public Mid(){
System.out.println("Mid的无参数的构造器");
}
public Mid(String msg){
//通过this调用同一类中重载的构造器
this();
System.out.println("Mid的带参数构造器，其参数值："
+ msg);
}
}
class Leaf extends Mid{
static{
System.out.println("Leaf的静态初始化块");
}
{
System.out.println("Leaf的普通初始化块");
}
public Leaf(){
//通过super调用父类中有一个字符串参数的构造器
super("尚硅谷");
System.out.println("Leaf的构造器");
}
}
public class LeafTest{
public static void main(String[] args){
new Leaf(); //分析，由父及子，静态优先
System.out.println("====================");
new Leaf();
}
}
静态初始化块举例 2
package com.rucoding.day14;
class Father {
static {
System.out.println("11111111111");
}
{
System.out.println("22222222222");
}
public Father() {
System.out.println("33333333333");
}
}
public class Son extends Father {
static {
System.out.println("44444444444");
}
{
System.out.println("55555555555");
}
public Son() {
System.out.println("66666666666");
}
public static void main(String[] args) { // 由父及子 静态先行
System.out.println("77777777777");
System.out.println("************************");
new Son();
System.out.println("************************");
new Son();
System.out.println("************************");
new Father();
}
}
小结
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-D1LFOXqc-1635522256739)(object_images3/image-20211029093254154.png)]](https://i-blog.csdnimg.cn/blog_migrate/5e6abb73f3a12fdde273012719a5e04a.png)
代码演示：
package com.rucoding.day14;
/**
* @author LiuYiXin
*
*/
/*
* 对属性可以赋值的位置:
* ①默认初始化
* ②显式初始化 / ⑤在代码块中赋值
* ③构造器中初始化
* ④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值。
*
* 执行的先后顺序:① - ② / ⑤ - ③ - ④
*/
public class OrderTest {
public static void main(String[] args) {
Order order = new Order();
order.setOrderId(6);
System.out.println(order.orderId);
}
}
class Order{
int orderId = 3;
{
orderId = 4; //
}
/**
* @return the orderId
*/
public int getOrderId() {
return orderId;
}
/**
* @param orderId the orderId to set
*/
public void setOrderId(int orderId) {
this.orderId = orderId;
}
}
4、final关键字
/*
* final:最终的
*
* 1.final可以用来修饰的结构:类、方法、变量
*
* 2.final用来修饰一个类:此类不能被其他类所继承。
* 比如:String类、System类、StringBuffer类
* 3.final修饰一个方法:final标记的方法不能被子类重写。
* 比如：Object类中的getClass()。
* 4.final用来修饰变量:此时的"变量"(成员变量或局部变量)就是一个常量。名称大写，且只能被赋值一次。
* 4.1 final修饰属性，可以考虑赋值的位置有:显式初始化、代码块中初始化、构造器中初始化
* 4.2 final修饰局部变量:
* 尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。
* 一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。
*
* static final 用来修饰:全局常量
*/
代码演示：
package com.rucoding.day14;
/**
* @author LiuYiXin
*
*/
public class FInalTest {
//3.final修饰属性
final int WIDTH = 0; //加上final得进行初始化 final修饰的常量，习惯大写，ctrl+shift+x
final int LEFT; //代码块进行初始化
final int RIGHT;//构造器进行初始化
// final int HEIGHT;
//代码块进行属性的初始化
{
LEFT = 1;
}
//构造器进行属性的初始化
public FInalTest(){
RIGHT = 2;
}
public FInalTest(int right){
this.RIGHT = right;
}
/**
* @return the hEIGHT
*/
public int getHEIGHT() {
return HEIGHT;
}
// public void setHEIGHT(int height){
// this.HEIGHT = height;
// }
}
final class Bank{ //1.final修饰的类不能被继承，最终类
}
//class SubBank extends Bank{//The type SubBank cannot subclass the final class Bank
//}
class MuBank{
public final void show(){} //2.final修饰的方法不能被重写
}
class ZiBank extends MuBank{
//final修饰的方法不能被重写
// public final void show(){} //Cannot override the final method from MuBank
}
面试题1
public class Something {
public int addOne(final int x) {
return ++x; //编译不通过
// return x + 1; //编译运行都ok
}
}
面试题2
package com.rucoding.day14;
/**
* @author LiuYiXin
*
*/
public class Something {
public static void main(String[] args) {
Other o = new Other();
new Something().addOne(o);
}
public void addOne(final Other o) {
// o = new Other(); //o类型重新进行new ,编译无法通过
o.i++; //调用的是Other类中的i属性，不是final修饰的 编译运行都ok
}
}
class Other {
public int i;
}
5、抽象类与抽象方法
1)、面向对象程序设计 {自我认知过程}: 寻找对象、创建对象、使用对象、维护对象之间的交互关系。
随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。
2)、抽象类、抽象方法自诞生以来的使命责任: 抽象类的使命是 被继承，抽象方法的使命是 被重写。
3)、 abstract 关键字的使用
①.abstract:抽象的
②.abstract 可以用来修饰的结构:类、方法
③.abstract 修饰类:抽象类
>此类不能实例化
>抽象类中一定有构造器，便于子类实例化时调用(涉及:子类对象实例化全过程 子类继承父类，加载父类的结构)
>开发中，都会提供抽象类的子类，让子类对象实例化，实现相关的操作
④.abstract 修饰方法:抽象方法
>抽象方法，只有方法的声明，没有方法体。
>包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法
>若子类重写了父类中的所有的抽象方法后，此子类方可实例化
>若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰
☆☆☆ abstract 使用上的注意点:
>abstract 不能用来修饰变量、代码块、构造器；
>abstract 不能用来修饰私有方法、静态方法(抽象方法使命责任是被重写的，之前我们提到父子类同时用static声明的方法 不是重写的)、final 的方法、final 的类。
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hoiJd4za-1635522256740)(object_images3/image-20211029093628298.png)]](https://i-blog.csdnimg.cn/blog_migrate/775d857f661a91015686cbbf89c07dae.png)
代码演示：
package com.rucoding.day14_1;
/**
* @author LiuYiXin
*
*/
/*
* abstract 关键字的使用
*
* 1.abstract:抽象的
* 2.abstract 可以用来修饰的结构:类、方法
* 3.abstract 修饰类:抽象类
* 》 此类不能实例化
* 》 抽象类中一定有构造器，便于子类实例化时调用(涉及:子类对象实例化全过程)
* 》 开发中，都会提供抽象类的子类，让子类对象实例化，实现相关的操作
*
* 4.abstract 修饰方法:抽象方法
* > 抽象方法，只有方法的声明，没有方法体。
* > 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法
* > 若子类重写了父类中所有的抽象方法，此子类，
*
* abstract 使用上的注意点:
* 1.abstract 不能用来修饰变量、代码块、构造器；
*
* 2.abstract 不能用来修饰私有方法、静态方法、final 的方法、final 的类。
*
*/
public class AbstractTest {
public static void main(String[] args) {
//抽象类不能被实例化
// Person person = new Person();
// person.walk();
}
}
//创建类，设计类的属性和方法
//创建抽象类
abstract class Creature{ //2.abstract 可以用来修饰的结构:类、方法
//抽象方法 1.abstract:抽象的
public abstract void breath(); //2.abstract 可以用来修饰的结构:类、方法
//> 抽象方法，只有方法的声明，没有方法体。
// Abstract methods do not specify a body 抽象方法没有方法体的
public abstract void getIt(); //Abstract methods do not specify a body
// 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法
}
//抽象类自诞生就是不能被实例化的， 使命责任就是被重写的
//Creature抽象类 定义了抽象方法，子类必须实现即是重写方法，不然子类必须是声明为抽象类
abstract class Person extends Creature{ //此抽象类不能实例化
//属性
String name;
int age;
public Person(){} //抽象类中一定有构造器，便于子类实例化时调用(涉及:子类对象实例化全过程)
/**
* @param name
* @param age
*/
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public void walk(){
System.out.println("人走路");
}
// /* (non-Javadoc)
// * @see com.rucoding.day14_1.Creature#getIt()
// */
// @Override
// public void getIt() {
// // TODO Auto-generated method stub
//
// }
//
// 4.abstract 修饰方法:抽象方法
@Override
public abstract void getIt(); //抽象方法abstract修饰
}
//既然上述父类是抽象类，抽象类又不能被实例化，那么得想方设法让其可以进行实例化
//该任务就交给了子类来实现了，子类继承抽象类的父类，重写实现对应的抽象方法
class Student extends Person{ //开发中，都会提供抽象类的子类，让子类对象实例化，实现相关的操作
String major;
/**
*
*/
public Student() {
super();
}
/**
* @param name
* @param age
* @param major
*/
public Student(String name, int age, String major) {
super(name, age);
this.major = major;
}
/* (non-Javadoc)
* @see com.rucoding.day14_1.Person#getIt()
*/
@Override
public void getIt() {
// TODO Auto-generated method stub
}
/* (non-Javadoc)
* @see com.rucoding.day14_1.Creature#breath()
*/
@Override
public void breath() {
// TODO Auto-generated method stub
}
}
小结
抽象类、抽象方法自诞生的使命责任就是被继承、被重写。
5.1、抽象类应用
抽象类是用来模型化那些父类无法确定全部实现，而是由其子类提供具体实现的对象的类。
示例场景：
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-boRRyano-1635522256742)(object_images3/image-20211029102124170.png)]](https://i-blog.csdnimg.cn/blog_migrate/42b43b41148336d654b55b2c36add295.png)
针对上述问题【设计抽象类及其子类】：
package com.rucoding.day14_1;
/**
* @author LiuYiXin
*
*/
public abstract class Vehicle {
//定义为抽象类，并声明如下的抽象方法
public abstract double calcFuelEfficiency();//计算燃料效率的抽象方法
public abstract double calcTripDistance();//计算行驶距离的抽象方法
}
//父类定义为抽象类， 子类继承父类并实现所有的抽象方法，方可进行实例化
class Truck extends Vehicle{
/* (non-Javadoc)
* @see com.rucoding.day14_1.Vehicle#calcFuelEfficiency()
*/
@Override
public double calcFuelEfficiency() {
//写出计算卡车的燃料效率的具体方法
return 0;
}
/* (non-Javadoc)
* @see com.rucoding.day14_1.Vehicle#calcTripDistance()
*/
@Override
public double calcTripDistance() {
// TODO Auto-generated method stub
//写出计算卡车行驶距离的具体方法
return 0;
}
}
5.2、抽象类的练习1
/*
* 编写一个 Employee 类，声明为抽象类，
* 包含如下三个属性：name，id，salary。
* 提供必要的构造器和抽象方法：work()。
* 对于 Manager 类来说，他既是员工，还具有奖金(bonus)的属性。
* 请使用继承的思想，设计 CommonEmployee 类和 Manager 类，
* 要求类中提供必要的方法进行属性访问。
*
*/
抽象类Employee：
package com.rucoding.day14_1;
/**
* @author LiuYiXin
*
*/
/*
* 编写一个 Employee 类，声明为抽象类，
* 包含如下三个属性：name，id，salary。
* 提供必要的构造器和抽象方法：work()。
* 对于 Manager 类来说，他既是员工，还具有奖金(bonus)的属性。
* 请使用继承的思想，设计 CommonEmployee 类和 Manager 类，
* 要求类中提供必要的方法进行属性访问。
*
*/
public abstract class Employee {
String name;
int id;
double salary;
/**
*
*/
public Employee() {
super();
}
/**
* @param name
* @param id
* @param salary
*/
public Employee(String name, int id, double salary) {
super();
this.name = name;
this.id = id;
this.salary = salary;
}
//抽象方法
public abstract void work();
}
Manager类：
package com.rucoding.day14_1;
/**
* @author LiuYiXin
*
*/
public class Manager extends Employee{
double bonus;
/**
*
*/
public Manager() {
super();
}
/**
* @param bonus
*/
public Manager(double bonus) {
super();
this.bonus = bonus;
}
/**
* @param name
* @param id
* @param salary
* @param bonus
*/
public Manager(String name, int id, double salary, double bonus) {
super(name, id, salary);
this.bonus = bonus;
}
/* (non-Javadoc)
* @see com.rucoding.day14_1.Employee#work()
*/
@Override
public void work() {
// TODO Auto-generated method stub
System.out.println("管理员工，提高公司运行效率。");
}
}
CommonEmployee类：
package com.rucoding.day14_1;
/**
* @author LiuYiXin
*
*/
public class CommonEmployee extends Employee{
/* (non-Javadoc)
* @see com.rucoding.day14_1.Employee#work()
*/
@Override
public void work() {
// TODO Auto-generated method stub
System.out.println("员工在一线车间生产产品。");
}
}
EmployeeTest测试类：
package com.rucoding.day14_1;
/**
* @author LiuYiXin
*
*/
public class EmployeeTest {
public static void main(String[] args) {
Employee manager = new Manager("", 1001, 5000, 5000);
manager.work();
CommonEmployee commonEmployee = new CommonEmployee();
commonEmployee.work();
}
}
5.3、创建抽象类的匿名子类对象
代码演示：
package com.rucoding.day14_1;
/**
* @author LiuYiXin
* 创建抽象类的匿名子类对象
*/
public class AbstractClassAnonymousSubClass {
public static void main(String[] args) {
MuBank bank = new ZiBank();
bank.reserve();
bank.getANumber();
System.out.println("================");
//创建抽象类的子类匿名对象
MuBank mBank = new MuBank() {
@Override
public void reserve() {
// TODO Auto-generated method stub
System.out.println("子类匿名对象：预定服务");
}
@Override
public void getANumber() {
// TODO Auto-generated method stub
System.out.println("子类匿名对象：叫号排队服务");
}
};
//
methodPrint(mBank);
}
//
public static void methodPrint(MuBank mBank){
mBank.reserve();
mBank.getANumber();
}
}
//母公司银行
abstract class MuBank{
//定义抽象方法
public abstract void reserve();//预约功能
public abstract void getANumber();//叫号排队
}
class ZiBank extends MuBank{
/* (non-Javadoc)
* @see com.rucoding.day14_1.MuBank#reserve()
*/
@Override
public void reserve() {
// TODO Auto-generated method stub
System.out.println("子公司系统的预约功能");
}
/* (non-Javadoc)
* @see com.rucoding.day14_1.MuBank#talkANumber()
*/
@Override
public void getANumber() {
// TODO Auto-generated method stub
System.out.println("子公司的叫号排队功能");
}
}
Eclipse自动生成：输入 new MuBank，按住Ctrl + /，就会出来提示匿名内部类
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IamGOeGk-1635522256743)(object_images3/image-20211029104821510.png)]](https://i-blog.csdnimg.cn/blog_migrate/69da6649fda90effa4870edb7efa78ba.png)
5.4、多态的应用：模板方法设计模式(TemplateMethod)
抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。
☆☆☆☆☆解决的问题：
当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
换句话说，在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。
但是某些部分易变，易变部分可以抽象出来，供不同子类实现。这就是一种模板模式。
代码示例一：
package com.rucoding.day14_1;
/**
* @author LiuYiXin
*
* 抽象类的应用: 模板方法的设计模式
*/
public class TemplateTest {
public static void main(String[] args) {
Template template = new SubTemplate();
template.spendTime();
}
}
// 创建抽象类，设计类的抽象方法
abstract class Template {
// 定义方法
// 计算某段代码执行所需花费的时间
public void spendTime() {
long startTime = System.currentTimeMillis();
// 具体是执行哪一段代码，并不确定，所以，我们定义为抽象的，具体实现让子类去描述
codeExecute();
long endTime = System.currentTimeMillis();
System.out.println("执行的代码耗时：" + (endTime - startTime) + "毫秒");
}
//
public abstract void codeExecute();
}
//子类来继承父类的，并重写对应的抽象方法
class SubTemplate extends Template{
/* (non-Javadoc)
* @see com.rucoding.day14_1.Template#codeExecute()
*/
@Override
public void codeExecute() {
// TODO Auto-generated method stub
//子类具体执行的代码
/**
* 求1000以内的素数
* 分析质数（素数），从2开始，只有1和本身能整除的数
*/
for(int i=2;i <=1000;i++){ //外层控制行数，内层控制列数
//判断整除的情况
boolean isFlag = true;
for(int j=2;j<=Math.sqrt(i);j++){
//判断能否整除
if(i % j == 0){
//能整除，说明不是质数，设置给标识
isFlag = false;
//继续下一次外层循环
break;//跳出当前就近的循环
}
}
//
if(isFlag){ //isFlag是为true
System.out.println("我是质数：" + i);
}
//重置isFlag
isFlag = true;
}
}
}
代码示例二：
package com.rucoding.day14_1;
/**
* @author LiuYiXin
*
*/
//抽象类的应用：模板方法的设计模式
public class TemplateMethodTest {
public static void main(String[] args) {
BankTemplateMethod btm = new DrawMoney();
btm.process();
BankTemplateMethod btm2 = new ManageMoney();
btm2.process();
}
}
//创建抽象类
abstract class BankTemplateMethod {
// 具体方法
public void takeNumber() { //通用的
System.out.println("取号排队");
}
public abstract void transact(); // 办理具体的业务 //钩子方法 //每个人来银行办理的业务内容都不一致，未明确，待子类具体实现
public void evaluate() {//通用的
System.out.println("反馈评分");
}
// 模板方法，把基本操作组合到一起，子类一般不能重写
public final void process() {
this.takeNumber();
this.transact();// 像个钩子，具体执行时，挂哪个子类，就执行哪个子类的实现代码
this.evaluate();
}
}
class DrawMoney extends BankTemplateMethod { //取钱的业务操作
public void transact() {
System.out.println("我要取款！！！");
}
}
class ManageMoney extends BankTemplateMethod { //理财操作
public void transact() {
System.out.println("我要理财！我这里有 2000 万美元!!");
}
}
小结
模板方法设计模式是编程中经常用得到的模式。各个框架、类库中都有他的
影子，比如常见的有:
数据库访问的封装
Junit单元测试
JavaWeb的Servlet中关于doGet/doPost方法调用
Hibernate中模板程序
Spring中JDBCTemlate、HibernateTemplate等
5.5、抽象类的练习2
编写工资系统，实现不同类型员工(多态)的按月发放工资。如果当月出现某个
Employee对象的生日，则将该雇员的工资增加100元。
实验说明：
（1）定义一个Employee类，该类包含：
private成员变量name,number,birthday，其中birthday 为MyDate类的对象；
abstract方法earnings()；
toString()方法输出对象的name,number和birthday。
（2）MyDate类包含:private成员变量year,month,day ；
toDateString()方法返回日期对应的字符串：xxxx年xx月xx日
（3）定义SalariedEmployee类继承Employee类，实现按月计算工资的员工处理。该类包括：private成员变量monthlySalary；
实现父类的抽象方法earnings(),该方法返回monthlySalary值；toString()方法输出员工类型信息及员工的name,number,birthday。
（4）参照SalariedEmployee类定义HourlyEmployee类，实现按小时计算工资的员工处理。该类包括：private成员变量wage和hour；
实现父类的抽象方法earnings(),该方法返回wage*hour值；
toString()方法输出员工类型信息及员工的name，number,birthday。
（5）定义PayrollSystem类，创建Employee变量数组并初始化，该数组存放各类雇员对象的引用。利用循环结构遍历数组元素，输出各个对象的类型,name,number,birthday,以及该对象生日。当键盘输入本月月份值时，如果本月是某个Employee对象的生日，还要输出增加工资信息。
代码演示：
抽象类Employee：
package com.rucoding.day14_2;
/**
* @author LiuYiXin
*
*/
public abstract class Employee {
// 定义属性
private String name;
private int number;
private MyDate birthday;
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @return the birthday
*/
public MyDate getBirthday() {
return birthday;
}
/**
* @param birthday the birthday to set
*/
public void setBirthday(MyDate birthday) {
this.birthday = birthday;
}
// 初始化构造器
/**
* @param name
* @param number
* @param birthday
*/
public Employee(String name, int number, MyDate birthday) {
super();
this.name = name;
this.number = number;
this.birthday = birthday;
}
// 抽象方法
public abstract double earnings();
/*
* (non-Javadoc)
*
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
return "[name=" + name + ", number=" + number + ", birthday=" + birthday.toDateString() + "]";
}
}
日期类MyDate：
package com.rucoding.day14_2;
/**
* @author LiuYiXin
*
*/
public class MyDate {
// 定义属性
private int year;
private int month;
private int day;
/**
* @return the year
*/
public int getYear() {
return year;
}
/**
* @param year the year to set
*/
public void setYear(int year) {
this.year = year;
}
/**
* @return the month
*/
public int getMonth() {
return month;
}
/**
* @param month the month to set
*/
public void setMonth(int month) {
this.month = month;
}
/**
* @return the day
*/
public int getDay() {
return day;
}
/**
* @param day the day to set
*/
public void setDay(int day) {
this.day = day;
}
/**
* @param year
* @param month
* @param day
*/
public MyDate(int year, int month, int day) {
super();
this.year = year;
this.month = month;
this.day = day;
}
// 返回xxxx年xx月xx日
public String toDateString() {
return year + "年" + month + "月" + day + "日";
}
}
子类SalariedEmployee：
package com.rucoding.day14_2;
/**
* @author LiuYiXin
*
*/
public class SalariedEmployee extends Employee {
private double monthlySalary;// 月工资
/**
* @param name
* @param number
* @param birthday
*/
public SalariedEmployee(String name, int number, MyDate birthday, double monthlySalary) {
super(name, number, birthday);
this.monthlySalary = monthlySalary;
// TODO Auto-generated constructor stub
}
/*
* (non-Javadoc)
* 该方法返回monthlySalary值
* @see com.rucoding.day14_2.Employee#earnings()
*/
@Override
public double earnings() {
// TODO Auto-generated method stub
return monthlySalary;
}
/* (non-Javadoc)
* 输出员工类型信息及员工的name,number,birthday
* @see java.lang.Object#toString()
*/
@Override
public String toString() { //父类已经定义了，直接调用返回即可
return "SalariedEmployee " + super.toString();
}
}
子类HourlyEmployee：
package com.rucoding.day14_2;
/**
* @author LiuYiXin
*
*/
public class HourlyEmployee extends Employee{
//定义属性
private double wage;//每小时的工资
private double hour; //工作时长
/**
* @param name
* @param number
* @param birthday
*/
public HourlyEmployee(String name, int number, MyDate birthday,double wage,double hour) {
super(name, number, birthday);
// TODO Auto-generated constructor stub
this.wage = wage;
this.hour = hour;
}
/* (non-Javadoc)
* @see com.rucoding.day14_2.Employee#earnings()
*/
@Override
public double earnings() {
// TODO Auto-generated method stub
return wage * hour;
}
/* (non-Javadoc)
* 输出员工类型信息及员工的name,number,birthday
* @see java.lang.Object#toString()
*/
@Override
public String toString() { //父类已经定义了，直接调用返回即可
return "HourlyEmployee " + super.toString();
}
}
测试类PayrollSystem：
package com.rucoding.day14_2;
import java.util.Calendar;
/**
* @author LiuYiXin
*
*/
public class PayrollSystem {
public static void main(String[] args) {
// 创建数组，在堆空间初始化长度为2
Employee[] employee = new Employee[2];
// 索引值为0上进行new对象，肯定会报错的
// employee[0] = new Employee();//Cannot instantiate the type Employee
// 体现多态性，子类来继承父类，子类负责创建实例
employee[0] = new SalariedEmployee("Tom", 1001, new MyDate(1997, 10, 24), 9000);
employee[1] = new HourlyEmployee("Hack", 1002, new MyDate(1998, 2, 28), 50, 220);
// 打印信息
// 本月是某个Employee对象的生日，还要输出增加工资信息。
// 获取当前的月份，后面会讲到的日期API
Calendar instance = Calendar.getInstance();
int month = instance.get(Calendar.MONTH); // JANUARY which is 0; 从0开始的
for (int i = 0; i < employee.length; i++) {
System.out.println(employee[i]);
System.out.println(employee[i].getName() + "的薪资为：" + employee[i].earnings());
if ((month + 1) == employee[i].getBirthday().getMonth()) {
System.out.println(employee[i].getName() + "：本月是你的生日，工资增加100");
System.out.println(employee[i].getName() + "：本月总发放工资详情为：" + "基本工资：" + employee[i].earnings() + " 生日福利： 100"
+ " 一共：" + (employee[i].earnings() + 100));
}
}
}
}
6、接口（interface）
6.1、接口的概述
一方面，有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java 不支持多重继承。有了接口，就可以得到多重继承的效果。
另一方面，有时必须从几个类中抽取出一些共同的行为特征，而它们之间又没有 is-a 的关系，仅仅是具有相同的行为特征而已。
(比如上面提及的抽象类图示，是有is-a关系的，人类是父类，官员和农民是子类，这里就描述了一种 is-a 关系，官员 is a 人类。)
例如：鼠标、键盘、打印机、扫描仪、摄像头、充电器、MP3 机、手机、数码相机、移动硬盘等 都支持 USB 连接。
☆☆☆接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。
继承是一个"是不是"的关系，而接口实现则是"能不能"的关系。
接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守。
接口和类关系；理解为并列的关系，类只支持单继承，接口则弥补了单继承，有了多实现。
图示案例：（继承是实线表示，接口实现是虚线表示的）
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CkPBjpCQ-1635522256744)(object_images3/image-20211029180841290.png)]](https://i-blog.csdnimg.cn/blog_migrate/36d0a4ed205501dba8d1d2396f3ee6aa.png)
下图作为代码演示：
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4YjGzxHU-1635522256745)(object_images3/image-20211029180907126.png)]](https://i-blog.csdnimg.cn/blog_migrate/20956b9ec7e303748e32371a92b2a623.png)
值得一记：
接口(interface)是抽象方法和常量值定义的集合。
接口的特征:
1)、用interface关键字来定义。
2)、接口中的所有成员变量都 默认是由 public static final 修饰的。
3)、接口中的所有抽象方法都 默认是由 public abstract 修饰的。
4)、接口中没有构造器。
5)、接口采用多继承机制。
代码演示：
package com.rucoding.day15;
/**
* @author LiuYiXin
*
*/
/*
* 接口的使用
* 1.接口使用 interface 来定义。
* 2.在 Java 中: 接口和类是并列的两个结构
* 3.如何去定义两个接口:定义接口中的成员
* 》3.1
* 》全局常量:public static final 的,但是书写中，可以省略不写。
* 》抽象方法:public abstract 的
*
* 》3.2 JDK8:除了全局常量和抽象方法之外，还可以定义静态方法、默认方法(略)。
*
* 4.接口中不能定义构造器！意味着接口不可以实例化。
*
* 5.Java 开发中，接口通过让类去实现(implements)的方式来使用。
* 如果实现类覆盖了接口中的所有方法，则此实现类就可以实例化
* 如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
*
* 6.Java 类可以实现多个接口 ---》弥补了 Java 单继承性的局限性
* 格式:class AA extends BB implementd CC,DD,EE
*
* 7.接口与接口之间是继承,而且可以多继承
*
**********************************
* 8.接口的具体使用，体现多态性
* 接口的主要用途就是被实现类实现。（面向接口编程）
* 9.接口，实际可以看作是一种规范
*
* 面试题:抽象类与接口有哪些异同？
*
*/
public class InterfaceTest {
public static void main(String[] args) {
// 接口的成员属性，可以直接通过 “接口名.属性名”调用,因为是static修饰的
System.out.println(Flayable.MAX_SPEED);
System.out.println(Flayable.MIN_SPEED);
}
}
//2.在 Java 中: 接口和类是并列的两个结构
// 定义接口 '可以飞' 类
interface Flayable {
//3.JDK7 及以前:只能定义全局常量和抽象方法
//3.全局常量:public static final 的,但是书写中，可以省略不写。
// 定义成员变量属性
public static final int MAX_SPEED = 7900;
int MIN_SPEED = 1; // 默认是public static final修饰的，这里省略没写
// 成员属性默认都是public abstract final修饰的
// 成员方法，即是抽象方法，默认public abstract修饰的
void fly(); // 不加方法体，抽象方法 省略了 public abstract
//3.JDK7 及以前:只能定义全局常量和抽象方法
public abstract void stop();
//4.接口中不能定义构造器！意味着接口不可以实例化。
// 接口没有构造器，不像是抽象类，需要前提的是继承关系，重写方法，所以子类需要加载父类的结构，此时需要super()
// public Flayable(){//Interfaces cannot have constructors
// 接口不能实例化
// }
}
//攻击接口
interface Attackable{
//成员方法
void attack(); //省略了 public abstract
}
// 接口跟抽象类一样，是不可以直接进行实例化的，只能通过子类方式
// 飞机类 实现接口
//5.Java 开发中，接口通过让类去实现(implements)的方式来使用。
class Plane implements Flayable { // 实现接口类的所有抽象方法
/*
* (non-Javadoc)
*
* @see com.rucoding.day15.Flayable#fly()
*/
@Override
public void fly() {
// TODO Auto-generated method stub
System.out.println("飞机起飞了");
}
/*
* (non-Javadoc)
*
* @see com.rucoding.day15.Flayable#stop()
*/
@Override
public void stop() {
// TODO Auto-generated method stub
System.out.println("飞机降落了");
}
}
//风筝类 实现 接口 普通类实现接口，必须重写所有的抽象方法，加abstract修饰，则是抽象类，可不重写
abstract class Kite implements Flayable{
/* (non-Javadoc)
* @see com.rucoding.day15.Flayable#fly()
*/
@Override
public void fly() {
// TODO Auto-generated method stub
System.out.println("风筝放飞了");
}
}
//子弹类 多实现
//类的单继承，接口的多实现
//6.Java 类可以实现多个接口 ---》弥补了 Java 单继承性的局限性
class Bullet extends Object implements Flayable,Attackable,CC{ //
/* (non-Javadoc)
* @see com.rucoding.day15.Attackable#attack()
*/
@Override
public void attack() {
// TODO Auto-generated method stub
System.out.println("子弹具有攻击性");
}
/* (non-Javadoc)
* @see com.rucoding.day15.Flayable#fly()
*/
@Override
public void fly() {
// TODO Auto-generated method stub
System.out.println("子弹飞了");
}
/* (non-Javadoc)
* @see com.rucoding.day15.Flayable#stop()
*/
@Override
public void stop() {
// TODO Auto-generated method stub
System.out.println("子弹停了");
}
/* (non-Javadoc)
* @see com.rucoding.day15.AA#method1()
*/
@Override
public void method1() {
// TODO Auto-generated method stub
}
/* (non-Javadoc)
* @see com.rucoding.day15.BB#method2()
*/
@Override
public void method2() {
// TODO Auto-generated method stub
}
}
//类与类是单继承，类与接口是多实现
//那么，接口与接口的关系呢？？
interface AA{
void method1(); //省略了 public abstract 修饰
}
interface BB{
void method2();//
}
//7.接口与接口之间是继承,而且可以多继承
interface CC extends AA,BB{
}
小结
/*
* 接口的使用
* 1.接口使用 interface 来定义。
* 2.在 Java 中: 接口和类是并列的两个结构
* 3.如何去定义两个接口:定义接口中的成员
* 》3.1
* 》全局常量:public static final 的,但是书写中，可以省略不写。
* 》抽象方法:public abstract 的
*
* 》3.2 JDK8:除了全局常量和抽象方法之外，还可以定义静态方法、默认方法(略)。
*
* 4.接口中不能定义构造器！意味着接口不可以实例化。
*
* 5.Java 开发中，接口通过让类去实现(implements)的方式来使用。
* 如果实现类覆盖了接口中的所有方法，则此实现类就可以实例化
* 如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
*
* 6.Java 类可以实现多个接口 ---》弥补了 Java 单继承性的局限性
* 格式:class AA extends BB implementd CC,DD,EE
*
* 7.接口与接口之间是继承,而且可以多继承
*
**********************************
* 8.接口的具体使用，体现多态性
* 接口的主要用途就是被实现类实现。（面向接口编程）
* 9.接口，实际可以看作是一种规范
*
* 面试题:抽象类与接口有哪些异同？
*
*/
6.2、接口应用举例
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pyVDqhWO-1635522256746)(object_images3/image-20211029223455047.png)]](https://i-blog.csdnimg.cn/blog_migrate/b9fb773ab68e8b087d1997fbc20f5999.png)
代码演示：
package com.rucoding.day15;
/**
* @author LiuYiXin
*
*/
public class USBTest {
public static void main(String[] args) {
//5.创建具体的实现类对象
Udisk udisk = new Udisk();
Computer.transferData(udisk);
Printer printer = new Printer();
Computer.transferData(printer);
}
}
//4.电脑类
class Computer{
//连接电脑，传输数据
public static void transferData(USB usb){//USB usb = new Printer(); 多态性体现
usb.start();
System.out.println("中间是具体的传输数据操作细节");
usb.stop();
}
}
//1.定义USB接口
interface USB{
//USB接口，定义常量，public static final修饰的，比如特定大小的长宽高
//定义抽象方法
void start(); //省略了 public abstract
void stop();
}
//2.具体实现类，U盘
class Udisk implements USB{
/* (non-Javadoc)
* @see com.rucoding.day15.USB#start()
*/
@Override
public void start() {
// TODO Auto-generated method stub
System.out.println("U盘开始工作");
}
/* (non-Javadoc)
* @see com.rucoding.day15.USB#stop()
*/
@Override
public void stop() {
// TODO Auto-generated method stub
System.out.println("U盘结束工作");
}
}
//3.具体实现类 打印机
class Printer implements USB{
/* (non-Javadoc)
* @see com.rucoding.day15.USB#start()
*/
@Override
public void start() {
// TODO Auto-generated method stub
System.out.println("打印机开始工作");
}
/* (non-Javadoc)
* @see com.rucoding.day15.USB#stop()
*/
@Override
public void stop() {
// TODO Auto-generated method stub
System.out.println("打印机结束工作");
}
}
6.3、接口的应用：代理模式（Proxy）
代理模式是 Java 开发中使用较多的一种设计模式。代理设计就是为其他对象提供一种代理以控制
对这个对象的访问。
举个生活例子：假如我们要租房，此时需要咨询某平台，作为被代理的我们，需要通过代理者中介，
中介了解出租屋信息。
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9g93USir-1635522256747)(object_images3/image-20211029230600782.png)]](https://i-blog.csdnimg.cn/blog_migrate/22e9927f2eb4ef27bf3aaf91c7e37c40.png)
代码演示：
package com.rucoding.day15;
import sun.nio.ch.Net;
/**
* @author LiuYiXin
*
*/
public class NetWorkTest {
public static void main(String[] args) {
Server server = new Server();
Proxy proxy = new Proxy(server);
proxy.browse();
}
}
//定义网络接口
interface Network{
void browse();//没有方法体，抽象方法，省略了 public abstract
}
//被代理类
class Server implements Network{
/* (non-Javadoc)
* @see com.rucoding.day15.Network#browse()
*/
@Override
public void browse() {
// TODO Auto-generated method stub
System.out.println("真实服务器访问");
}
}
//代理类
class Proxy implements Network{
//代理类， 代理谁了
private Network network;
/**
* @param network
*/
public Proxy(Network network) {//实现类，体现多态思想
super();
this.network = network;
}
//代理者，结合实际场景，设计对应的功能
public void cheakConnection(){
System.out.println("检查联网之前的网络情况");
}
/* (non-Javadoc)
* @see com.rucoding.day15.Network#browse()
*/
@Override
public void browse() {
this.cheakConnection();
network.browse();
}
}
应用场景
1) 应用场景：
安全代理：屏蔽对真实角色的直接访问。
远程代理：通过代理类处理远程方法调用（RMI）
延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象
比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有100MB，在打开文件时，不可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用proxy来进行大图片的打开。
2) 分类：
静态代理（静态定义代理类）
动态代理（动态生成代理类）
JDK自带的动态代理，需要反射等知识
举一例
代码演示：
package com.rucoding.day15;
/**
* @author LiuYiXin
*
*/
public class StarStaticProxyTest {
public static void main(String[] args) {
ProxyClass proxyClass = new ProxyClass(new RealStar());
proxyClass.confer();
proxyClass.signContract();
proxyClass.bookTicket();
proxyClass.sing();
proxyClass.collectMoney();
}
}
//设计接口 Star抽取特征行为 —— 明星接口
interface Star{
void confer();// 面谈 抽象方法，省略了 public abstract
void signContract();// 签合同
void bookTicket();// 订票
void sing();// 唱歌
void collectMoney();// 收钱
}
//具体的真实明星类 ，被代理
class RealStar implements Star{
/* (non-Javadoc)
* @see com.rucoding.day15.Star#confer()
*/
@Override
public void confer() {
// TODO Auto-generated method stub
}
/* (non-Javadoc)
* @see com.rucoding.day15.Star#signContract()
*/
@Override
public void signContract() {
// TODO Auto-generated method stub
}
/* (non-Javadoc)
* @see com.rucoding.day15.Star#bookTicket()
*/
@Override
public void bookTicket() {
// TODO Auto-generated method stub
}
/* (non-Javadoc)
* @see com.rucoding.day15.Star#sing()
*/
@Override
public void sing() {
// TODO Auto-generated method stub
System.out.println("明星自己唱歌了...");
}
/* (non-Javadoc)
* @see com.rucoding.day15.Star#collectMoney()
*/
@Override
public void collectMoney() {
// TODO Auto-generated method stub
}
}
//设计类，代理者Proxy
class ProxyClass implements Star{
private RealStar realStar;
/**
* @param realStar
*/
public ProxyClass(RealStar realStar) {
super();
this.realStar = realStar;
}
/* (non-Javadoc)
* @see com.rucoding.day15.Star#confer()
*/
@Override
public void confer() {
// TODO Auto-generated method stub
System.out.println("经纪人面谈");
}
/* (non-Javadoc)
* @see com.rucoding.day15.Star#signContract()
*/
@Override
public void signContract() {
// TODO Auto-generated method stub
System.out.println("经纪人签约");
}
/* (non-Javadoc)
* @see com.rucoding.day15.Star#bookTicket()
*/
@Override
public void bookTicket() {
// TODO Auto-generated method stub
System.out.println("经纪人订票");
}
/* (non-Javadoc)
* @see com.rucoding.day15.Star#sing()
*/
@Override
public void sing() {
// TODO Auto-generated method stub
realStar.sing();
}
/* (non-Javadoc)
* @see com.rucoding.day15.Star#collectMoney()
*/
@Override
public void collectMoney() {
// TODO Auto-generated method stub
System.out.println("经纪人财务打理");
}
}
6.4、接口的应用：工厂模式
6.5、抽象类与接口的对比
| 序号 | 区别点 | 抽象类 | 接口 |
|---|---|---|---|
| 1 | 定义 | 包含抽象方法的类 | 主要是全局常量和抽象方法的集合 |
| 2 | 组成 | 变量、常量、构造方法、普通方法、抽象方法 | 常量、抽象方法（jdk8 静态方法、默认方法） |
| 3 | 使用 | 子类继承抽象类（extends） | 子类实现接口（implements） |
| 4 | 关系 | 抽象类可以实现多个接口 | 接口不能继承抽象类，但允许继承多个接口 |
| 5 | 常见设计模式 | 模板方法 | 简单工厂、工厂模式、代理模式 |
| 6 | 对象 | 都通过对象的多态性产生实例化对象 | 都通过对象的多态性产生实例化对象 |
| 7 | 局限 | 抽象类有单继承的局限 | 接口没有此局限 |
| 8 | 实际标准 | 作为一个模板 | 是作为一个标准或是表示一种能力 |
| 9 | 选择 | 如果抽象类和接口都可以使用的话，优先使用接口，因为避免单继承的局限 | 如果抽象类和接口都可以使用的话，优先使用接口，因为避免单继承的局限 |
6.6、面试题&&练习
排错题1：
package com.rucoding.day15;
/**
* @author LiuYiXin
*
*/
interface A {
int x = 0; //省略了 public static final修饰
}
class B {
int x = 1;
}
class C extends B implements A { //继承类B实现接口A
public void pX() {
// 编译不通过，x 不明确
// System.out.println(x); //The field x is ambiguous[模糊两可的，含糊不清的]此时x并不明确
System.out.println(super.x); //1 super表示当前实例的父类
System.out.println(A.x);//0 接口的属性是用 public static final修饰的 ，直接通过 ‘类.属性’调用
}
public static void main(String[] args) {
new C().pX();
}
}
排错题2：
package com.rucoding.day15;
/**
* @author LiuYiXin
*
*/
interface Playable {
void play();
}
interface Bounceable {
void play();
}
interface Rollable extends Playable, Bounceable {
Ball ball = new Ball("PingPang"); // 接口内定义的是常量，省略了 public static final 修饰
}
public class Ball implements Rollable {
private String name;
public String getName() {
return name;
}
public Ball(String name) {
this.name = name;
}
public void play() {
ball = new Ball("Football"); // The final field Rollable.ball cannot be assigned
System.out.println(ball.getName());
}
}
练习1：
代码演示：
接口类CompareObject：
package com.rucoding.day15_1;
/**
* @author LiuYiXin
*
*/
public interface CompareObject {
/**
*
* @param o
* @return
* 若返回值是 0,代表相等;若为正数，代表当前对象大；负数代表当前对象小
*/
public int compareTo(Object o);
/**
*
* @return
* 比较两个矩形的面积大小
* 若返回值是 0,代表相等;若为正数，代表当前对象大；负数代表当前对象小
*/
public Double findArea();
}
Circle类：
package com.rucoding.day15_1;
/**
* @author LiuYiXin
*
*/
public class Circle {
//定义属性，半径属性后续会进行比较，这里定义为包装类
private Double radius;
/**
* @return the radius
*/
public Double getRadius() {
return radius;
}
/**
* @param radius the radius to set
*/
public void setRadius(Double radius) {
this.radius = radius;
}
/**
*
*/
public Circle() {
super();
}
/**
* @param radius
*/
public Circle(Double radius) {
super();
this.radius = radius;
}
}
ComparableCircle类：
package com.rucoding.day15_1;
/**
* @author LiuYiXin
*
*/
/*
* 定义一个 ComparableCircle 类，继承 Circle 类并且实现 CompareObject 接口。在 ComparableCircle 类中给出接口中方法 compareTo 的实现体，
* 用来比较两个圆的半径大小。
*/
public class ComparableCircle extends Circle implements CompareObject{
/**
* @param radius
*/
public ComparableCircle(Double radius) {
super(radius);
}
/* (non-Javadoc)
* @see com.rucoding.day15_1.CompareObject#compareTo(java.lang.Object)
*/
@Override
public int compareTo(Object o) {
if(this == o){
return 0;
}
if(o instanceof ComparableCircle){
//向下类型转换
ComparableCircle c = (ComparableCircle)o;
//方式一
// if(this.getRadius() > c.getRadius()){
// return 1;
// }else if(this.getRadius() < c.getRadius()){
// return -1;
// }else{
// return 0;
// }
//方式二 当属性为包装类时，可以调用包装类的比较方法
return this.getRadius().compareTo(c.getRadius());
}else{
// return 0;
throw new RuntimeException("传入数据类型不匹配");//异常的知识，后面学习
}
}
/* (non-Javadoc)
* @see com.rucoding.day15_1.CompareObject#findArea()
*/
@Override
public Double findArea() {
// 计算面积的
return null;
}
}
Rectangle类：
package com.rucoding.day15_1;
/**
* @author LiuYiXin
*
*/
public class Rectangle {
//矩形，定义属性
private Double length; //长
private Double width; //宽
/**
*
*/
public Rectangle() {
super();
}
/**
* @param length
* @param width
*/
public Rectangle(Double length, Double width) {
super();
this.length = length;
this.width = width;
}
/**
* @return the length
*/
public Double getLength() {
return length;
}
/**
* @param length the length to set
*/
public void setLength(Double length) {
this.length = length;
}
/**
* @return the width
*/
public Double getWidth() {
return width;
}
/**
* @param width the width to set
*/
public void setWidth(Double width) {
this.width = width;
}
//
}
ComparableRectangle类：
package com.rucoding.day15_1;
/**
* @author LiuYiXin
*
*/
public class ComparableRectangle extends Rectangle implements CompareObject{
/**
* @param length
* @param width
*/
public ComparableRectangle(Double length, Double width) {
super(length, width);
// TODO Auto-generated constructor stub
}
/* (non-Javadoc)
* @see com.rucoding.day15_1.CompareObject#compareTo(java.lang.Object)
*/
@Override
public int compareTo(Object o) {
//比较长宽的属性值是否相等
if(this == o){
return 0;
}
if(o instanceof ComparableRectangle){
ComparableRectangle c = (ComparableRectangle)o;
return this.findArea().compareTo(c.findArea());
}else{
// return 0;
throw new RuntimeException("传入的数据类型不匹配"); //异常的知识，后面学习
}
}
/* (non-Javadoc)
* @see com.rucoding.day15_1.CompareObject#findArea()
*/
@Override
public Double findArea() {
// TODO Auto-generated method stub
return this.getLength() * this.getWidth();
}
}
测试类InterfaceTest：
package com.rucoding.day15_1;
/**
* @author LiuYiXin
*
*/
public class InterfaceTest {
public static void main(String[] args) {
//比较两个圆的半径大小
ComparableCircle c1 = new ComparableCircle(3.4);
ComparableCircle c2 = new ComparableCircle(3.6);
int compareValue = c1.compareTo(c2);
if(compareValue > 0){
System.out.println("c1对象的半径大");
}else if(compareValue < 0){
System.out.println("c2对象的半径大");
}else{
System.out.println("半径一样大");
}
//比较两个矩形的面积大小
System.out.println("=========================");
ComparableRectangle r1 = new ComparableRectangle(12.4, 6.4);
ComparableRectangle r2 = new ComparableRectangle(12.4, 6.41);
int compareResult = r1.compareTo(r2);
if(compareResult > 0){
System.out.println("r1的面积大");
}else if(compareResult < 0){
System.out.println("r2的面积大");
}else{
System.out.println("面积一样大");
}
}
}
7、Java 8 中关于接口的改进
Java 8 中，你可以为接口添加 静态方法和默认方法。
从技术角度来说，这是完全合法的，只是它看起来违反了接口作为一个抽象定义的理念。
1)、静态方法：
使用 static 关键字修饰。可以通过接口直接调用静态方法，并执行其方法体。 我们经常在
相互一起使用的类中使用静态方法。你可以 在标准库中找到像 Collection/Collections 或者
Path/Paths 这样成对的接口和类。
2)、默认方法：
默认方法使用 default 关键字修饰。可以通过实现类对象来调用。我们在已有的接口中提供
新方法的同时，还保持了与旧版本代码的兼 容性。比如：java 8 API 中对 Collection、List、
Comparator 等接口提供了丰富的默认方法。
代码演示：
package com.rucoding.day15_8;
/**
* @author LiuYiXin
*
*/
public class SubClassTest {
public static void main(String[] args) {
SubClass s = new SubClass();
s.method3();
// 知识点1:接口定义的静态方法，只能通过'接口.静态方法'来调用
CompareA.method1();
// 知识点2:通过实现类的对象，可以调用接口中的默认方法。
// 如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
s.method2(); // 重写后的方法
/**
* 知识点 3：如果子类(或实现类)继承的父类和实现的接口中声明了
* 同名同参数的默认方法，那么子类在没有重写此方法的情况下，
* ，默认调用的是父类中的同名同参数的方法。-->类优先原则
*
*/
s.method3();
/**
* 知识点 4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，
* 那么在实现类没有重写此方法的情况下，报错。-->接口冲突。
* 这就需要我们必须在实现类中重写此方法
*/
}
}
class SuperClass {
public void method3() {
System.out.println("SuperClass:北京");
}
}
class SubClass extends SuperClass implements CompareA, CompareB {
// public void method2() {
// System.out.println("SubClass：method2");
// }
public void method3() {
System.out.println("SubClass：method3");
}
//知识点 5：如何在子类(或实现类)的方法中调用父类、接口中被重写的方法
public void myMethod(){
method3();//调用自己的
super.method3(); //调用父类
//调用接口静态方法、默认方法
CompareA.method1(); //静态方法
CompareA.super.method2(); //默认方法
CompareB.super.method3(); //默认方法
}
}
interface CompareA {
/*
* JDK8:除了全局常量和抽象方法之外，还可以定义静态方法、默认方法(略)。
*
*
*/
// 静态方法
public static void method1() {
System.out.println("CompareA:静态方法");
}
// 默认方法
public default void method2() {
System.out.println("CompareA:默认方法public default");
}
default void method3() {
System.out.println("CompareA:默认方法default");
}
}
interface CompareB {
// default void method2() {
// System.out.println("CompareB：默认方法default");
// }
default void method3() {
System.out.println("CompareB：默认方法default");
}
}
小结
知识点 1：接口中定义的静态方法，只能通过接口来调用。
知识点 2：通过实现类的对象，可以调用接口中的默认方法。如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法。
知识点 3：如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，那么子类在没有重写此方法的情况下，默认调用的是 父类中的同名同参数的方法。-->类优先原则。
知识点 4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况下，报错。
-->接口冲突。这就需要我们必须在实现类中重写此方法
知识点 5：如何在子类(或实现类)的方法中调用父类、接口中被重写的方法。
method3();//调用自己的
super.method3(); //调用父类
//调用接口静态方法、默认方法
CompareA.method1(); //静态方法
CompareA.super.method2(); //默认方法 super之前表示当前对象实例的父类
CompareB.super.method3(); //默认方法
接口冲突示例：
package com.rucoding.day15_8;
/**
* @author LiuYiXin
*
*/
/*
* 练习：接口冲突的解决方式
*/
interface Filial {// 孝顺的
default void help() {
System.out.println("老妈，我来救你了");
}
}
interface Spoony {// 痴情的
default void help() {
System.out.println("媳妇，别怕，我来了");
}
}
class Father{
public void help(){
System.out.println("儿子，救我媳妇！");
}
}
class Man extends Father implements Filial, Spoony {
public static void main(String[] args) {
Man m = new Man();
m.help();
}
@Override
public void help() {
System.out.println("我该救谁呢？");
//选择其中一个，这时区分调用方式
//接口的默认方法调用方式，通过 接口类.super.方法名
Filial.super.help();
Spoony.super.help();
}
}
8、类的内部成员之五：内部类
当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。（举个例子，定义Person人类，人具有大脑brain,大脑体现可为人具有的内部类）
☆☆☆关注如下的3个问题
》 如何实例化成员内部类的对象
》 如何在成员内部类中区分调用外部类的结构
》 开发中局部内部类的使用 见《InnerClassTest1.java》
代码演示：
package com.rucoding.day15_1;
import com.rucoding.day15_1.Person.Brain;
import com.rucoding.day15_1.Person.Cerebellum;
/**
* @author LiuYiXin
*
*/
/*
* 类的内部成员之五:内部类
*
* 1.Java中允许将一个类A声明在另一个类B中,则类A就是内部类,类B就是外部类.
*
* 2.内部类的分类:成员内部类 VS 局部内部类(方法内、代码块内、构造器内)
*
* 3.成员内部类 》作为外部类的成员, - 调用外部类的结构 - 可以被static修饰 - 可以被4种不同的权限修饰
*
* 》作为一个类， - 类内可以定义属性、方法、构造器等 - 可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承 -
* 可以abstract修饰
*
* 4.关注如下的3个问题 》 如何实例化成员内部类的对象 》 如何在成员内部类中区分调用外部类的结构 》 开发中局部内部类的使用
* 见《InnerClassTest1.java》
*/
public class InnerClassTest {
public static void main(String[] args) {
// 创建静态成员内部类的对象实例
Person.Brain brain = new Person.Brain();
brain.show();
// 创建非静态成员内部类的对象实例
Person p = new Person();
Person.Cerebellum c = p.new Cerebellum();
c.show();
c.displayName("brainstem脑干");
}
}
class Person {
String name = "李华";
int age;
public void eat() {
System.out.println("人，吃饭");
}
// 成员内部类的
// 静态内部类
static class Brain { // 可以被static修饰 可以被4种不同的权限修饰
String name = "大脑"; // 大脑
public void show() {
System.out.println("show BrainInfo");
}
}
// 非静态内部类
class Cerebellum {// 小脑
String name = "小脑";
public void show() {
System.out.println("show CerebellumInfo");
// 调用外部类的非静态属性
Person.this.eat(); // 调用外部类的结构
eat();
System.out.println(age);
}
public void displayName(String name) {
System.out.println(name); // 方法的形参
System.out.println(this.name); // 当前对象内部类的属性
System.out.println(Person.this.name);// 外部类Person的属性
}
}
// Person类的成员方法
public void method() { // 方法内的局部内部类
// 局部内部类
class AA {
}
}
// 代码块的局部内部类
{
class BB {
}
}
// 构造器中的局部内部类
public Person() {
class CC {
}
}
}
局部内部类的使用：
package com.rucoding.day15_1;
/**
* @author LiuYiXin
*
*/
public class InnerClassTest1 {
// 开发中很少见
public void method() {
// 局部内部类
class AA {
}
}
// 返回一个实现了Comparable接口的类的对象
// 方式一
public Comparable getComparable() {
// class MyComparable implements Comparable {
// /*
// * (non-Javadoc)
// *
// * @see java.lang.Comparable#compareTo(java.lang.Object)
// */
// @Override
// public int compareTo(Object o) {
// // TODO Auto-generated method stub
// return 0;
// }
// }
// return new MyComparable();
//方式二
return new Comparable(){
@Override
public int compareTo(Object o) {
// TODO Auto-generated method stub
return 0;
}
};
}
}
8.1、匿名内部类
* 匿名内部类
*
* 1.匿名内部类不能定义 "任何静态成员、方法和类" ，只能创建匿名内部类的一个实例。
* 一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
*
* 2.格式：
* new 父类构造器（实参列表）|实现接口(){
* //匿名内部类的类体部分
* }
*
* 3.匿名内部类的特点
* > 匿名内部类必须继承父类或实现接口
* > 匿名内部类只能有一个对象
* > 匿名内部类对象只能使用多态形式引用
*/
代码演示：
package com.rucoding.day15_1;
/**
* @author LiuYiXin
* 匿名内部类
*
* 1.匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。
* 一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
*
* 2.格式：
* new 父类构造器（实参列表）|实现接口(){
* //匿名内部类的类体部分
* }
*
* 3.匿名内部类的特点
* > 匿名内部类必须继承父类或实现接口
* > 匿名内部类只能有一个对象
* > 匿名内部类对象只能使用多态形式引用
*/
public class AnonymousInnerClassTest {
public static void main(String[] args) {
AnonymousInnerClassTest a = new AnonymousInnerClassTest();
//调用printInfo 方法，传入一个参数Product
//这里传入的是匿名实现一个接口（隐含）
a.printInfo(new Product() {
@Override
public double getPrice() {
// TODO Auto-generated method stub
return 5299.00;
}
@Override
public String getName() {
// TODO Auto-generated method stub
return "联想小新Pro14";
}
});
}
// 打印信息
public void printInfo(Product p) {
System.out.println("双十一购买的电子产品：" + p.getName() + " 支付了" + p.getPrice());
}
}
//
interface Product {
// 接口内定义的方法
public double getPrice();
public String getName();
}
8.2、局部内部类的使用注意
/*
* 在局部内部类的方法中(比如:show)如果调用外部类AnonymousInnerClassTest2
* 声明的成员方法(比如：method)中的局部变量(比如： num)的话,要求此局部变量声明为final的。
*
* jdk 7及之前版本：要求此局部变量显式的声明为final的。
* jdk 8及之后的版本：可以省略final的声明
*
*/
代码演示：
package com.rucoding.day15_1;
/**
* @author LiuYiXin
*
*/
public class AnonymousInnerClassTest2 {
public static void main(String[] args) {
AnonymousInnerClassTest2 a = new AnonymousInnerClassTest2();
a.method();
}
public void method() {
// 局部变量
int num = 10;
class AA {
public void show() {
// 在局部内部类AA的方法中(比如:show)
// 如果调用外部类所声明的方法(比如：method)中
// 的局部变量(比如：num)的话,要求此局部变量声明为final的。
/**
* jdk 7及之前版本：要求此局部变量显式的声明为final的
* jdk 8及之后的版本：可以省略final的声明
*/
// num = 20;
System.out.println(num);
}
}
//
new AA().show();
}
}
Rucoding Today！
面向对象编程结束啦，下一遍文章，就是关于整个面向对象的内容整理，形成思维导图哦~~~
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
