一、final 关键字
基本介绍
final 可以修饰类、属性、方法和局部变量。
在某些情况下,程序员可能有以下需求,就会使用到final:
1)当不希望类被继承时,可以用final修饰。
2)当不希望父类的某个方法被子类覆盖/重写(override)时,可以用final关键字修饰。
【语法:访问修饰符 final 返回类型 方法名】
3)当不希望类的的某个属性的值被修改,可以用final修饰。
【 public final double TAX RATE = 0.08】
4)当不希望某个局部变量被修改,可以使用final修饰【final double TAX RATE = 0.08】
//如果我们要求 hi 不能被子类重写
//可以使用 final 修饰 hi 方法
public final void hi() {}
//当不希望类的的某个属性的值被修改,可以用 final 修饰
public final double TAX_RATE = 0.08;//常量
//当不希望某个局部变量被修改,可以使用 final 修饰
//这时,NUM 也称为 局部常量
final double NUM = 0.01;
注意事项
1)final修饰的属性又叫常量,一般用XX_XX_XX来命名
2)final修饰的属性在定义时,必须赋初始值,并且以后不能再修改,赋值可以在如下位置之一【选择一个位置赋初值即可】:
1 - 定义时:如 public final double TAX_RATE = 0.08;
2 - 在构造器中
3 - 在代码块中
3)如果 final修饰的属性是静态的,则初始化的位置只能是:
1 - 定义时赋值
2 - 在静态代码块,不能在构造器中赋值。
4)final类不能继承,但是可以实例化对象。[A2类]
5)如果类不是 final类,但是含有 final方法,则该方法虽然不能重写,但是可以被继承。[A3类]
package com.spock.final_;
public class FinalDetail01 {
public static void main(String[] args) {
CC cc = new CC();
new EE().cal();
}
}
class AA {
/*
1. 定义时:如 public final double TAX_RATE = 0.08;
2. 在构造器中
3. 在代码块中
*/
public final double TAX_RATE = 0.08;//1.定义时赋值
public final double TAX_RATE2 ;
public final double TAX_RATE3 ;
public AA() {
//构造器中赋值
TAX_RATE2 = 1.1;
}
{
//在代码块赋值
TAX_RATE3 = 8.8;
}
}
class BB {
/*
如果 final 修饰的属性是静态的,则初始化的位置只能是
1 - 定义时赋值 2 - 在静态代码块 不能在构造器中赋值。
*/
public static final double TAX_RATE = 99.9; //定义时赋值
public static final double TAX_RATE2;
static {
//静态代码块赋值
TAX_RATE2 = 3.3;
}
}
//final 类不能继承,但是可以实例化对象
final class CC { }
//如果类不是 final 类,但是含有 final 方法,则该方法虽然不能重写,但是可以被继承
//即,仍然遵守继承的机制
class DD {
public final void cal() {
System.out.println("cal()方法");
}
}
class EE extends DD { }
6)一般来说,如果一个类已经是final类了,就没有必要再将方法修饰成final方法。
7)final不能修饰构造方法(即构造器)
8)final 和 static 往往搭配使用,效率更高,不会导致类加载。底层编译器做了优化处理。
class Demo {
public static final int i = 16;
static {
System.out.println("代码块执行,类加载了")
}
}
8)包装类(Integer,Double,Float,Boolean等都是final),String也是final类。
二、抽象类
使用抽象类的原因
解决父类方法不确定性的问题
1 - 考虑将该方法设计为抽象(abstract)方法
2 - 所谓抽象方法就是没有实现的方法
3 - 所谓没有实现就是指,没有方法体
4 - 当一个类中存在抽象方法时,需要将该类声明为 abstract 类
5 - 一般来说,抽象类会被继承,有其子类来实现抽象方法
小结:
当父类的某些方法,需要声明,但是又不确定如何实现时,可以将其声明为抽象方法,那么这个类就是抽象类。
抽象类快速入门
当父类的一些方法不能确定时,可以用 abstract关键字 来修饰该方法,这个方法就是抽象方法。
用 abstract 来修饰该类就是抽象类。
如何把Animal做成抽象类,并让子类Cat类实现。
abstract class Animal{
String name;
int age;
abstract public void cry();
}
抽象类的介绍
1)用 abstract关键字 来修饰一个类时,这个类就叫抽象类。
语法:
访问修饰符 abstract class 类名 {
}
2)用 abstract关键字 来修饰一个方法时,这个方法就是抽象方法。
语法:
访问修饰符 abstract 返回类型 方法名(参数列表); //没有方法体
3)抽象类的价值更多的作用是在于设计,是设计者设计好后,让子类继承并实现抽象类
4)抽象类,是考官比较爱问的知识点,在框架和设计模式使用较多
注意事项
1)抽象类不能被实例化
2)抽象类不一定要包含 abstract方法。也就是说,抽象类可以没有abstract方法
3)一旦类包含了 abstract方法,则这个类必须声明为abstract
4)abstract 只能修饰类和方法,不能修饰属性和其它的东西。
package com.spock.abstract_;
public class AbstractDetail01 {
public static void main(String[] args) {
//抽象类,不能被实例化
new A();//报错
}
}
//抽象类不一定要包含 abstract 方法。
//也就是说,抽象类可以没有 abstract 方法
//还可以有实现的方法。
abstract class A {
public void hi() {
System.out.println("hi");
}
}
//一旦类包含了 abstract 方法,则这个类必须声明为 abstract
abstract class B {
public abstract void hi();
}
//abstract 只能修饰类和方法,不能修饰属性和其它的
class C {
//错误 public abstract int n1 = 1;
}
5)抽象类可以有任意成员【抽象类本质还是类】
比如:非抽象方法、构造器、静态属性等等
6)抽象方法不能有主体,即不能实现
7)如果一个类继承了抽象类,则它必须实现抽象类的所有抽象方法
除非它自己也声明为 abstract类。
8)抽象方法不能使用 private、final 和 static来修饰,因为这些关键字都是和重写相违背的。
package com.spock.abstract_;
public class AbstractDetail02 {
public static void main(String[] args) {
System.out.println("hello");
}
}
//抽象方法不能使用 private、final 和 static 来修饰
//因为这些关键字都是和重写相违背的
abstract class H {
public abstract void hi();//抽象方法
}
//如果一个类继承了抽象类,则它必须实现抽象类的所有抽象方法
//除非它自己也声明为 abstract 类
abstract class E {
public abstract void hi();
}
abstract class F extends E {
}
class G extends E {
@Override
public void hi() {
//这里相等于 G 子类实现了父类 E 的抽象方法
//所谓实现方法,就是有方法体
}
}
//抽象类的本质还是类,所以可以有类的各种成员
abstract class D {
public int n1 = 10;
public static String name = "抽象类";
public void hi() {
System.out.println("hi");
}
public abstract void hello();
public static void ok() {
System.out.println("ok");
}
}
三、抽象类最佳实践-模板设计模式
基本介绍
抽象类体现的就是一种模板模式的设计,抽象类作为多个子类的通用模板
子类在抽象类的基础上进行扩展、改造,但子类总体上会保留抽象类的行为方式。
模板设计模式能解决的问题
1)当功能内部中一部分实现是确定的,一部分实现是不确定的。这时可以把不确定的部分暴露出去,让子类去实现。
2)编写一个抽象父类,父类提供了多个子类的通用方法,并把一个或多个方法留给其子类实现,就是一种模板模式。
最佳实践
需求:
1)有多个类,完成不同的任务job
2)要求统计得到各自完成任务的时间
3)请编程实现TestTemplate.java
思路:
1)先用最容易想到的方法 ---> 代码实现
2)分析问题,提出使用模板设计模式
package com.spock.abstract_;
//抽象类-模板设计模式
//模板类
abstract public class Template {
public abstract void job(); //抽象方法
public void calculateTime() { //实现方法,调用 job 方法
//得到开始的时间
long start = System.currentTimeMillis();
job(); //动态绑定机制
//得的结束的时间
long end = System.currentTimeMillis();
System.out.println("任务执行时间 " + (end - start));
}
}
package com.spock.abstract_;
//继承模板类
public class AA extends Template {
//计算任务
//1+....+ 800000
@Override
public void job() { //实现 Template 的抽象方法 job
long num = 0;
for (long i = 1; i <= 800000; i++) {
num += i;
}
}
// public void job2() {
// //得到开始的时间
// long start = System.currentTimeMillis();
// long num = 0;
// for (long i = 1; i <= 200000; i++) {
// num += i;
// }
// //得的结束的时间
// long end = System.currentTimeMillis();
// System.out.println("AA 执行时间 " + (end - start));
// }
}
package com.spock.abstract_;
public class BB extends Template{
public void job() {//重写了 Template 的 job 方法
long num = 0;
for (long i = 1; i <= 80000; i++) {
num *= i;
}
}
}
package com.spock.abstract_;
public class TestTemplate {
public static void main(String[] args) {
AA aa = new AA();
aa.calculateTime(); //这里还是需要有良好的 OOP 基础,对多态
BB bb = new BB();
bb.calculateTime();
}
}
上面就是抽象类—模版设计模式
只需要继承这个抽象类
然后实现job方法,通过动态绑定机制。
就可以得到各自完成的时间。
四、接口
基本介绍
接口就是给出一些没有实现的方法,封装到一起,直到某个类要使用的时候,再根据具体情况把这些方法写出来。
语法:
interface 接口名 {
//属性
//抽象方法
}
class 类名 implements 接口 {
自己属性;
自己方法;
必须实现的接口的抽象方法
}
小结:接口是更加抽象的 抽象类,抽象类里的方法可以有方法体,接口里的所有方法都没有方法体【Jdk7.0】。接口体现了程序设计的多态和高内聚低偶合的设计思想。
特别说明:Jdk8.0 后接口类可以有静态方法,默认方法,也就是说接口中可以有方法的具体实现
接口快速入门
package com.spock.interface_;
//接口
public interface UsbInterface {
//规定接口的相关方法
public void start();
public void stop();
}
package com.spock.interface_;
//实现接口,就是把接口方法实现
public class Camera implements UsbInterface{
@Override
public void start() {
System.out.println("相机开始工作...");
}
@Override
public void stop() {
System.out.println("相机停止工作....");
}
}
package com.spock.interface_;
//Phone类 实现 UsbInterface
//解读 1. 即 Phone类需要实现 UsbInterface 接口 规定/声明的方法
public class Phone implements UsbInterface {
@Override
public void start() {
System.out.println("手机开始工作...");
}
@Override
public void stop() {
System.out.println("手机停止工作.....");
}
}
package com.spock.interface_;
public class Interface01 {
public static void main(String[] args) {
//创建手机,相机对象
//Camera 实现了 UsbInterface
Camera camera = new Camera();
//Phone 实现了 UsbInterface
Phone phone = new Phone();
//创建计算机
Computer computer = new Computer();
computer.work(phone);//把手机接入到计算机
System.out.println("===============");
computer.work(camera);//把相机接入到计算机
}
}
注意事项
1 - 接口不能被实例化
2 - 接口中所有的方法是 public 方法, 接口中抽象方法,可以不用 abstract 修饰
void aaa();
实际上是 abstract void aaa();
void aaa() {}; //错误,不需要花括号
3 - 一个普通类实现接口,就必须将该接口的所有方法都实现,可以使用 alt+enter 来解决
4 - 抽象类去实现接口时,可以不实现接口的抽象方法
//1.接口不能被实例化
//2.接口中所有的方法是 public 方法, 接口中抽象方法,可以不用 abstract 修饰
//3.一个普通类实现接口,就必须将该接口的所有方法都实现,可以使用 alt+enter 来解决
//4.抽象类去实现接口时,可以不实现接口的抽象方法
interface IA {
void say();//修饰符 public protected 默认 private
void hi();
}
class Cat implements IA{
@Override
public void say() { }
@Override
public void hi() { }
}
//抽象类
//抽象类去实现接口时,可以不实现接口的抽象方法
abstract class Tiger implements IA {}
5 - 一个类同时可以实现多个接口
6 - 接口中的属性,只能是final的,而且是 public static final修饰符。
比如:int a = 1;
实际上是 public static final int a=1;(必须初始化)
7 - 接口中属性的访问形式:
接口名.属性名
8 - 接口不能继承其它的类,但是可以继承多个别的接口
interface A extends B,C {}
9 - 接口的修饰符只能是 public 和 默认,这点和类的修饰符是一样的。
public class InterfaceDetail02 {
public static void main(String[] args) {
//证明 接口中的属性,是 public static final
System.out.println(IB.n1);
//说明 n1 就是 static
//IB.n1 = 30; 说明 n1 是 final
}
}
interface IB {
//接口中的属性,只能是 final 的,而且是 public static final 修饰符
int n1 = 10; //等价 public static final int n1 = 10;
}
interface IC {
void say();
}
}
//接口不能继承其它的类,但是可以继承多个别的接口
interface ID extends IB,IC {
}
//一个类同时可以实现多个接口
class Pig implements IB,IC {
@Override
public void hi() { }
@Override
public void say() { }
}
实现接口 vs 继承类
package com.spock.interface_;
public class ExtendsVsInterface {
public static void main(String[] args) {
LittleMonkey wuKong = new LittleMonkey("悟空");
wuKong.climbing();
wuKong.swimming();
wuKong.flying();
}
}
//猴子类
class Monkey {
private String name;
public Monkey(String name) {
this.name = name;
}
public void climbing() {
System.out.println(name + " 会爬树...");
}
public String getName() {
return name;
}
}
//接口
interface Fishable {
void swimming();
}
interface Birdable {
void flying();
}
// 继承
// 小结: 当子类继承了父类,就自动的拥有父类的功能
// 如果子类需要扩展功能,可以通过实现接口的方式扩展
// 可以理解 实现接口 是 对 java 单继承机制的一种补充.
class LittleMonkey extends Monkey implements Fishable,Birdable {
public LittleMonkey(String name) {
super(name);
}
@Override
public void swimming() {
System.out.println(getName() + " 通过学习,可以像鱼儿一样游泳...");
}
@Override
public void flying() {
System.out.println(getName() + " 通过学习,可以像鸟儿一样飞翔...");
}
}
接口和继承解决的问题不同
继承的价值主要在于:解决代码的复用性和可维护性。
接口的价值主要在于:设计,设计好各种规范(方法),让其它类去实现这些方法。即更加的灵活。
接口比继承更加灵活
接口比继承更加灵活,继承是满足 is - a 的关系,而接口只需满足 like - a 的关系。
接口在一定程度上实现代码解耦 [即:接口规范性 + 动态绑定机制]
接口的多态特性
1)多态参数
在前面的USB接口案例,UsbInterface usb,即可以接收手机对象,又可以接受相机对象,就体现了 接口的多态特性。
2)多态数组
案例:给USB数组中,存放 Phone 和 相机对象,Phone类还有一个特有的方法 call()
请遍历USB数组,如果是 Phone对象,除了调用USB接口定义的方法外,还需要调用 Phone类的特有方法 call()。
3)接口存在多态传递现象。
package com.spock.interface_;
public class InterfacePolyParameter {
public static void main(String[] args) {
//接口的多态体现
//接口类型的变量 if01 可以指向 实现了 IF 接口类的对象实例
IF if01 = new Monster();
if01 = new Car();
//继承体现的多态
//父类类型的变量 a 可以指向 继承 AAA 的子类的对象实例
AAA a = new BBB();
a = new CCC();
}
}
interface IF {
}
class Monster implements IF {}
class Car implements IF {}
class AAA {
}
class BBB extends AAA {}
class CCC extends AAA {}
package com.spock.interface_;
public class InterfacePolyArr {
public static void main(String[] args) {
//多态数组 -> 接口类型数组
Usb[] usbs = new Usb[2];
usbs[0] = new Phone_();
usbs[1] = new Camera_();
/*
给 Usb 数组中,存放 Phone 和 相机对象,Phone 类还有一个特有的方法 call(),
请遍历 Usb 数组,如果是 Phone 对象,除了调用 Usb 接口定义的方法外,
还需要调用 Phone 特有方法 call
*/
for(int i = 0; i < usbs.length; i++) {
usbs[i].work();//动态绑定.. //和前面一样,我们仍然需要进行类型的向下转型
if(usbs[i] instanceof Phone_) {//判断他的运行类型是 Phone_
((Phone_) usbs[i]).call();
}
}
}
}
interface Usb{
void work();
}
class Phone_ implements Usb {
public void call() {
System.out.println("手机可以打电话...");
}
@Override
public void work() {
System.out.println("手机工作中...");
}
}
class Camera_ implements Usb {
@Override
public void work() {
System.out.println("相机工作中...");
}
}
package com.spock.interface_;
/**
* 演示多态传递现象
*/
public class InterfacePolyPass {
public static void main(String[] args) {
//接口类型的变量可以指向,实现了该接口的类的对象实例
IG ig = new Teacher();
//如果 IG 继承了 IH 接口,而 Teacher 类实现了 IG 接口
//那么,实际上就相当于 Teacher 类也实现了 IH 接口. //这就是所谓的 接口多态传递现象. IH ih = new Teacher();
}
}
interface IH {
void hi();
}
interface IG extends IH { }
class Teacher implements IG {
@Override
public void hi() {
}
}