Java——抽象类、接口

body, table{font-family: 微软雅黑; font-size: 10pt}
table{border-collapse: collapse; border: solid gray; border-width: 2px 0 2px 0;}
th{border: 1px solid gray; padding: 4px; background-color: #DDD;}
td{border: 1px solid gray; padding: 4px;}
tr:nth-child(2n){background-color: #f8f8f8;}

抽象类语法

◆抽象类和抽象方法必须使用  abstract  声明。

◆抽象方法不能有方法体。

◆抽象类不一定有抽象方法，但是含有抽象方法的类必须是抽象类。

◆抽象类本身不能实例化(但是多态机制可以用子类实例化）。

◆抽象类的子类：

       如果不想重写抽象类里面的抽象方法，则也必须是抽象类

        如果不是抽象类，则必须实现抽象父类的所有抽象方法

◆被abstract修饰的类称为抽象类，被abstract修饰的方法称为抽象方法。

◆抽象类不能被实例化，即不能使用抽象类的构造函数创建对象，抽象类中可以声明抽象方法，除此以外抽象类与一般的类没有区别。

◆抽象类只定义了类的部分行为，这些行为是子类共有的，其它行为由子类实现的抽象方法提供，因此抽象类通常作为一个框架，把子类将实现的抽象方法组织起来，简化或限制子类的设计

抽象类的成员特点：

◆抽象类的成员变量：即可以变量，又可以是常量

◆抽象类的构造方法：用于子类访问父类数据的初始化

◆抽象类的方法：可以是抽象的，也可以是非抽象的，作用是：

        抽象的：强制子类实现

        非抽象的：子类可以复用

---

接口的定义：//接口往往用来描述一种功能，而不是一种类别；     接口可以理解为一个特殊的类，只有常量和抽象方法组成的特殊类

◆接口是用来实现类间多重继承功能的结构。

◆通过接口可以实现不相关类的相同行为，而不需考虑这些类之间的层次关系

◆通过接口可以指明多个类需要实现的方法

◆接口中所有的方法默认都是 public abstract 的

◆接口中的成员变量默认都是 public static final 的

◆接口可以继承多个接口，但不能继承类

 一个完全抽象的类，所有的方法都是抽象方法

特点：

◆接口使用 Interface 关键字进行声明

       格式：Interface 接口名 {  }

◆类实现接口使用 implements 表示

       格式： class 类名 implements 接口名{ }

◆接口无法直接实例化

       如何实例化？由其具体的子类实例化

◆接口的子类

       要么是抽象类

       要么重写接口中所有的抽象方法

---

单亲继承与多亲继承：

◆Java语言中，类(Class)只支持单亲继承，一个类只能有唯一的父类

◆Java语言中，接口(Interface)可支持多亲继承，一个接口可以有多个父接口，子接口拥有所有父接口中声明的方法

◆接口中可以声明以下成员：

    (1) 成员

    (2) 方法

◆接口中的成员都是public的，不能指定其它的访问控制修饰符

◆接口中的成员变量默认是 static final 的，必须显式初始化

◆接口中的方法只能提供方法头声明，不能提供实现，且除abstract外，不能使用其它修饰符

接口的继承：

◆接口支持多亲继承，可以在关键字extends后面跟多个接口的列表，中间用逗号隔开，如：

public interface SerializableRunnable                 extends java.io.Serializable, Runnable     { …… } interface IA{     void ma();     void mb(); } interface IB extends IA{     void mb();     void mc(); } class CA implements IB{     public void ma(){ … }     public void mb(){ … }     public void mc(){ … } } abstract CB implement IB{     public void ma(){ … }     public void mc(){ … } }

interface X{     int val=1; } interface Y extends X{     int val=2;     int sum=val+X.val; } interface CardDealer{     void draw();     void deal();     void shuffle(); } interface GraphicalComponent{     void draw();     void draw(Device d);     void rotate(int degrees);     void fill(Color c); } interface GraphicalCardDealer extends GraphicalComponent, CardDealer{     …… }

◆子接口拥有所有父接口中声明的方法

◆子接口中的域将隐藏父接口中声明的同名域，被隐藏的父接口中的域必须通过父接口名访问

◆要定义接口的实现类，需在类头中使用关键字

接口中的方法覆盖和重载：

◆接口中的方法可以重载(Overload)，可以声明方法名相同但签名不同的多个方法(包括父接口中的方法)

◆接口中的方法也可以覆盖(Override)，但没有实际的意义，因为接口中不提供方法的实现

---

◆可以定义一个接口用extends关键字去继承一个已有的接口

◆可以定义一个类用implements关键字去实现一个接口中的所有方法

◆可以去定义一个抽象类用implements关键字去实现一个接口中定义的部分方法。

◆一个类可以继承一个父类的同时，实现一个或多个接口，extends关键字必须位于implements关键字之前 。

实现一个接口就是要实现该接口的所有方法（抽象类除外）

接口中的方法都是抽象的

多个无关的类可以实现同一个接口

一个类可以实现多个无关的接口

java反射技术:

public static void main(String[] args) {         Test test = new Test();         System.out.println(test.getClass().getSimpleName());     } } 运行结果：Test

import java.lang.reflect.Method; public class Test {     public void invoke(){     }     public static void main(String[] args) {         Test test = new Test();         Class clazz = test.getClass();         Method[] methods = clazz.getDeclaredMethods();   //返回类class所指定的方法，方法没在形参表声明，参数什么都没有，就返回所有无参的放法数组         for(Method method:methods){             System.out.println(method.getName());         }     } } 运行结果： invoke                  main

/*已知每种交通工具的参数都是3个整数A、B、C的表达式。 现有两种工具：Car 和Plane， 其中Car 的速度运算公式为：A*B/C， Plane 的速度运算公式为  ：A+B+C。 需要编写三类：ComputeTime.java,Plane.java,Car.java和接口Common.java. 要求在未来如果增加第3种交通工具的时候，不必修改以前的任何程序，只需要编写新的交通工具的程序。 其运行过程如下，从命令行输入ComputeTime的四个参数，第一个是交通工具的类型，第二、三、四个参数分别时整数A、B、C， 举例如下：      计算Plane的时间：”java ComputeTime Plane 20 30 40″ 计算Car007的时间：”java ComputeTime Car  23 34 45″ 如果第3种交通工具为Ship,则只需要编写Ship.java，运行时输入：”java ComputeTime Ship 22 33 44″*/ package com.java.zuoye7; public interface Common {         public double speed(double a,double b,double c); } package com.java.zuoye7; public class Car implements Common{         public double speed(double a,double b,double c){                 return a*b/c;         } } package com.java.zuoye7; public class Plane implements Common{         public double speed(double a,double b,double c){                 return a+b+c;         } }

package com.java.zuoye7; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; public class ComputeTime {         public static void main(String[] args) {                 try {                         System.out.println("我进来了");                         Class cl = Class.forName("com.work07."+args[0]); //static Class<?> forName(String className) // 返回与带有给定字符串名的类或接口相关联的 Class 对象。                         Object obj = cl.newInstance(); //创建此 Class 对象所表示的类的一个新实例。                         Method m = obj.getClass().getDeclaredMethod("speed", double.class,double.class,double.class);   //double.class  返回double所属的类对象Class<double> //Class<?> getClass() 返回此 Object 的运行时类;就是返回obj具体属于哪个类的类名 //Method getDeclaredMethod(String name, Class<?>... parameterTypes) // 返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法。参数指明了哪个方法，有什么参数                         double a  = Double.parseDouble(args[1]); // 程序运行参数传参都默认的是String // static double parseDouble(String s) // 返回一个新的 double 值，该值被初始化为用指定 String 表示的值，这与 Double 类的 valueOf 方法一样。                         double b  = Double.parseDouble(args[2]);                         double c  = Double.parseDouble(args[3]);                         double speed = (double)m.invoke(obj, a,b,c); // Object invoke(Object obj, Object... args) // 对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。                                 double time = 1000/speed;                         System.out.println("the time of "+args[0]+"run 1000 kilometers is "+time);                 } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException e) {                         e.printStackTrace();                 }         } }

Java静态方法可以类名调用和对象调用；如果都在同一类体忠，可以直接类名调用