接口：
[修饰符] interface 接口名 [extends 父接口名1，父接口名2，...]{
[public] [static] [final] 类型 变量；
[public] [abstract] 方法；
}
修饰符，可选参数，用于指定接口的访问权限，可选值为public。如果省略则使用默认的访问权限。
接口名，必选参数，用于指定接口的名称，接口名必须是合法的java标示符。一般首字母大写。
extends父接口名列表，可选参数，用于指定要定义的接口继承于哪个父接口。当使用extends关键字时，父接口名为必选参数。
方法，接口中的方法只有定义而没有被实现。
eg:
public interface Calculate{
float pi = 3.14;
float getArea(float r);
}
等价于：
public interface Calculate{
public fianl float pi = 3.14;
public abstract float getArea(float r);
}
接口的实现：
[修饰符]class 类名 [extends 父类名] [implements 接口列表]{
}
修饰符，可选参数，用于指定类的访问权限，可选值为public、abstract、final。
类名，必选参数，用于指定类的名称，类名必须是合法的java标示符。一般情况下，首字母大写。
extends 父类名，可选参数，用于指定要定义的类继承于哪个父类。当使用extends关键字时，父类名为必选参数。
implements 接口列表，可选参数，用于指定该类实现的是哪些接口。当使用implements关键字时，接口列表为必选参数。当接口列表中存在多个接口名时，各个接口名之间使用逗号分隔。
eg:
public interface Calculate{
float pi = 3.14;
float getArea(float r);
}
public class Circle implements Calculate{
public float getArea(float r){
return pi * r * r;
}
}
继承的实现：
[修饰符] class 子类名 extends 父类名{
}
修饰符，可选参数，用于指定类的访问权限，可选值为public、abstract、final。
子类名，必选参数，用于指定子类的名称，类名称必须是合法的java标示符。一般情况下，首字母大写。
extends 父类名，必选参数，用于指定要定义的子类继承于哪个父类。
eg:
public class Bird{
protected String color;
protected String skin;
}
public class extends Bird{
public void fly(){
}
}
抽象类：
abstract class 类名{
}
eg:
public abstract class Fruit{
protected String color;
public Fruit(){
color = "green";
}
}
抽象方法(不能使用private或static关键字修饰，因为要在子类中重写，不能用类名直接调用方法)
abstact <方法返回值类型> 方法名（参数列表);
eg:
public abstract class Fruit{
protected String color;
public Fruit(){
color = "green";
}
public abstract void harvest();
}
成员内部类(内部类只能在外部类中使用，一般作为外部类的成员变量，内部类的实例化操作必须在外部类或外部类中的非静态方法中；内部类可以访问外部类成员)
public class OuterClass{
private class InnerClass{
}
}
eg:
public class OuterClass{
private int i = 0;
private void g(){
}
private InnerClass{
void f(){
g();
i++;
}
}
}
局部内部类(在类的方法中定义的类，他得作用范围也是在这个方法体内)
eg:
public class SellOutClass{
private String name;
public SellOutClass(){
name = "apple";
}
public void sell(double price){
class Apple{
double price;
public Apple(double price){
this.price = price;
}
public void price(){
System.out.println("现在开始卖" + name);
System.out.println("单价为:" + price);
}
}
Apple a = new Apple(price);
a.price();
}
}
匿名内部类(匿名内部类也就是没有名字的内部类，正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写；但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口)
eg1:不使用匿名内部类来实现抽象方法
public abstract class Person {
public abstract void eat();
}
public class Child extends Person {
public void eat() {
System.out.println("eat something");
}
}
public class Test {
public static void main(String[] args) {
Person p = new Child();
p.eat();
}
}
运行结果：eat something
可以看到，我们用Child继承了Person类，然后实现了Child的一个实例，将其向上转型为Person类的引用.但是，如果Child类只使用一次，那么将其编写为独立的一个类有些浪费。这个时候就引入了匿名内部类。
eg2：匿名内部类的基本实现
public abstract class Person {
public abstract void eat();
}
public class Test {
public static void main(String[] args) {
Person p = new Person() {
public void eat() {
System.out.println("eat something");
}
};
p.eat();
}
}
运行结果：eat something
可以看到，我们直接将抽象类Person中的方法在大括号中实现了，这样便可以省略一个类的书写；并且，匿名内部类还能用于接口上。
eg3：在接口上使用匿名内部类
public interface Person {
public abstract void eat();
}
public class Test {
public static void main(String[] args) {
Person p = new Person() {
public void eat() {
System.out.println("eat something");
}
};
p.eat();
}
}
运行结果：eat something
由上面的例子可以看出，只要一个类是抽象的或是一个接口，那么其子类中的方法都可以使用匿名内部类来实现;当然一般类的子类也可以使用匿名内部类来实现。
最常用的情况就是在多线程的实现上，因为要实现多线程必须继承Thread类或是继承Runnable接口。
eg4：Thread类的匿名内部类实现
public class Test {
public static void main(String[] args) {
Thread t = new Thread() {
public void run() {
for (int i = 1; i <= 3; i++) {
System.out.print(i + " ");
}
}
};
t.start();
}
}
运行结果：1 2 3
eg5：Runnable接口的匿名内部类实现
public class Test {
public static void main(String[] args) {
Runnable r = new Runnable() {
public void run() {
for (int i = 1; i <= 3; i++) {
System.out.print(i + " ");
}
}
};
Thread t = new Thread(r);
t.start();
}
}
运行结果：1 2 3
版权声明：本文为博主原创文章，未经博主允许不得转载。