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() ;//异常的轨迹，从何处开始异常，传播到何处等等
}
}
}
扫一扫
2323
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
