抽象类语法
◆抽象类和抽象方法必须使用 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静态方法可以类名调用和对象调用；如果都在同一类体忠，可以直接类名调用
