Day10【接口、多态】

最新推荐文章于 2024-06-09 18:24:15 发布

野返

最新推荐文章于 2024-06-09 18:24:15 发布

阅读量176

点赞数

分类专栏：自学java 文章标签：接口多态 java 自学

本文链接：https://blog.csdn.net/Don_11/article/details/103191256

版权

自学java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

#今日内容

接口
多态

##01. 接口概述与生活举例

结合例子, 接口是什么思想?

总结: 接口就是一种公共的规范标准

		接口是对外暴露的一种规则


	定义接口的人:
		
		声明规则的

	使用接口的人:

		根据规则完成功能的人

##02. 接口的定义基本格式

接口的基本定义格式

格式: interface 接口名{}

接口有会产生字节码文件吗?

总结: 会的

接口中可以定义的内容有?

接口在jdk1.7的特点:

	只能定义常量
	抽象方法

接口在jdk1.8的特点:

	默认方法
	静态方法

接口在jdk1.9的特点:

	私有方法



	总结:

		1. 常量		--> 自定义常量	-> final
		2. 抽象方法	-> 必掌握


		3. 默认方法	-> 了解
		4. 静态方法	-> 了解
		5. 私有方法  -> 了解

##03. 接口的抽象方法定义

接口中定义抽象方法的特点:

总结:
		定义的方法即使写成 void show();   系统也会默认加上2个关键字 public abstract


细节:
		abstract关键字不能和哪些关键字共存

		1. private
				-> 因为被abstract修饰的方法强制要求子类重写, 而被private修饰的方法子类重写不了, 二者冲突	
		2. static
				-> 如果允许被static修饰, 就可以通过类名点去调用没有方法体的抽象方法, 这样做没有意义.
		3. final
				-> 变量 方法  类

					变量 : 就变成了常量, 只能被赋值一次

					方法 : 不能被重写

					类 : 不能被继承


				-> 因为被abstract修饰的方法强制要求子类重写, 而被final修饰的方法, 子类不能重写, 二者冲突.

##04. 接口的抽象方法使用

思路: 接口不能实例化, 必须由实现类(子类的一种)去实现接口

实现接口的格式为:

总结:
		
	class 实现类类名 implements 接口名{

    }

建议:

	作为接口的实现类(子类), 要么重写所有的抽象方法	--> 推荐方案

	要么将自己也变成一个抽象类		-> 不推荐


步骤:
	1. 定义接口   interface 接口名 {   ....      }
	2. 找一个实现类实现这个接口-> implements           class  实现类名 implements 接口名 {  ...  }
	3. 创建实现类对象, 并调用方法


思路:

	抽象类 -> 共性的内容

	接口 -> 扩展的规则

##05. 接口的默认方法定义

jdk8开始, 才可以定义默认方法

定义默认方法的时候, 需要加入关键字default

格式:	

	public default 返回值类型 方法名(){

	}

加入默认方法, 可以解决什么样的问题?

结论: 可以解决接口的升级问题


interface A {
    public abstract void methodA();


	// 这里如果是一个抽象方法的话, 会影响到很多的实现类.
    public default void show(){
        System.out.println("我是新增加的功能show");
    }

}

class AImp1 implements A {
    @Override
    public void methodA() {
        System.out.println("AImp1....");
    }
}

class AImp2 implements A{
    @Override
    public void methodA() {
        System.out.println("AImp2....");
    }
}

##06. 接口的默认方法使用

调用方式是?
实现类是否可以对默认方法进行重写?

总结:

	1. 可以直接创建 实现类 的对象进行调用

	2. 可以

		如果实现类重写了, 那么调用的时候, 使用的就是重写之后的逻辑

		如果没有重写, 使用的就是接口当中默认的逻辑

eg.

		public interface Animal {
            public default void method (){
                System.out.println("默认方法");
            }
		}

public Dog implements Animal {
@Override
public void method (){ //注意重写默认方法的时候, 不能写"default"关键字.按照普通的成员方法写就行了.
System.out.println(“重写的默认方法”);
}
}

	概念: 接口是一个干爹, 干爹中的数据, 实现类也是可以继承使用的.

##07. 接口的静态方法定义

jdk1.8开始, 可以开始定义静态方法
格式为?

总结: 

	public static 返回值类型 方法名(参数列表){
		方法体;
	}

##08. 接口的静态方法使用

调用方式是?

总结:
	1. 接口名称.静态方法名称();
	
	[ 注意事项 ]静态方法无法通过实现类名或者是实现类对象进行调用.只能通过接口名.静态方法名进行调用.


	interface Inter{
		public static void method(){
			System.out.println("1");
		}
	}

	interface Inter2{
		public static void method(){
			System.out.println("2");
		}
	}

class InterImp implements Inter,Inter2{

	}


	InterImp ii = new InterImp();
	ii.method();			// 错误写法

main(){
Inter.method(); // 接口名称.静态方法名称();
}

问题: 为什么接口中的静态方法, 不允许对象名调用.

		特点: 接口和类之间是实现关系, 可以单实现, 也可以多实现


			 	既然可以多实现, 就有可能, 多个接口中定义了相同的静态方法, 但是方法体不一样.

				这时候就会出现冲突问题.


		所以, 接口中的静态方法. 只允许接口名.进行调用, 不允许对象名调用!

##09. 接口的私有方法定义

jdk1.9开始, 接口可以定义私有方法
什么情况下需要将接口中的方法进行私有?

总结:
	如果一个接口中有多个默认方法，并且方法中有重复的内容，那么可以抽取出来，封装到私有方法中，供默认方法 去调用。从设计的角度讲，私有的方法是对默认方法和静态方法的辅助
	换句话说: 
	当发现接口中的多个默认方法中, 出现了重复的代码, 我们可以将这段代码抽取到一个方法当中.
		但又不希望实现类将整个逻辑性不强的方法继承使用, 就可以将该方法进行私有.


举例:

	public interface MyInterfacePrivateA {

	    public default void methodDefault1() {
	        System.out.println("默认方法1");
	        methodCommon();
	    }
	
	    public default void methodDefault2() {
	        System.out.println("默认方法2");
	        methodCommon();
	    }
	
	    private void methodCommon() {
	        System.out.println("AAA");
	        System.out.println("BBB");
	        System.out.println("CCC");
	    }
	
	}

##10. 接口的私有方法使用

代码分析

结论 : 接口中定义的私有方法, 就是解决(普通/静态)方法中, 重复代码的问题.

##11. 接口的常量定义和使用

接口中的变量只能是常量

总结: 因为默认加入了三个关键字 : public static final

	int num = 10;

fianl修饰变量

>* 基本数据类型

		其值不能发生改变

		final int a = 10;
		a = 20;	// 错误.

>* 引用数据类型

		地址值不能发生改变, 但是可以通过setXxx方法修改属性值.

		final Person p = new Person("张三",23);
		p.setAge(24);	// 正确
		p = new Person("李四",24);	// 错误

注意事项:

1. 接口中的常量, 必须给出初始化值.

	-> final修饰的变量, 如果是成员变量的话, 初始化时机.

解释:

			因为final修饰成员变量的初始化时机一共分为两种
				 1. 在创建成员变量的之后, 就直接赋值 --> 推荐方案
				 2. 在构造方法弹栈之前完成赋值

			注意的是, 接口中没有构造方法, 所以能够选择的初始化时机, 就只能是在创建成员变量的时候, 直接赋值.

江湖规矩

定义标识符的时候, 需要见名知意, 驼峰命名

	1. 变量 : 如果是一个单词, 所有字母小写			: age
				如果是多个单词, 从第二个单词的首字母开始大写 : maxAge

	2. 常量 : 如果是一个单词, 所有字母大写			: VALUE
				如果是多个单词, 所有字母大写, 但是单词之间需要以下划线隔开	: MAX_VALUE

	3. 类名 : 如果是一个单词, 首字母大写		Demo
				如果是多个单词, 每个单词的首字母大写	TestFinal

	4. 方法名: 如果是一个单词, 所有字母小写		: method()
				如果是多个单词, 从第二个单词的首字母开始大写 : getAge();


	5. 包名 : 一般都是公司的域名倒着写

					itheima.com

						com.itheima.xx

##12. 接口的内容小结

在Java 9+版本中，接口的内容可以有：

成员变量其实是常量，格式：

[public] [static] [final] 数据类型 常量名称 = 数据值;
注意：
	常量必须进行赋值，而且一旦赋值不能改变。
	常量名称完全大写，用下划线进行分隔。

接口中最重要的就是抽象方法，格式：

[public] [abstract] 返回值类型 方法名称(参数列表);
注意：实现类必须覆盖重写接口所有的抽象方法，除非实现类是抽象类。

从Java 8开始，接口里允许定义默认方法，格式：

[public] default 返回值类型 方法名称(参数列表) { 方法体 }
注意：默认方法也可以被覆盖重写

从Java 8开始，接口里允许定义静态方法，格式：

[public] static 返回值类型 方法名称(参数列表) { 方法体 }
注意：静态方法不能通过实现类的类名或者实现类的对象进行调用, 只能通过接口名.静态方法名进行调用.

从Java 9开始，接口里允许定义私有方法，格式：

普通私有方法：private 返回值类型 方法名称(参数列表) { 方法体 }
静态私有方法：private static 返回值类型 方法名称(参数列表) { 方法体 }

接口的思想(重要)

总结:

	对比抽象类的思想

		抽象类: 被继承体现的是一种is..a的关系, 抽象类中的行为都是共性的行为.

		接口 : 接口当中定义的都是一些扩展的规则(特性的行为), 体现的是一种like..a的关系.

##13. 继承父类并实现多个接口

注意事项:

总结:
	1.子接口重写默认方法时，default关键字可以保留。
	  子类重写默认方法时，default关键字不可以保留。 子父类中不能出现default关键字, 出现就是错误代码.
	
	2.接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static ﬁnal修饰。 
	3.接口中，没有构造方法，不能创建对象。 
	4.接口中，没有静态代码块。

接口的出现, 打破了java只支持单继承的局限性, 为什么?

总结:  因为接口和类之间是实现关系, 可以单实现,也可以多实现
			并且可以在继承了一个类的同时, 实现多个接口


		interface A{

		}
		
		interface B{

		}

		interface C{


		}


		class InterImp extends Object implements A,B,C{

}

接口的子类需要注意哪些?

总结:

	1. 实现一个接口, 要么重写所有的抽象方法, 要么该实现类自己本身也是一个抽象类.

	2. 如果实现类实现多个接口, 多个接口中存在重复的抽象方法, 实现类之重写一个即可 

	3. 如果实现类所实现的多个接口中, 存在重复的默认方法,  必须对冲突的默认方法重写
		
		interface A{
			public default void method(){
				System.out.println("A");
			}
		}

		interface B{
			public default void method(){
				System.out.println(B);
			}
		}

		class InterImp implements A, B{
			@Override
			public void method(){
				System.out.println("...");
			}
		}


	4. 如果实现类, 从父类中继承下来的方法, 和接口中默认的方法重名了.

			优先用父类的方法.

public class Test1_Extends {
public static void main(String[] args) {
Dog d = new Dog();
d.eat();
d.show();
}
}

			class Animal{
			    public void eat(){
			        System.out.println("动物吃饭");
			    }
			
			    public void show(){
			        System.out.println("父类的show方法");
			    }
			}


			interface Inter{
			    void eat();
			
			    public default void show(){
			        System.out.println("接口中的show方法");
			    }
			
			}
			
			class Dog extends Animal implements Inter{
			    // 虽然和接口的抽象eat冲突, 这里使用的是父类的eat方法
			    public void eat(){
			        System.out.println("动物吃饭");
			    }
			    // 父类的show方法和接口中默认的show方法冲突, 优先使用的是父类的show方法
			    // d.show();
			}

##14. 接口之间的多继承

类与类的关系:
* 继承关系, 只支持单继承, 不支持多继承, 但是可以多层继承
类与接口的关系:
* 实现关系, 可以单实现, 也可以多实现, 并且可以在继承了一个类的同时, 实现多个接口

接口与接口的关系:
* 继承, 可以单继承, 也可以多继承!

	interface A{
		void showA();
	}

	interface B{
		void showB();
	}

	interface C extends A,B{
		void showC();
	}


	class InterImp implements C{
		//重写三个抽象方法, 因为C当中继承到了showA, showB();
	}


* 单独注意:

	如果多个父接口当中, 出现了重复的默认方法, 那么子接口必须对方法进行覆盖重写, 而且不能省略default关键字 !!


	interface A{
		public defalut void show(){
			System.out.println("a");
		}
	}

	interface B{
		public defalut void show(){
			System.out.println("B");
		}
	}

	interface C extends A,B{
		@Override
		public defalut void show(){		// defalut不能省略.
			System.out.println("C");
		}
	}

##15. 多态的概述

什么是多态?

总结: 事物存在的多种形态


class Animal{

}

class Dog extends Animal{

}

main(){
	
	Dog d = new Dog();		// 事物以狗的形态出现

	Animal a = new Dog();	// 事物以动物的形态出现

}

##16. 多态的格式与使用

多态的前提是?

总结:

	1. 要有继承关系, 实现关系

	2. 要有父类引用指向子类对象.		--> 多态的写法

##17. 多态中成员变量的使用特点

多态中成员变量的使用特点?

总结:
	1. 编译看左边(父类), 运行看左边(父类)

		Fu f = new Zi();

		System.out.println(f.num);		// 父类当中num所记录的值


细节:

	编译看左边(父类), 运行看左边(父类)

		因为当前是父类引用指向子类对象, 父类的引用带有局限性, 只能看到堆内存当中super的一小块区域
		所以可以拿到的只能是super区域当中, 父类记录的数值.



问题: 静态成员变量呢?

		静态修饰的成员跟类相关, 跟对象没有关系.

		 Animal a = new Dog();
	     System.out.println(a.abc);       

		此处虽然是对象名.abc, 但在编译的时候也会翻译成类名.abc

		Animal.abc	--> 调用静态成员, 类名是谁的, 调用的就是谁的数值.

##18. 多态中成员方法的使用特点

多态中成员方法的访问提点?

总结:
	1. 编译看左边(父类), 运行看右边(子类)

动态绑定机制:


	动态绑定:

          在多态创建对象并调用成员方法的时候, 编译时会检测父类当中是否有此方法的声明

                有 : 编译通过, 但是运行的时候执行子类的方法

                没有 : 编译失败.
	.

##19. 使用多态的好处

无论右边new的是那个子类对象, 左边都不会发生变化

总结:

	1.
		Animal a = new Dog();

		Animal a = new Cat();

		...


结论:

	多态的出现, 提高了代码的复用性, 因为有继承保证

	提高了代码的扩展性	--> 必掌握


		问题: 怎么就提高了?

				可以将方法的形参定义为父类类型, 该方法就可以接受这个父类的任意子类对象了.


		注意: 将方法形参定义为父类类型之后, 该方法可以接受这个父类的任意子类对象, 在方法内部一般都是调用的共性内容

				如果想要调用特性内容, 就需要向下转型, 莫不如直接创建子类对象.

##20. 对象的向上转型

什么是多态的向上转型?

总结:

	1.	Animal a = new Dog();		// 父类引用指向子类对象


对比:

	double d = 10;

##21. 对象的向下转型

为什么要向下转型?

总结:
	多态的弊端: 不能调用子类特有的属性和行为.
	
	如果非要调用子类特有的功能, 就必须向下转型.


	向下转型的举例:
			超人的例子.

注意: 向下转型的强转必须发生在子父类的关系内, 而且必须是转上去, 才能转下来.

			什么情况下需要用到向下转型?
				答:  为了调用子类特有的属性和行为.

			ClassCastException(类型转换异常): 引用数据类型的强转, 出现了错误.

				例如:  

					1. Animal a = new Cat();
					   Dog d = (Dog)a;			--> Cat和Dog之间没有子父类关系, 不能强转

					2. Animal a = new Animal();
    					Dog d = (Dog) a;		--> 必须要先进行向上转型, 才可以将数据正常的转型下来.

##22. 用instanceof关键字进行类型判断

instanceof关键字的作用是什么?

总结:
	1. 判断左边的引用, 是否是右边的数据类型.

public static void useAnimal(Animal a){ // Animal a = new Cat();
a.eat();

	       if(a instanceof Dog){
	           Dog d = (Dog) a;
	           d.lookHome();
	       }else if (a instanceof Cat){
	           Cat c = (Cat) a;
	           c.catchMouse();
	       }
	    }


多态的好处:

	多态可以提高代码的扩展性, 可以将方法的形参定义为父类类型, 该方法就能接收这个父类的任意子类对象.

		方法内部一般只调用该体系当中共性的内容, 如果要调用特性的, 干脆就创建子类对象.

##23. 笔记本USB接口案例_分析

看图说话

##24. 笔记本USB接口案例_实现

示例代码

总结:

	1.

野返

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Day10【接口、多态】

#今日内容接口多态##01. 接口概述与生活举例结合例子, 接口是什么思想?总结: 接口就是一种公共的规范标准接口是对外暴露的一种规则定义接口的人: 声明规则的使用接口的人: 根据规则完成功能的人##02. 接口的定义基本格式接口的基本定义格式格式: interface 接口名{}接口有会产生字节码文件吗?...
复制链接

扫一扫