标签：
内部类：
类的继承：一个子类只能继承一个父类，子类又可以被子类继承没有限制（多重继承）。子类继承父类的所有方法与属性(不能继承父类的private方法和属性)。
子类的实例化：首先子类的对象在堆中分配内存，初始化，然后对形参进行赋值，执行构造函数，执行构造函数时判断有无this调用其它的构造函数，若有则执行下去直到顶层，之后直接跳转到子类当前部分，接着执行显示初始化，最后执行子类构造函数自身的代码。若没有this构造函数，则执行super继承的构造方法，直至object类（object类是所有类的顶层父类），之后直接跳转到子类当前部分，接着执行显示初始化，最后执行子类构造函数本身的代码。Super关键字用于表示继承父类的构造方法，写在子类的每个构造方法中，若没有写则默认为super()；此时即继承父类的public 类名(){}，若父类中此时又恰巧没有public 类名(){}，则会报错。若写了super(….);则表示继承父类中的public 类名(…){…}。This和super调用语句不能同时出现在同一个构造方法中，且this()或super()调用语句只能作为构造函数中的第一句出现。
方法重载：在子类中重写的方法名字和父类一致，且只能把方法的访问权限变强即子类中该方法的开放性比父类强。以super.的形式访问父类中的方法。
Final关键字：相当于定义常量；final修饰的类不能被继承，父类中final修饰的方法不能被重载；final修饰的成员变量的初始化只能在两处，一是定义成员变量的时候如public final String name=”hdjfg”;二是在构造方法中，注意要在每一个构造方法中都做初始化；若再加上static修饰，则此时初始化只能在定义的时候而不能再在构造方法中了（构造方法只有在创建了对象时才会执行，而static修饰的常量则没有要求一定要有对象）。
抽象方法：一些不含方法体的方法，根据。抽象类、抽象方法必须用关键字abstract修饰。抽象方法只需声明不需要实现，抽象类不能实例化。含有抽象方法的类必须被声明为抽象类，抽象类的子类必须覆盖所有的抽象方法后才能实例化，否则依然为抽象类。
Abstract class A
{
Public Int age
Abstract int aa(int x,int y);
Public void bb(int age)
{
}
}
Class B extends A
{
Int aa(int x,int y)(return 2;)//此处重写了父类的抽象方法故该子类不是抽象类了
Public static void main(String[] args)
{
}
}
接口interface：接口可以理解为一种特殊的抽象类，这种抽象类中只包含常量和方法的定义二没有变量和方法的实现。接口中的成员都是public访问类型的，变量都是常量（默认省略public static final），成员方法都是抽象方法（即省略public abstract）；可以定义一个新的接口去继承另外一个已有的接口；可以定义一个类用implements关键字去实现一个接口中的所有方法，也可以定义一个抽象类用implements去实现一个接口中定义的部分方法，代码如下。一个类可以继承一个父类的同时实现一个或者多个接口，extends关键字必须位于implements关键字之前。
interface Runner
{
int ID=3;
//此处ID省略public static final
void run();
//此处省略public abstract，成员变量和方法都默认为public
}
interface Animal extends Runner
{
void breathe();
//此处同时继承了Runner中的方法和变量
}
interface Flyer
{
void fly();
}
class Landanimal
{
}
class bird implements Animal
{
public void run()
{
System.out.println("bird is flying");
}
public void breathe()
//继承重写方法时访问权限要更强public
//若此处没有重写breathe方法，则默认继承接口
//中breathe，此时该类必须声明为抽象类
{
System.out.prnitln("bird is breathing");
}
}
class bird1 extends Landanimal implements Flyer,Runner
//此处extends必须在implements前面
{
}
对象的类型转换：对象转换并没有改变它的本质内容内存等，只是改变了声明而已。
class A
{
public void fun1()
{
System.out,println("A is calling");
}
public void fun2()
{
fun1();
}
}
class B extends A
{
public void fun1()
{
System.out.println("B is calling");
}
public void fun3()
{
System.out.println("B fun3 is calling");
}
}
class C
{
public static void main(String[] args)
{
B b=new B();
callA(b);//子类能够自动转换为父类
//A a=b;
//callA(new B());
}
public static void callA(A a)
{
if(a instanceof B)
//判断传过来的a是否是B的实例，是就执行
{
B b=(B)a;
//强制将父类A a转换为子类
b.fun1();
b.fun2();
b.fun3();
}
a.fun1();
a.fun2();
/* a.fun1();
a.fun2();
a.fun3();
若callA方法改成这样会报错，因为a里面没有fun3方法。但是若再把a.fun3()去掉，则不会报错，但此时涉及到多态。即a.fun1()是执行传过来的子类的fun1()，由于子类中没有重写fun2()，故a.fun2()执行的事父类中的fun2()，但是父类中调用的fun1()是子类中的fun1()。
*/
}
}
如果一个类没有说明继承哪个类那它默认继承object类，object类中有一个方法叫equals它是比较两个类的内容（成员变量的值）
代码如下：
class Animal
{
public int age;
public String name;
public Animal(String name,int age)
{
this.age=age;
this.name=name;
System.out.println(this.name+this.age);
}
public static void main(String[] args)
{
Animal A=new Animal("luo",20);
Animal B=new Animal("hao",30);
if(A.equals(B))
{
System.out.println("相等");
}
else
{System.out.println("不相等");}
}
}
匿名内部类：如下代码
interface PCI
{
void start();
void stop();
}
class MainBoard
{
public void usePCICard(PCI p)
{
p.start();
p.stop();
}
}
class Animal
{
public static void main(String[] args)
{
MainBoard mb=new MainBoard();
//PCI相当于抽象类是不能实例化的，故此处
//的意义等于产生一个实现PCI接口类的对象
//class F implement PCI{...}
mb.usePCICard(new PCI()
{
public void start()
{
System.out.println("start");
}
public void stop()
{
System.out.println("stop");
}
});
}
}
标签：
原文地址：http://www.cnblogs.com/luoh/p/4266550.html
