java-抽象类和接口

抽象类和接口

1. 抽象类实现多态

抽象类实现多态的方式依然还是两种：

1.父类作为形参

2.父类作为返回值

2. final关键字

final单词：最终的

可以用于修饰

​ 属性：称之为常量，表示此属性值只能被赋值一次，不能改变

​ 方法：表示此方法只能被继承，不能被重写

​ 类：表示此类不能被继承

2.1 修饰属性

final修饰属性：

常量名称全部大写，多个单词之间使用下划线分割 WORD1_WORD2

被final修饰的属性称之为常量，常量只能被赋值一次

通常(百分之九十九)在定义的时候赋值，或者在构造方法中赋值

以上两种赋值方式都是为了保证在使用常量之前是有值的

package com.qfedu.test2;
/**
 * 	final修饰属性：
 * 		常量名称全部大写，多个单词之间使用下划线分割  WORD1_WORD2
 * 		被final修饰的属性称之为常量，常量只能被赋值一次
 * 		通常(百分之九十九)在定义的时候赋值，或者在构造方法中赋值
 * 		以上两种赋值方式都是为了保证在使用常量之前是有值的
 * 		
 * 	
 * @author WHD
 *
 */
public class TestFinal {
	final double PI = 3.14; // 圆周率
	double radius; // 半径
	final String COUNTRY_NAME;
	
	public TestFinal() {
		COUNTRY_NAME = "中华人民共和国";
	}
	
	public TestFinal(double radius) {
		this.radius = radius;
		COUNTRY_NAME = "中华人民共和国";
	}
	public static void main(String[] args) {
		TestFinal tf = new TestFinal();
		tf.radius = 10;
//		tf.PI = 3.14;
		System.out.println("半径为："+ tf.radius +"，面积为：" + tf.PI * tf.radius * tf.radius);
	
		TestFinal tf1 = new TestFinal();
	
	}
	
}

回顾我们之前定义的PI 和 COUNTRY_NAME

因为使用final修饰所以其值不能改变 这样的数据通常也没有必要存在多个

所以我们可以再加上static修饰符 表示静态常量

静态常量:表示此常量值在内存中只有一份 并且值不能被改变

通常在定义的时候赋值或者在静态代码块中赋值

以上两种方式同样是为了保证 静态常量在使用之前是有值的

同级别互相直接访问

静态访问实例 先new对象

实例访问静态直接访问

静态的先加载 先执行不需要new对象

package com.qfedu.test2;
/**
 * 	回顾我们之前定义的PI  和  COUNTRY_NAME
 * 	因为使用final修饰所以其值不能改变   这样的数据通常也没有必要存在多个
 * 	所以我们可以再加上static修饰符 表示静态常量
 * 
 * 	静态常量:表示此常量值在内存中只有一份 并且值不能被改变
 * 	通常在定义的时候赋值或者在静态代码块中赋值
 * 	以上两种方式同样是为了保证 静态常量在使用之前是有值的
 * 
 * 	同级别互相直接访问
 * 	静态访问实例 先new对象
 * 	实例访问静态直接访问
 * 		
 * 	静态的先加载 先执行不需要new对象
 * @author WHD
 *
 */
public class TestStaticFinal {
	static final double PI = 3.14;
	static final String COUNTRY_NAME;
	
	static {
		COUNTRY_NAME= "中华人民共和国";
	}
	
	public TestStaticFinal() {
//		COUNTRY_NAME= "中华人民共和国"; 构造方法中不能访问静态相关的信息
	}
}

2.2 修饰方法

被final修饰的方法不能被重写

package com.qfedu.test2;
/**
 * 	被final修饰的方法不能被重写
 * @author WHD
 *
 */
public class TestFinalMethod {
	public void m1() {
		System.out.println("m1方法");
	}
	
	
	public final void m2() {
		System.out.println("m2方法");
	}
	
	
	public void m3() {
		System.out.println("m3方法");
	}
	
	public static void main(String[] args) {
		A a = new A();
		a.m1();
		a.m2();
		a.m3();
	}
	
}

class A extends TestFinalMethod{
	public void m1() {
		System.out.println("A类重写m1方法");
	}
	
	
//	public void m2() { 被final修饰的方法  可以继承 但是不能被重写
//		System.out.println("A类重写m2方法");
//	}
	
	
	public void m3() {
		System.out.println("A类重写m3方法");
	}
}

2.3 修饰类

被final修饰的类 不能被继承

package com.qfedu.test2;
/**
 * 	被final修饰的类 不能被继承
 * @author WHD
 *
 */
public class TestFinalClass {

}

final class B {
	
}
//class C extends B{ 这里不能继承B类
//	 
//}

3. 接口

3.1 概念和规则

接口：接口相当于一种约定/规定，属于提前定义的内容，接口只关注约定，不关注具体实现

DK1.7
1.接口中的方法默认都是全局抽象方法 不管是否书写都 public abstract 关键字修饰的效果
2.接口不能直接new对象，必须通过new实现类(子类)的方式创建对象
3.实现类(子类)必须实现(重写)接口中的所有抽象方法，除非子类也是抽象类或者接口
4.接口中不能书写普通属性，默认都是全局静态常量：不管是否书写都有 public static final 修饰
普通方法，静态方法，构造方法，静态代码块
5.一个类只能继承一个父类，但是可以实现多个接口
6.接口可以继承多个接口
7.接口实现多态的方式与之前一致：接口作为形参，接口作为返回值

面试题：Java支持多继承吗？
不支持，但是我们可以通过接口继承多个接口的方式，实现类似多继承的效果

3.2 课堂案例

让不同类型的手机实现不同个数的接口，代表不同的手机具备不同的功能

接口就是一种约定，遵循这个约定即代表拥有某种能力

package com.qfedu.test5;
/**
 * 	普通手机
 * 	当一个类即需要继承父类，又需要实现接口：先继承，后实现
 * @author WHD
 *
 */
public class CommonPhone extends Phone implements Audio,NetWork{

	@Override
	public void call() {
		System.out.println("普通手机打电话，按键拨号");
	}

	@Override
	public void sendMessage(String message) {
		System.out.println("普通手机发短信，按键打字：" + message);
	}

	@Override
	public void connect() {
		System.out.println("普通手机连接2G网络，网速感人");
	}

	@Override
	public void playAudio(String audioName) {
		System.out.println("普通手机听音乐，音质感人" + audioName);
	}

}

1. 接口实现多态

接口实现多态的方式

1.接口作为形参

2.接口作为返回值

2. 抽象类和接口总结

2.1 适用场景

当你关注事物的本质，使用抽象类；当你关注某个功能，使用接口

2.2 区别

相同点

​ 代表系统的抽象层
​ 都不能被实例化
​ 都能包含抽象方法
​ 用于描述系统提供的服务，不必提供具体实现

不同点

​ 在抽象类中可以为部分方法提供默认实现，而接口中只能包含抽象方法
​ 抽象类便于复用，接口便于代码维护
​ 一个类只能继承一个直接的父类，但可以实现多个接口

使用原则

​ 接口做系统与外界交互的窗口
​ 接口提供服务
​ 接口本身一旦制定，就不允许随意修改
​ 抽象类可完成部分功能实现，还有部分功能可作为系统的扩展点

2.3 OOP设计原则

多用组合，少用继承

针对接口编程

针对扩展开放，针对改变关闭