final、接口

一、final

1.1 final修饰变量

• 生活生产中有些数据是不可变的,做成常量
• 使用final修饰的变量成为常量,不可再次赋值
• final修饰的变量必须在声明的后面直接赋值

常量

• 字面值常量
  • 1/3/555aaa、hhh、hehehe
• 自定义常量
  • 把变量使用final修饰
  • final int area = 960
  • 命名自定义常量的时候字母全部大写，多个单词使用下划线连接

package com.qf.final0;

public class Demo01 {
	public static void main(String[] args) {
		double pi = Math.PI;
		System.out.println(pi);
		
		double pI2 = MathUtil.PI;
		System.out.println(pI2);
		
		// 这个圆周率可以被任意修改,不合理,做成常量不可修改
		// MathUtil.PI = 6.666;
		double pI3 = MathUtil.PI;
		System.out.println(pI3);
	}
}

class MathUtil{
	// 生活生产中有些数据是不可变的,做成常量
	public static final double PI = 3.141592653589793;
}

引用类型常量

• 引用地址不可以改变
• 对象中的内容可以改变

1.2 final修饰类

• 被final修饰的类成为最终的类
• 这个类不能被继承，没有子类

1.3 final修饰方法

• final修饰的方法成为最终的方法
• 可以被所在类的子类继承使用
• 不能被重写

package com.qf.final0;

public class Demo05 {
	public static void main(String[] args) {
		double pi = Math.PI;
		String str = "heiheihei";
		System.out.println();
		
		Students s01 = new Students();
		// 子类可以继承到final修饰的方法
		s01.bitCard();
	}
}

final class Calculator{
	public static int getSum(int...is) {
		int sum = 0;
		for (int i = 0; i < is.length; i++) {
			sum += is[i];
		}
		return sum;
	}
}

// 最终的类无法被继承，没有子类
// class Calculator000 extends Calculator{}

class Student{
	String name;
	int age;
	
	// 被final修饰的方法能被继承,不能被重写
	public final void bitCard() {
		System.out.println("我们需要使用小程序在校区附近打卡....");
	}
}

class Students extends Student{
	
	/*
	public final void bitCard() {
		System.out.println("我们需要使用小程序在校区附近打卡....");
	}
	*/
}

1.4 final小结

二、接口

2.1 定义

• 在java中使用interface声明的内容成为接口

特性

• 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
• 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
• 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。
• 接口不能直接创建对象

2.2 验证接口中属性的修饰符

• 接口和测试类

package com.qf.inter;

public class Demo01 {
	public static void main(String[] args) {
		String field = MyInterface.FIELD;
		System.out.println(field);
		
		// 能使用类名直接调用说明是static修饰
		String yourField = YourInterface.YOUR_FIELD;
		System.out.println(yourField);
		
		// 不能重新赋值说明是final修饰
		// YourInterface.YOUR_FIELD = "嘿嘿嘿";
		
	}
}

interface MyInterface{
	// 属性:公开、静态、常量
	public static final String FIELD = "接口中的FIELD";
	
	// 方法:公开、抽象方法
	public abstract void show();
	
}


interface YourInterface{
	String YOUR_FIELD = "没有修饰符的FIELD";
}

• 验证public

package com.qf.inter;

public interface Demo02 {
	String OUR_FIELD = "Demo02中的OUR_FIELD";
}

package com.qf.final0;

import com.qf.inter.Demo02;

public class Demo06 {
	public static void main(String[] args) {
		// 在其他包中也能访问到,说明默认修饰符是public
		String ourField = Demo02.OUR_FIELD;
		System.out.println(ourField);
	}
}

三、接口和抽象类

3.1 相同点

• 可以生产字节码文件
• 可以声明为引用类型
• 不能直接创建对象
• 拥有Object中所有的方法

3.2 不同点

• 接口中所有的属性都是公开、静态、常量，默认使用public static final修饰
• 接口中的方法都是公开、抽象方法，默认使用public abstract修饰
• 接口中没有构造方法、动态代码块、静态代码块
• 一个类只能继承一个抽象类，而一个类却可以实现多个接口
  注：JDK 1.8 以后，接口里可以有静态方法和方法体了。

四、接口的基本使用

4.1 USB案例

package com.qf.inter;

public class Demo03 {
	public static void main(String[] args) {
		ACER acer = new ACER();
		acer.power();
		acer.transfer();
		
		System.out.println("=================");
		
		USB usb = new ACER();
		usb.power();
		usb.transfer();
		
	}
}

/**
 * USB 接口
 * 	定义了属性电压和版本
 * 	定义了方法充电和传输数据
 * @author Dushine2008
 *
 */
interface USB{
	// 属性
	double VOLTAGE = 5.0;
	double VERSION = 3.0;
	
	// 方法
	public abstract void power();
	
	public abstract void transfer();
}

/**
 * 子类宏碁电脑
 * 	实现接口USB
 * @author Dushine2008
 *
 */
class ACER implements USB{

	@Override
	public void power() {
		System.out.println("我的电脑品牌是宏碁，供电电压是5.0V，最大电流是2A...");
	}

	@Override
	public void transfer() {
		System.out.println("我的电脑USB版本是" + VERSION + "，传输数据速率嫩达到6Gbps...");
	}
	
}

五、接口的多态

5.1 接口多态的向上转型

• 接口可以用作变量的声明
• 声明接口的类型，引用指向实现接口的类创建的对象
• 这个是向上转型的多态

package com.qf.inter;

public class Demo04 {
	public static void main(String[] args) {
		/**
		 * Dog类
		 * 	继承Animal
		 * 	实现Runnable接口
		 * 	实现Swiming接口
		 */
		Dog dog = new Dog("道哥", 2);
		dog.run();
		dog.swim();
		dog.eat();
		dog.sleep();
		
		System.out.println("================================");
		
		Animal animal = new Dog();
		animal.eat();
		animal.sleep();
		
		System.out.println("================================");
		
		Runnable runnable = new Dog();
		runnable.run();
		
		System.out.println("================================");
		
		Swimable swimable = new Dog();
		swimable.swim();
		
	}
}

/**
 * 动物类
 * 	定义了属性和方法
 * @author Dushine2008
 *
 */
class Animal{
	String name;
	int age;
	
	public Animal() {
		super();
	}
	
	public Animal(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	public void eat() {
		System.out.println("很多动物都是杂食性的...");
	}	
	
	public void sleep() {
		System.out.println("大部分动物晚上睡觉...");
	}
}

/**
 * 能奔跑的接口
 * @author Dushine2008
 *
 */
interface Runnable{
	void run();
}

/**
 * 能游泳的接口
 * @author Dushine2008
 *
 */
interface Swimable{
	void swim();
}

/**
 * Dog类
 * 	继承了Animal，获得了Animal中所有非私有的属性和方法
 * 	实现了Swimable接口，重写了游泳的方法
 * 	实现了Runnable接口，重写了奔跑的方法
 * @author Dushine2008
 *
 */
class Dog extends Animal implements Runnable,Swimable{

	public Dog() {
		super();
	}

	public Dog(String name, int age) {
		super(name, age);
	}

	/**
	 * 来自Swimable中的方法
	 */
	@Override
	public void swim() {
		System.out.println("狗子天生就会游泳,狗刨这个姿势来来自狗子...");
	}

	@Override
	public void run() {
		System.out.println("狗子奔跑的时候用四条腿,速度比人要快一些....");
	}
	
}

5.2 接口多态的向下转型

• 把声明的父类引用转换回原来的类型

package com.qf.inter;

public class Demo05 {
	public static void main(String[] args) {
		/**
		 * Dog类
		 * 	继承Animal
		 * 	实现Runnable接口
		 * 	实现Swiming接口
		 */
		Dog5 dog = new Dog5("道哥", 2);
		dog.run();
		dog.swim();
		dog.eat();
		dog.sleep();
		
		System.out.println("================================");
		
		Animal5 animal = new Dog5();
		animal.eat();
		animal.sleep();
		
		Dog5 dog5 = (Dog5) animal;
		dog5.run();
		dog5.swim();
		dog5.eat();
		dog5.sleep();
		
		System.out.println("================================");
		
		Runnable5 runnable = new Dog5();
		runnable.run();
		
		Dog5 dog05 = (Dog5) runnable;
		dog05.run();
		dog05.swim();
		dog05.eat();
		dog05.sleep();
		
		System.out.println("================================");
		
		Swimable5 swimable = new Dog5();
		swimable.swim();
		
		// Runnable r = (Runnable) swimable;
		
	}
}

/**
 * 动物类
 * 	定义了属性和方法
 * @author Dushine2008
 *
 */
class Animal5{
	String name;
	int age;
	
	public Animal5() {
		super();
	}
	
	public Animal5(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	public void eat() {
		System.out.println("很多动物都是杂食性的...");
	}	
	
	public void sleep() {
		System.out.println("大部分动物晚上睡觉...");
	}
}

/**
 * 能奔跑的接口
 * @author Dushine2008
 *
 */
interface Runnable5{
	void run();
}

/**
 * 能游泳的接口
 * @author Dushine2008
 *
 */
interface Swimable5{
	void swim();
}

/**
 * Dog类
 * 	继承了Animal，获得了Animal中所有非私有的属性和方法
 * 	实现了Swimable接口，重写了游泳的方法
 * 	实现了Runnable接口，重写了奔跑的方法
 * @author Dushine2008
 *
 */
class Dog5 extends Animal5 implements Runnable5,Swimable5{

	public Dog5() {
		super();
	}

	public Dog5(String name, int age) {
		super(name, age);
	}

	/**
	 * 来自Swimable中的方法
	 */
	@Override
	public void swim() {
		System.out.println("狗子天生就会游泳,狗刨这个姿势来来自狗子...");
	}

	@Override
	public void run() {
		System.out.println("狗子奔跑的时候用四条腿,速度比人要快一些....");
	}
	
}

六、接口和类常见关系

• 类和类
  • 单继承,多层继承
  • 使用extends
• 类和接口
  • 多实现，一个类可以在继承另一个类的同时再实现多个接口
  • implements 接口1，接口2接口3。。。
• 接口和接口
  • 多继承
  • 接口A extends 接口B，接口C，接口D…

package com.qf.inter;

public class Demo06 {
	public static void main(String[] args) {
		Lenove lenove = new Lenove();
		lenove.power();
		lenove.transferHDMI();
		lenove.transferVGA();
		lenove.readROM();
		lenove.RAM();
		lenove.ROM();
		lenove.start();
		lenove.shutdown();
		lenove.signalCommunicate();
	}
}

/**
 * 电脑类
 * 	定义了电脑通用的属性和方法
 * @author Dushine2008
 *
 */
class Computer{
	// 属性
	String brand;
	int price;
	int weight;
	int size;
	
	// 方法
	public void start() {
		System.out.println("电脑必须可以通过电源键开机...");
	}
	
	public void shutdown() {
		System.out.println("电脑关机可以分为软关机和硬关机...");
	}
	
}

/**
 * VGA接口，提供VGA协议规定的数据传输方式
 * @author Dushine2008
 *
 */
interface VGA{
	void transferVGA();
}

/**
 * HDMI接口，提供HDMI协议规定的数据传输方式
 * @author Dushine2008
 *
 */
interface HDMI{
	void transferHDMI();
}

/**
 * 电源接口
 * @author Dushine2008
 *
 */
interface Power{
	void power();
}

/**
 * 网线接口
 * @author Dushine2008
 *
 */
interface RJ45{
	void signalCommunicate();
}

/**
 * 光驱接口
 * @author Dushine2008
 *
 */
interface CdDrive{
	void readROM();
}

/**
 * 主板接口，继承VGA,HDMI,Power,RJ45
 * 	自己独有的方法内存、硬盘、CPU
 * 	
 * @author Dushine2008
 *
 */
interface Board extends VGA,HDMI,Power,RJ45{
	void RAM();
	
	void ROM();
}

class Lenove extends Computer implements Board,CdDrive{

	@Override
	public void transferVGA() {
		System.out.println("VGA信号传输效果真赞!!!!");
		
	}

	@Override
	public void transferHDMI() {
		System.out.println("HDMI信号传输效果geng赞!!!!");
		
	}

	@Override
	public void power() {
		System.out.println("这款电脑即便是没有电池也能正常工作...");
	}

	@Override
	public void signalCommunicate() {
		System.out.println("这款电脑不插网线也能浏览网页...");
	}

	@Override
	public void readROM() {
		System.out.println("这款电脑提供了光驱,可以看DVD里面的大片...");
	}

	@Override
	public void RAM() {
		System.out.println("这款电脑内存8G,可以运行多数软件...");
	}

	@Override
	public void ROM() {
		System.out.println("这款电脑磁盘1T,可以存储800部大片...");
	}
	
}

七、常量接口

• 存放一些常用的常量
• 调用的时候直接使用 接口名.常量名就能获取到具体的内容，简单方便

package com.qf.inter;

public interface Constants {
	String USERNAME = "root";
	String PASSWORD = "root1234";
	String HOST_NAME = "localhost:3306";
	String DB_NAME = "";
}

八、接口回调

• 假设我们学习每周会有一次周考
• 讲师分配周考的任务给学生
• 学生做周考题目，做完之后把结果反馈给讲师
  • 需要考试这样一个接口
  • 讲师类实现考试接口，再定义接收结果的方法
  • 学生类中定义做考试题的方法

8.1 案例01

package com.qf.callback;

public class Demo01 {
	public static void main(String[] args) {
		Student stu = new Student("zhangsan");
		Teacher teacher = new Teacher(stu);
		
		teacher.doTest("java基础测试");
		
	}
}

/**
 * java考试的接口
 * @author Dushine2008
 *
 */
interface JavaTest{
	void doTest(String testName);
}

class Teacher implements JavaTest{
	Student student;

	public Teacher(Student student) {
		super();
		this.student = student;
	}

	@Override
	public void doTest(String testName) {
		System.out.println("讲师开始分配任务.............");
		student.doTest(testName,this);
	}

	public void getResult(String result) {
		System.out.println("接收到学生传来的结果:" + result);
		
	}
	
}

class Student{
	String name;
	
	public Student(String name) {
		super();
		this.name = name;
	}

	public void doTest(String testName, Teacher teacher) {
		System.out.println("学生接收到任务..............");
		System.out.println(name + "开始认真做" + testName);
		System.out.println("100分钟之后.........");
		teacher.getResult("试题做完啦啦啦啦啦啦");
	}	
}

8.2 案例02

package com.qf.callback;

public class Demo02 {
	public static void main(String[] args) {
		Worker worker = new Worker("卓别林");
		Boss boss = new Boss(worker);
		
		boss.task("拧一万个螺丝");
	}
}

/**
 * 接口公司
 * 	进了公司有任务需要做
 * @author Dushine2008
 *
 */
interface Company{
	void task(String taskName);
}

/**
 * Boss类
 * 	实现公司接口中的任务方法
 * 	在任务方法中分配任务
 * @author Dushine2008
 *
 */
class Boss implements Company{
	Worker worker;

	public Boss(Worker worker) {
		super();
		this.worker = worker;
	}

	/**
	 * 重写接口中的任务方法
	 */
	@Override
	public void task(String taskName) {
		System.out.println("Boss开分配任务:" + taskName);
		worker.work(taskName,this);
	}

	/**
	 * boss接收结果的方法
	 * @param worker
	 * @param result
	 */
	public void getResult(Worker worker, String result) {
		System.out.println(worker.name + "回复：" + result);
	}
	
}

/**
 * 工人类
 * 	接收boss分配的任务
 * 	做完任务后调用boss接收消息的方法反馈内容
 * @author Dushine2008
 *
 */
class Worker{
	String name;

	public Worker(String name) {
		super();
		this.name = name;
	}

	/**
	 * 工人做工的方法
	 * @param taskName	boss分配的任务
	 * @param boss		分配任务的boss
	 */
	public void work(String taskName, Boss boss) {
		System.out.println("工人接收到任务:" + taskName);
		System.out.println(this.name + "开始努力做任务:" + taskName);
		System.out.println("100分钟之后给boss的回复............");
		boss.getResult(this,"任务完成！！！");
	}
	
}

九、接口的好处