java中的类和接口 java中类名和接口名

接口：

[修饰符] 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 static 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 

静态内部类（在内部类前添加修饰符static，这个内部类就变为静态内部类。静态内部类中可以声明static成员，但是在非静态内部类中不可以声明静态成员。因开发中不常使用，这里就不总结了。）