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() ;//异常的轨迹,从何处开始异常,传播到何处等等
}
}
}