JAVA学习笔记(一)

1.       javap.exe，JAVA的反编译器，可以运行：javap  Point 使用方法类似于JAVA的解释器。

2.       new关键字的作用：

         为对象分配内存空间   引起对象构造方法的调用   为对象返回一个引用

3.this变量的使用：this对象代表对象本身   当类中有两个同名的变量，一个属于类（类的成员变量），而另一个属于某个特定的方法（方法中的局部变量）使用this区分成员变量和局部变量。

This简化构造函数的调用：

     一个类的所有实例（对象）调用的成员方法在内存中只有一份拷贝，尽管在内存中可能有多个对象，而数据成员在累得每个对象所在的内存中都存在一份拷贝。This变量允许相同的实例方法为不同的对象工作。每当调用一个实例方法时，this变量将被设置成引用该实例方法的特定的类对象。方法的代码接着会与this所代表的对象的特定数据建立关系。

3.       关键字static

静态方法和静态变量属于某一个类，而不是属于某个对象。（类方法，类对象）

静态方法和静态变量的引用直接通过类名引用。如object.method();

在静态方法中不能调用非静态的方法和引用非静态的成员变量，反之，则可以。

4.       调用this方法必须是第一条构造函数的第一条语句。

5.       final常量，JAVA中没有define语句，常量用final定义，而且在声明的时候初始化或者在构造函数中初始化，为了节省空间，常常将常量定义为静态的，必须在声明的时候初始化。static final  

6.       方法的覆盖(override),发生在父类和子类之间，父类和子类有一个相同的方法，子类的对象调用会覆盖父类的方法，而直接调用子类的方法。

7.       super调用，可以用它调用父类的方法，解决覆盖的问题，而且子类的构造方法隐含的调用父类的构造方法,super(),而且每个子类的构造方法都调用super().如果父类没有这个方法，那么编译会报错。

8.       多态性，通过覆盖父类的方法，在运行时根据传递的对象引用，来调用相应的方法。把子类的引用赋值给父类的一个对象，调用的过程为，如果子类有相应的方法，则调用子类的方法，如果子类没有这个方法，则调用父类的方法。

9.       instanceof关键字，可以判断一个对象是不是一个类的实例，例如  fn instanceof Object ，返回值非零为真，零为假。

10.   package 的使用

自己引入包，package a  在程序的第一句，这样编译的时候要按照层次编译，即 javac – d . Test.java      java  a/Test

11.   abstract方法：如果一个类有一个抽象方法，那么这个类必须被声明为抽象类。抽象类不能实例化，即不能声明对象，但是可以被继承，派生类必须实现抽象类的所有方法，如果有一个方法没有实现，那么这个派生类也应该被声明为抽象类，否则编译出错。

12.   final：final声明的方法，在子类中不能够被override，保证了父类的方法的唯一，final的方法类似于声明为static和private的方法。static和private的方法就是final方法。编译器会判断是否对fianl方法进行优化，而不是一定要优化，当方法的体积比较小时，我们会声明为final方法，这也是编译器判断的一个依据。

13.   interface 接口定义了方法，但是没有实现过程，接口中的方法都是缺省为public abstract 这样实现类 必须全部实现接口的方法，而且访问的权限必须比它高，只能为public，而且必须全部实现，否则编译报错，改类必须声明为抽象类。 

接口中的成员的缺省为public static abstract 在接口的实现类中，可以用接口名调用，也可以用类名，对象名引用这个成员。

一个接口可以继承多个接口，一个类可以实现多个接口，可以在继承另一个类的同时实现多个接口。

接口的使用：

例：显卡的接口，显卡厂商要按照接口的标准，实现接口的全部方法；主板厂商要调用这个接口中的方法。

14．内部类：在类中定义另一个类，则这个定义在内部的类称为内部类，内置类。内部类可以访问外部类的所有成员变量以及成员方法。内部类隐含了一个访问外部类的引用:OUTER.this引用。就像每个类都有this引用一样。

   内部类可以放到一个语句块中，函数中，而且都可以访问外部类的成员变量，但是它的使用范围就缩小了。若将内部类放到一个方法当中，那个这个方法当中的变量必须声明为final，而且要初始化。内部类才能够访问。如果不访问，可以不用声明为final

   创建内部类的对象：Outer.Inne I r=outer.new Inner()//outer是Outer的对象

   内部类相当于成员方法一样，可以有访问限制符：public default protected private   anstract final(不能被继承) static(就不能访问外部类的非静态的成员变量和非静态的成员方法了，如果声明为静态的了，那么就是相当于类方法或者类变量了，那么就可以用类名直接调用。如果内部类不是static那么它内部就不能定义静态的方法或者静态的成员变量。)

   继承一个内部类，这个派生类的实例化过程：（先有外部类对象，建立一个内部类到外部类的关系）CAR.SUPER()

//一个如何从内部类派生

class A

{

       class B

       {

       }

}

class C extends A.B

{

  C(A a)//将内部类与外部类建立引用关系

       {

              a.super();

       }

}

class D

{

       public static void main(String [] args)

       {

              A a1=new A();

              C c =new C(a1);

              A.B b=a1.new B();

 // C c =new C();//提示出错，需要一个A.B的实例，要创建内部类的实例

       }                //首先要有一个外部类的对象可以通过构造函数

}

   内部类可以用于创建适配器类，适配器类用于实现接口的类。可以很好的隐藏实现的细节。例如把内部类来实现一个接口，而这个内部类是私有的类，在其他类中不能够实现它的对象，那么可以通过实例化一个对象指向那个私有的内部类。这样就可以访问内部类以及外部类的所有方法和成员变量了。

匿名的内部类：

//用内部类实现接口

interface Animal

{

       void sleep();

       void eat();

}

//动物园内有各种动物

class Zoo

{

private class Tiger implements Animal

       {

              public void sleep()

              {

                     System.out.println("Tiger Sleep");

              }

              public void eat()

              {

                     System.out.println("Tiger Eat");

              }

       }

/*    Animal getAnimal()

       {

              return new Tiger();

       }*/

       Animal getAnimal()

       {

       //     return new Animal();//错误，接口不能直接实现一个对象，只有当接口中的函数

                                  //全部实现之后才可以,所以使用一个匿名的内部类

           return new Animal()

           //class AA//相当与一个匿名类

           {

                  public void sleep()

                  {

                         System.out.println("Animal Sleep");

                  }

                  public void eat()

                  {

                         System.out.println("Animal eat");

                  }

           };//;不能丢

       }

}

class Test

{

       public static void main(String [] args)

       {

              Zoo zoo=new Zoo();

              Animal an=zoo.getAnimal();

              an.sleep();

              an.eat();

       }

}

//一个类继承一个类，实现一个接口，而这个抽象类和接口中有一个相同的函数，但是他们表示的意思又不同。可以用内部类实现这个接口。

interface Machine

{

       void run();

}

class Person

{

       void run()

       {

              System.out.println("run");

       }

}

class Robort extends Person

{

       class MachineHeart implements Machine

       {

              public void run()

              {

                     System.out.println("heatr run");

              }

       }

       Machine getMachine()

       {

              return new MachineHeart();

       }

}

class Test

{

       public static void main(String [] args)

       {

              Robort robort =new Robort();

         Machine m=robort.getMachine();

         m.run();

         robort.run();

}

}

15．异常

Try catch finally

可以在可能发生异常的函数的定义后面抛出异常 如 void fn()throw Exception  这个异常是抛给了这个函数的调用者，即调用这个函数的代码处。这个异常必须被声明或者捕获。如果这个调用函数继续不想声明或者捕获，它可以再声明为抛出异常，这样这个异常又抛给了它的上一级调用，如果到了main()函数再抛出异常了，那么这个函数就被抛到系统，然后打印出这个异常的运行轨迹，然后终止程序的执行，有时为了节省直接在main函数抛出异常。如果你要抛出的异常正好就是程序执行时候产生的异常，这样编译器就不会报错了。捕获异常可以在函数内部写，而且这个异常必须与抛出的异常同名，而且catch语句可以有多个不同类型的异常。但是执行代码的时候如果具体的异常捕获在catch语句中，那么就捕获它，而且要写在Exception之后，因为Exception包含了所有的异常。

程序在执行的时候抛出(throws)异常，产生一个异常类的对象，然后捕获这个对象，返回到产生异常的代码，如果这个异常没有被捕获到，程序停止执行。

程序编写的错误，不需要捕获（throw），这是程序运行时自动抛出，自动处理的。

父类可以抛出多个异常，子类要么与父类的异常相同要么是它的异常的子类，但是不能有新的异常，但是构造函数除外。

If(b==0)throw  new Exceptin(“dddddd”);//构造函数

 

class Except

{

       int Divition(int a,int b)

       {

              return a/b;

       }

 

}

class Text

{

              public static void main(String []args)

       {

              Except a=new Except();

              try

              {    

              System.out.println("try");

              a.Divition(5,0);

 

              }

       catch(Exception e)

       {

//            System.out.println(e.getLocalizedMessage());//异常的详细信息

//            System.out.println(e.getMessage());

//            System.out.println(e.toString());

      e.printStackTrace() ;//异常的轨迹，从何处开始异常，传播到何处等等

       }

       }

}