1. 为抽象类和接口实例化
在java中可以通过对象的多态性，为抽象类和接口实例化，这样再使用抽象类
和接口的时候就可以调用本子类中所覆写过的方法了。
之所以抽象类和接口不能直接实例化，是因为其内部包含了多个抽象方法，抽
像方法本身都是未实现的方法，所以无法调用。
通过对象多态性可以发现，子类发生了向上转型关系之后，所调用的全部方法
都是被覆写过得方法。
下面是通过子类为借口实例化的例子：
interface A{ //定义一个接口
public abstract void print(); //定义抽象方法
}
class B implements A{ //实现接口
@Override
public void print() { //覆写抽象方法
System.out.println("hello world!");
}
}
public class Test12 {
public static void main(String[] args) {
A a=new B(); //通过子类为接口实例化
a.print();
}
}
2. 抽象类的应用----定义模板
例子：
abstract class Person{
private String name; //定义name属性
private int age; //定义age属性
public Person(String name,int age){
this.name=name;
this.age=age;
}
public String getName() {
return this.name;
}
public int getAge() {
return this.age;
}
public void say(){ //人说话是一个具体的功能
System.out.println(this.getcontent()); //输出内容
}
public abstract String getcontent(); //说话的内容由子类决定
}
class Student extends Person{
private float score;
public Student(String name,int age,float score){
super(name,age);
this.score=score;
}
@Override
public String getcontent() {
return "学生信息-----》姓名:"+super.getName()
+"：年龄："+super.getAge()+
"：成绩："+this.score;
}
}
class Worker extends Person{
private float salary;
public Worker(String name,int age,float salary){
super(name,age); //调用父类中的构造方法
this.salary=salary;
}
@Override
public String getcontent() {
return "工人信息-----》姓名:"+super.getName()
+"：年龄："+super.getAge()+
"：薪水："+this.salary;
}
}
public class Test13 {
public static void main(String[] args) {
Person per1=new Student("michael",18,99.0f);
Person per2=new Worker("bob",40,3000.0f);
per1.say();
per2.say();
}
}
3. 接口的实际应用---制定标准
接口咋的实际应用就是制定标准，如果深入的话， 接口实际上还可以将方法的视图暴露给远程客户端。
接口实际应例子：
import java.util.concurrent.Callable;
//接口的实际应用---制定标准
interface USB{ //定义了USB接口
public void start(); //USB设备开始工作
public void stop(); //USB设备停止工作
}
class Computer{
public static void Plugin(USB usb){
usb.start();
System.out.println("=====usb设备工作=====");
usb.stop();
}
}
class Flash implements USB{
@Override
public void start() { //覆写方法
System.out.println("U盘开始工作。");
}
@Override
public void stop() {
System.out.println("U盘停止工作");
}
}
class Print implements USB{
@Override
public void start() {
System.out.println("打印机开始工作");
}
@Override
public void stop() {
System.out.println("打印机停止工作");
}
}
public class Test14 {
public static void main(String[] args) {
Computer.Plugin(new Flash());
Computer.Plugin(new Print());
};
}
4. 工厂设计模式
interface Fruit{
public void eat();
}
class Apple implements Fruit{
@Override
public void eat() {
System.out.println("吃苹果！");
}
}
class Orange implements Fruit{
@Override
public void eat() {
System.out.println("吃橘子！");
}
}
public class Test15 {
public static void main(String[] args) {
Fruit f =new Apple();
f.eat();
}
}
上述代码虽然没有语法错误，但是存在问题。
主方法应此时，应该就表示一个客户端，主方法的代码越少越好。此时，
直接在主方法中指定了要操作的子类，如果要更换子类，则肯定要修改
客户端。就表示跟特定的子类紧密结合在一起了。
JVM的工作原理：程序---->JVM----》操作系统。
此过渡端在程序中就称为工厂设计。
设计后：
interface Fruit{ //定义水果类
public void eat();
}
class Apple implements Fruit{
@Override
public void eat() {
System.out.println("吃苹果！");
}
}
class Orange implements Fruit{
@Override
public void eat() {
System.out.println("吃橘子！");
}
}
class Factory { //定义工厂类
public static Fruit getInstance(String className){
Fruit f=null;
if("Apple".equals(className)){
f=new Apple();
}
if ("Orange".equals(className)){
f=new Orange();
}
return f;
}
}
public class Test15 {
public static void main(String[] args) {
Fruit f =Factory.getInstance("Apple");
if (f!=null){ //判断是否取得实例
f.eat();
}
}
}
5. 设计模式----代理设计
interface Network{
public void browse(); //浏览
}
class Real implements Network{
public void browse(){
System.out.println("上网浏览信息");
}
}
class Proxy implements Network{
private Network network; //代理对象
public Proxy(Network network){
this.network=network;
}
public void check(){
System.out.println("检查用户名是否合法");
}
@Override
public void browse() {
this.check();
this.network.browse(); //调用真实的主题操作
}
}
public class Test16 {
public static void main(String[] args) {
Network net = null;
net = new Proxy(new Real()); //指定代理操作
net.browse(); //客户只关心上网浏览一个操作
}
}
6. 适配器设计
对于JAVA程序来说，如果一个类要实现接口，若子类不是抽象方法肯定要覆写
此接口的全部抽象方法，那么如果，此时一个接口中定义的抽象方法过多，但是
在子类中又用不到这么多抽象方法的话，则肯定很麻烦，所以此时就需要
一个中间国度，但是此过度类又不希望被直接使用，所以将此过度类定义成抽象
类最合适，即一个接口首先被一个抽象类（此抽象类通常称为适配器类），并在
此抽象类中实现若干方法（方法体为空），则以后的子类直接继承此抽象类，就
可以有选择的覆写所需要的方法。
例如：
interface Window{ //定义WINDOW接口，表示窗口操作
public void open(); //打开
public void close(); //关闭
public void activated(); //窗口活动
public void iconifiled(); //窗口最小化
public void deiconifiled(); //窗口恢复大小
}
abstract class WindowAdapter implements Window{
public void open(){}; //打开
public void close(){}; //关闭
public void activated(){}; //窗口活动
public void iconifiled(){}; //窗口最小化
public void deiconifiled(){}; //窗口恢复大小
}
class WindowImpl extends WindowAdapter {
public void open(){
System.out.println("窗口打开。");
}
public void close(){
System.out.println("窗口关闭。");
}
}
public class Test17 {
public static void main(String[] args) {
Window win=new WindowImpl();
win.open();
win.close();
}
}
7. 内部类的扩展
内部类中可以定义接口，同样接口中也可以定义内部类。
abstract class A{ //定义抽象类
public abstract void printA(); //抽象方法
interface B{ //定义内部接口
public void PrintB(); //定义抽象方法
}
}
class X extends A{ //继承抽象类
@Override
public void printA() {
System.out.println("hello --->A");
}
class Y implements B{ //定义内部类实现内部接口
public void PrintB(){
System.out.println("hello --->b");
}
}
}
public class Test18 {
public static void main(String[] args) {
A.B b=new X().new Y();
b.PrintB();
}
}
8. 抽象类和接口的区别