JAVA学习笔记(一)

1.       javap.exeJAVA的反编译器,可以运行: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.   finalfinal声明的方法,在子类中不能够被override,保证了父类的方法的唯一,final的方法类似于声明为staticprivate的方法。staticprivate的方法就是final方法。编译器会判断是否对fianl方法进行优化,而不是一定要优化,当方法的体积比较小时,我们会声明为final方法,这也是编译器判断的一个依据。

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

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

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

接口的使用:

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

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

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

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

   内部类相当于成员方法一样,可以有访问限制符: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() ;//异常的轨迹,从何处开始异常,传播到何处等等

       }

       }

}

 
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值