内部类：

类的继承：一个子类只能继承一个父类，子类又可以被子类继承没有限制（多重继承）。子类继承父类的所有方法与属性(不能继承父类的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");

               }

        });

   } 

}

Java学习笔记（二）