内部类，类修饰符，上转型对象，多态，接口回调

内部类：

java支持在一个类中声明另一个类，这样的类称之为内部类，而包含内部类的类称为外部类。

内部类的使用方法：可以访问外部类的成员变量和方法。但不可以在自己的类体中声明类变量和类方法。

外部类使用内部类：外部类要想使用内部类里的方法，是通过实例化内部类的对象，然后通过外部类的对象去调用内部类的对象的成员变量和方法。

如果我在main函数中，执行

Tree tree=new Tree();

就会出现no enclosing instance of type TT is accessible. Must qualify the allocation with an enclosing instance of type TT问题。（原因）解决方法：把Tree声明为static的就可以了。

不过使用的时候，最好还是通过外部类使用内部类的方法去用，如下：

TT tt=new TT();
tt.tree.ff();/

完整调用格式：

public class TT {
Tree tree;
int val;
void f1(){

}
class Tree{//内部类
int value;
void ff(){
val=2;//内部类中是可以访问外部类的成员变量的。
f1();//内部类也可以调用外部类的方法。
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
TT tt=new TT();
tt.tree.ff();//通过外部类的对象，来访问内部类对象里面的变量和方法；
tt.tree.value=1;

}

}

类修饰符：

普通类前面可以有public，友好，abstract，final修饰符。类不能被protected和private修饰。

public：公共类。可以在任何另外一个类中(任何包)，使用该类创建对象。

友好：友好类。只能在同一包中，用该类创建对象

abstract：抽象类。内部可以有抽象方法，继承时，父类中的抽象方法必须在子类中重写，故抽象方法不能被final修饰。抽象类除可含有抽象方法外，其余和普通类相似，也可被public、友好修饰，相当于公共抽象类，友好抽象类。但不能被final修饰，因为该类还要被继承重写；也不能用new创建该类的对象；另外子类继承抽象类时不能降低方法的访问权限。子类不能继承父类中的构造方法。

final：final类不能被继承，即不能有子类。java中的String就是final类，不能被改变。final修饰方法，表示这个方法不能被重写，final修饰成员变量，就是常量，java中常量必须赋给其初值，不能在改变。final修饰方法的参数时，该参数值不能在该函数体中被改变，只于传参的函数传参值有关。

对象的上转型对象：

上转型对象必须存在继承，把子类创建对象的引用赋给父类的对象。上转型对象特点：

父类A，子类B：

A a=new B();
或
A a;
B b=new B();
a=b;

多态：

父类中的某个方法被子类重写时，可以产生各自的功能行为。

接口回调

接口：多继承时使用。类实现接口时，必须重写接口的全部方法。接口和类类似，有接口的声明和接口体。接口中的方法都是抽象方法，且默认都是pubic abstract形式。所以在类实现接口时，类中实现接口的方法必须加public修饰(不降低访问权限原则)。接口中无变量，全是常量，默认用public stactic final修饰。

inteface A{
int a=100;//缺省public static final修饰，常量必须赋初值。
int f();//缺省public abstract修饰，必须在类中重写。
}

接口可以被public和友好修饰，这点和普通类相同，都是同包的问题

如果父类实现了接口，那么继承该父类的子类不必在使用关键字implements声明自己使用这个接口

接口可以被接口继承，是继承全部的方法和常量。

如果一个类实现了一个接口，却没有实现接口中的所有方法，该类必为抽象类。

接口回调：把实现某接口的类创建的对象的引用赋给该接口声明的接口变量，那么该接口变量可以调用被类实现的接口中的方法。

iterface A{
void f();
}
class B implements A{
public void f(){
system.out.println("haha")
}
}
pulic class C{
pubic static void main(String[]args){
A a;
a=new B();
a.f();
}
}
//输出haha

接口做参数：某方法参数是接口类型，那么可以将实现该接口的类对象的引用传递给该接口参数，此时该接口参数可以回调该类实现的接口中的方法。

“`

iterface A{

void f();

}

class B implements A{

public void f(){

system.out.println(“haha”)

}

}

class D{

pubic void g(A a1){

a1.f();

}

}

pulic class C{

pubic static void main(String[]args){

D d=new D();

d.g(new B());

}

}

//同样输出haha