1. 接口
1.1接口
1.1.1 概念理解
接口是一种约定规范,是多个抽象方法的集合。仅仅只是定义了应该有哪些功能,本身不实现功能,至于每个功能具体怎么实现,就交给实现类完成。
接口中的方法是抽象方法,并不提供功能实现,体现了规范和实现相分离的思想,也体现了组件之间 低耦合的思想。
所谓耦合度,表示组件之间的依赖关系。依赖关系越多,耦合性越强,同时表明组件的独立性越差, 在开发中往往提倡降低耦合性,可提高其组件独立性,举一个低耦合的例子。
电脑的显卡分为集成显卡和独立显卡:
n 集成显卡:显卡和主板焊死在一起,显卡坏了,只能换主板
n 独立显卡:显卡和主板相分离,显卡插到主板上即可,显卡坏了,只换显卡,不用换主板
接口也体现的是这种低耦合思想,接口仅仅提供方法的定义,却不提供方法的代码实现。那么得专门
提供类并去实现接口,再覆盖接口中的方法,最后实现方法的功能,在多态案例中再说明。
1.1.2 接口申明&多继承性
接口可以认为是一种特殊的类,但是定义类的时候使用 class 关键字,定义接口使用 interface 关键字。
public interface 接口名{ 抽象方法 1(); 抽象方法 2(); 抽象方法 2(); } |
接口表示具有某些功能的事物,接口名使用名词,有人也习惯以 I 打头如 IWalkable.java。
接口定义代码:
public interface IWalkable {
void walk();
}
接口中的方法都是公共的抽象方法,等价于:
public interface IWalkable {
public abstract void walk();
}
类可以继承类,但是只能单继承的,接口也可以继承接口,但是却可以继承多个接口,也就是说一个
接口可以同时继承多个接口,如两栖动物可以行走也可以拥有。
可行走规范:
public interface IWalkable {
void walk();
}
可游泳规范:
public interface ISwimable {
void swim();
}
两栖动物规范,即可以游泳,又可以行走。
public interface IAmphibiable extends IWalkable,ISwimable{
}
此时子接口能继承所有父接口的方法。
1.2接口实现类
1.2.1 接口实现类概念
和抽象类一样,接口是不能创建对象的,此时必须定义一个类去实现接口,并覆盖接口中的方法,这
个类称之为实现类,类和接口之间的关系称之为实现关系(implements)。
public class 类名 implements 接口名 1,接口名 2{
覆盖接口中抽象方法
}
在类实现接口后,覆盖接口中的抽象方法,完成功能代码,此时接口和实现类之间的关系:
n 接口:定义多个抽象方法,仅仅定义有哪些功能,却不提供实现。
n 实现类:实现接口,覆盖接口中抽象方法,完成功能具体的实现。
1.2.2 接口与实现类案例
/**
* IUSB3_0接口
* 1. 接口interface语法:
声明接口语法:
public interface I接口名 {
全局常量;// 默认都会有一个public static final修饰成员变量,建议简写 // 调用方式:只能是通过: 接口名.常量名;
【必须是声明的同时接着赋值】 命名:全大写用_隔开:MAX_VALUE
抽象方法;// 前面会有默认的public abstract修饰,可以简写
// 从jdk1.7开始有的
public default 返回值类型 方法名(...){ // 调用方式:只能是通过 实现类对象.方法名(...);
}
// 从jdk1.7开始有的
public static 返回值类型 方法名(...){ // 调用方式:只能是通过: 接口名.方法名(...);
}
接口没有构造方法,语法规定
}
按照上面的语法提示,将接口中所有的成员写出来即可
接口要使用,必须有实现类:
语法:
public(abstract) class 接口名Impl implements 接口名1,接口2...{
如果是一个非抽象的类必须重写全部的抽象方法
}
4 注意事项 (重点)
1. 接口命名规则:IXxx【I接口名:不是阿里巴巴规范要求,只是建议的写法】
2. 接口实现类命名规则:接口名Impl
3. 接口中没有构造方法,也不能new对象
4. 如果接口中只有一个抽象方法,该接口就是函数式接口,函数式接口可以用@FunctionalInterface
注解修饰,函数式接口可以使用jdk8新特性lambda表达式。
5. 只要一个接口中只有一个抽象方法,不管有没有@FunctionalInterface,该接口都是函数式接口。
6. 接口必须被子类通过implements全部实现其内的抽象方法
*/
@FunctionalInterface // 该注解,表示当前接口是函数式接口。函数式接口可以使用jdk8新特性lambda表达式。
public interface IMyInterface {// 按照上面的语法提示,将接口中所有的成员写出来即可
/** 全局常量: public static final 数据类型 常量名[全大写,下划线隔开],声明同时必须直接赋值 */
public static final int MAX_VALUE = 2;// 调用方式: 接口名.常量名;
/** 全局常量: 数据类型 常量名[全大写,下划线隔开],声明同时必须直接赋值。简写,省略了修饰符 */
int MIN_VALUE = 1;// 前面默认会有:public static final修饰,建议省略
/**
* testAbstract抽象方法
*/
void testAbstract();// 默认前面有 public abstract修饰,建议省略
/**
* 从jdk1.7开始有的default方法语法:
* public default 返回值类型 方法名(...) { // 调用方式:实现类对象.方法名(...);
}
*/
public default void testDefault1() {
System.out.println("testDefault1");
}
/**
* 从jdk1.7开始有的default方法语法:
* public default 返回值类型 方法名(...) { // 调用方式:实现类对象.方法名(...);
}
*/
public default void testDefault2() {
System.out.println("testDefault2....");
}
/**
* 从jdk1.7开始有的static方法语法:
* public static 返回值类型 方法名(...) { // 调用方式: 接口名.方法名(...);
}
*/
public static void testStatic1() {
System.out.println("testStatic1------>");
}
/**
* 从jdk1.7开始有的static方法语法:
* public static 返回值类型 方法名(...) { // 调用方式: 接口名.方法名(...);
}
*/
public static void testStatic2() {
System.out.println("testStatic2=============>");
}
// 没有构造方法
// public IMyInterface() {}
}
实现类:
/**
* IMyInterface接口实现类MyInterfaceImpl
* 接口实现类语法:
public(abstract) class 接口名Impl implements 接口名1, 接口2...{
如果是一个非抽象的类必须重写全部的抽象方法
}
*/
public class MyInterfaceImpl implements IMyInterface {
@Override
public void testAbstract() {
System.out.println("实现类重写后的抽象方法testAbstract....");
}
}
测试类:
/**
* 接口测试类:将接口中成员全都调用一次
* 测试方式:
* 1. 调用接口中常量和static方法:
* static修饰的调用方式:接口名.常量/static方法(...)
*
* 2. 创建实现类对象,调用default方法和 重写后的抽象方法
* 非static修饰的调用方式:实现类对象.default方法(...)/抽象方法(...)
*
*/
public class MyInterfaceTest {
public static void main(String[] args) {
// 调用IMyInterface接口中常量:接口名.常量
System.out.println(IMyInterface.MIN_VALUE);// 1
System.out.println(IMyInterface.MAX_VALUE);// 2
// 调用IMyInterface接口中static方法:接口名.static方法(...);
IMyInterface.testStatic1();
IMyInterface.testStatic2();
// 创建MyInterfaceImpl实现类对象
MyInterfaceImpl my = new MyInterfaceImpl();
// 通过实现类对象my调用default方法: 实现类对象.default方法(...)
my.testDefault1();
my.testDefault2();
// 通过实现类对象my调用抽象方法: 实现类对象.抽象方法(...)
my.testAbstract();
// new IMyInterface();// 接口不能创建对象
}
}
2. 多态(polymorphic)
2.1 什么是多态?
简单理解 : 看成一种事物多种形态
示例 :
今天晚上大家请我吃大餐 : 龙虾 喝粥 思想大餐....
我准备买一辆车: 独轮车 自行车 拖拉机 布加迪模型....
Java 程序中的体现:
多态概念:
将子类对象装到父类的变量中保存(向上造型/向上转型),当父类变量调用方法的时候,如果子类重写了该方法,会直接执行子类重写之后的方法。(父类变量可以装任意类型的子类对象)。
多态案例1:
父类:
public class Animal {
int age = 1;
public void eat() {
System.out.println("吃....");
}
}
子类:
public class Person extends Animal{
int age = 2;
@Override
public void eat() {
System.out.println("吃肉...");
}
public void coding() {
System.out.println("撸代码...");
}
}
public class Pig extends Animal{
int age = 3;
@Override
public void eat() {
System.out.println("吃白菜");
}
public void gongBaiCai() {
System.out.println("拱白菜");
}
}
测试代码:
public class AnimalTest {
public static void main(String[] args) {
Animal animal = new Person();//多态的方式(向上造型/向上转型)
Animal animal2 = new Pig();//多态的方式(向上造型/向上转型)
//调用方法
animal.eat();//吃肉... 执行子类重写后的方法
animal2.eat();//吃白菜 执行子类重写后的方法
System.out.println(animal.age);//1 成员变量没有多态
// animal.gongBaiCai();//多态不能调用子类独有方法
}
}
2.2 多态作用:
可以屏蔽子类差异性,提高代码的扩展性(通过代码理解,不要从字面理解)
2.3 多态使用:
1. 向上造型/向上转型:
语法:
父类类型 父类变量 = new 子类类型();
父类变量.方法(); // 子类若重写,则会执行子类重写后的方法
例如:
Animal animal = new Person(); //多态的方式(向上造型/向上转型)
Animal animal2 = new Pig(); //多态的方式(向上造型/向上转型)
//调用方法
animal.eat(); //吃肉... 执行子类重写后的方法
animal2.eat(); //吃白菜 执行子类重写后的方法
2. 向下造型/向下转型: =>就是为了调用子类特有方法
例如:(接上面案例)
现在需要调用子类Person中特有的方法或者调用子类Pig中特有的方法,不能调用怎么办?
这个时候就需要强制转换(向下造型/向下转型):
强制转换(向下造型/向下转型)语法:
数据类型 变量 = (数据类型)值/变量;
在向下造型前,必须进行类型判断,需要判断当前父类变量中装的是哪一个子类类型的对象
类型判断方式1:
if(父类变量 instanceof 子类类型1){
//强制类型转换
子类类型1 子类变量 = (子类类型1)父类变量;
//现在就可以调用子类特有方法
子类变量.子类特有方法(...);
}else if(父类变量 instanceof 子类类型2){
//强制类型转换
子类类型2 子类变量 = (子类类型2)父类变量;
//现在就可以调用子类特有方法
子类变量.子类特有方法(...);
}...
类型判断方式2:
if(父类变量.getClass() == 子类类型1.class){
//强制类型转换
子类类型1 子类变量 = (子类类型1)父类变量;
//现在就可以调用子类特有方法
子类变量.子类特有方法(...);
}else if(父类变量.getClass() == 子类类型2.class){
//强制类型转换
子类类型2 子类变量 = (子类类型2)父类变量;
//现在就可以调用子类特有方法
子类变量.子类特有方法(...);
}
测试类代码如下:
public class AnimalTest {
public static void main(String[] args) {
Animal animal = new Person(); //多态的方式(向上造型/向上转型)
Animal animal2 = new Pig(); //多态的方式(向上造型/向上转型)
animal = new Pig(); //多态的方式(向上造型/向上转型)
//调用方法
animal.eat();
animal2.eat();
System.out.println(animal.age); //1 成员变量没有多态
//如果这里需要调用Pig类中特有方法,就需要将animal强转为Pig类型
//类型判断的方式1
if (animal instanceof Pig) { //判断animal中是不是装的Pig对象,如果是才强转
Pig pig = (Pig)animal;
//调用Pig特有方法
pig.gongBaiCai();
} else if (animal instanceof Person) {
//如果这里需要调用Person类中特有方法,就需要将animal强转为Person类型
Person person = (Person)animal;
//调用Person特有方法
person.coding();
}
//类型判断的方式2
if (animal.getClass() == Pig.class) { //判断animal中是不是装的Pig对象,如果是才强转
Pig pig = (Pig)animal;
//调用Pig特有方法
pig.gongBaiCai();
} else if (animal.getClass() == Person.class) {
//如果这里需要调用Person类中特有方法,就需要将animal强转为Person类型
Person person = (Person)animal;
//调用Person特有方法
person.coding();
}
}
}
多态案例2:
父类:
public class Dog {
public void eat() {
System.out.println("吃...");
}
}
public class Hasky extends Dog {
@Override
public void eat() {
System.out.println("沙发..");
}
public void breakHome() {
System.out.println("拆家..");
}
}
public class Teddy extends Dog {
@Override
public void eat() {
System.out.println("吃天吃地吃空气");
}
public void f__k() {
System.out.println("都懂..");
}
}
public class Tudog extends Dog {
@Override
public void eat() {
System.out.println("啃骨头。。。");
}
public void protectHome() {
System.out.println("看家护院");
}
}
public class Person {
/*public void feedDog(Hasky dog) {
dog.eat();
}
public void feedDog(Teddy dog) {
dog.eat();
}
public void feedDog(Tudog dog) {
dog.eat();
}
如果有几万种狗,就需要写几万个方法喂狗,不可取
*/
public void feedDog(Dog dog) {//屏蔽子类差异性。写一个父类类型,所有的子类对象都可以接收
dog.eat();// 会执行dog变量中装的对应子类eat方法
// 调用子类狗特有方法
// 类型判断
if(dog instanceof TuDog) {
Tudog tu = (Tudog)dog;
tu.protectHome();
}....
}
}
测试类:
public class DogTest {
public static void main(String[] args) {
//测试喂狗案例
Hasky hasky = new Hasky();
Tudog tudog = new Tudog();
Teddy teddy = new Teddy();
Person person = new Person();
person.feedDog(hasky);// Dog dog = new Hasky();
person.feedDog(tudog);
person.feedDog(teddy);
}
}
原理分析:
2.4 多态注意事项:
1. 成员变量没有多态
2. 不能调用子类特有的方法,如果需要调用子类特有的方法,必须进行强制类型转换(向下造型/向下转型),向下造型需要进行子类类型判断
3. 父类变量能点(调用)出哪些成员(成员变量和方法),是由当前类和其父类决定,优先从当前类开始查找,直到找到Object了为止,如果Object中有没有,就不能调用
2.5. 继承关系的构造方法执行流程:
类加载流程:
从最高父类构造方法开始执行,逐级向下执行,直到当前类的构造方法结束
如图:
下一章 十三、《面向对象-枚举与关键字》"五"