Java学习笔记-摘自nourl

关于对象

= = 表示引用的变量的值是否相等

equal() 表示对象的内容是否相同

String str1 = new string("abc");

String str2 = new string("abc");

Str1==str2 返回的是false

 

关于构造方法

P1 = new person(string name,int age);

当new一个对象时，第一步是在堆中申请空间，第二步并不是执行构造方法中的赋值，而是先执行显示的变量赋值，将name age 的值置为显示赋值的值，第三步才是执行构造方法中的函数赋值

 

关于this

this关键字在java程序里的作用和它的词义很接近，它在函数内部就是这个函数所属的对象的引用变量。

个人理解：this就是指代调用自己的那个对象，因为在编写方法的时候并不知道将来会是哪个对象调用自己，所以如果在自己这个方法中想调用其他的方法，无法确定“对象.方法”中的对象，设计this指针实现这一点。自己运行的时候一定是有一个对象存在的，调用自己的那个对象就是this

 

同一个类中，一个成员方法可以直接调用同类的另一个成员方法，省略this，这也是可以的

{

…………

Void fun1(){}

Void fun2(){

Fun1();

}

…………

}

有些情况非用this不可，例如：

A 构造函数 public person(string name){

this.name = name; //防止参数和成员变量重名；

}

B可以在一个构造方法里调用其他重载的构造方法，不是用构造方法名，而是用this(参数列表)的形式，根据其中的参数列表，选择相应的构造方法。

C 特殊调用情况

 

关于垃圾回收

c++中的析构方法

释放对象在生成中占用的资源

java中的finalize()方法

对象被彻底清除之前被调用，垃圾回收器是不能控制的。

Public void finalize() 是被自动调用的，但不一定什么时候调用。

System.gc（）的作用 垃圾回收器

指派垃圾回收器收回垃圾

 

每个类中都有一个equals方法和finalize方法

 

不管构造方法还是析构方法 在调用这个方法时，对象还是存在的。否则怎么调用对象的方法呢？！

 

 

关于函数参数传递

直接传递成员给change函数，change函数改变成员的值，不会对对象中的成员有任何影响

如果直接传递对象给change，改变对象中的值时有影响，因为传递对象的名字，等于传递了堆中变量的地址，被两个句柄引用。

 

关于static 静态方法

编写一个类的本质是什么？是描述这个类的对象一般具有的的属性和方法！

 

Static方法：无论是否产生了对象或无论产生了多少对象的情况下，某些特定的数据在内存空间里只有一份，可以使用static方法，这个方法所有的对象共享内存的一份拷贝，在内存中却只有一份。

注意：

1. 静态方法只能调用该类中的静态变量（包括成员和方法），不能调用非静态的变量。这是因为静态方法的使用不需要声明一个对象，而非静态的变量在使用之前必须指定一个对象
2. 静态方法中不能使用this和super，道理同上
3. Main方法是静态的，因为JVM在调用main的时候不需要他的所属对象到底是谁，同理，main中调用类中的非静态方法时，必须先有一个对象，使用该对象才可以调用类中的非静态变量。
4. 一个类中可以使用不包含在任何方法体中的静态代码块(static block )，当类被载入时，静态代码块被执行，且只被执行一次，静态块经常用来进行类属性的初始化。
5. 类中的静态代码块被自动执行，尽管我们产生了类的多个实例对象，但其中的静态代码块只被执行了一次。当一个程序中用到了其他的类，类是在第一次被使用的时候才被装载，而不是在程序启动时就装载程序中所有可能要用到的类。-------》通过这一点可以推测到，在java程序的import语句中导入的任何包和类，只有被使用了才会被编译到代码模块中，而不是import的包和类都被编译！

 

 

关于内部类

内部类可以使用外部类的变量，包括private类型的变量；但是，外部类不能使用内部类的变量

内部类的好处：

1.代码紧凑，模块化强！

2.例如 类A调用类B的对象，调用的过程中类B又需要得到类A的成员变量，如果写成两个类，两个类之间的参数传递很麻烦！！用内部类很简单！！

 

注意：

1 如果内部类定义为static类型的，那么它相当于一个外部类，static的内部类中可声明static成员，但是，非static的内部类中的成员是不能声明为static的。

2 在内部类对象保存了一个对外部类对象的引用，当内部类的成员方法中访问某一变量时，如果在该方法和内部类中都没有定义过这个变量，内部类中对this的引用会被传递给那个外部类对象的引用

3 如果函数的局部变量（函数的形参也是局部变量），内部类的成员变量，外部类的成员变量重名，我们应该按下面的程序代码所使用的方式来明确指定我们真正要访问的变量。

public class Outer

{
private int size;
public class Inner

{
private int size;
public void doStuff( int size)

{
size++; // 引用的是doStuff函数的形参

this.size++; //引用的是Inner类中的成员变量

Outer.this.size++; // 引用的Outer类中的成员变量

}

}

}

4.在方法中定义的内部类只能访问方法中的final类型的局部变量，不能访问方法中的普通局部变量，用final定义的局部变量相当于是一个常量，它的生命周期超出方法运行的生命周期。在类中定义的局部变量，编译器可以自动初始化，但在方法中定义的局部变量，编译器是不可以进行初始化的，必须由程序员手工进行初始化。

 

内部类被外部类引用的例子

class Outer

{

private int size=10;

public class Inner

{

public void doStuff()

{

System.out.println(++size);

}

}

}

public class TestInner

{

public static void main( String[] args)

{

Outer outer = new Outer();

Outer.Inner inner = outer.new Inner();

inner.doStuff();

}

}

 

注意：在一个类中需要实例化另一个类的内部类，先实例化外部类，再实例化内部类！

 

关于Java的文档注释

1 类和方法的说明应该在类和方法的定义之前

2 批注参数来标记一些特殊的属性及其相应的说明 。

@author<作者姓名>

@version<版本信息>

@param<参数名称><参数说明>

@return<返回值说明>

1. 子类继承父类的所有成员变量和方法，不包括构造方法，super（参数列表）可以调用父类的构造方法。
2. 子类是不能继承父类的私有成员的
3. 子类没有调用父类的构造方法，也没有使用this调用自己的重载构造方法时，系统默认调用父类的无参构造方法
4. 子类对象实例化过程：

A. 先分配存储空间

B. 系统默认赋值(为0或为NULL或为false)

C. 看有没有this重载，如果有，先执行this重载函数，跳到B，如果没有，隐式或显式调用父类的构造方法，一直到Object类，执行完父类的构造方法，子类的构造方法继续往下执行。

D. 进行实例变量的显式初始化操作

 

关于类的访问控制

Private 同一类

Default 同一类 同一个包

Protected 同一个类 同一个包 子类

Public 所有（包括不同的包中的类）

 

关于覆盖父类的方法

1. 覆盖方法必须和被覆盖方法具有相同的方法名、参数列表和返回类型
2. 子类中覆盖方法的访问权限不能比父类中的被覆盖方法的访问权限更弱

如 被覆盖方法 覆盖方法

Private public 是可以的，但是没有意义

Public private 是不可以的

 

 

关于final关键字

1. final标记的类不能被继承。

2. final标记的方法不能被子类重写。

3. final标记的变量(成员变量或局部变量)即成为常量，只能赋值一次。

4. 方法中定义的内置类只能访问该方法内的final类型的局部变量，用final定义的局部变量相当于是一个常量，它的生命周期超出方法运行的生命周期，将一个形参定义成final也是可以的，这就限定了我们在方法中修改形式参数的值。

4. public static final共同标记常量时，这个常量就成了全局的常量。

 

 

关于抽象类

包含抽象方法的类就是抽象类，抽象类不会被实例化，存在的意义就是被继承。

抽象方法只定义不实现，由自己的子类根据需要自己实现

1. 抽象类必须用abstract关键字来修饰；抽象方法也必须用abstract来修饰。

2. 抽象类不能被实例化，也就是不能用new关键字去产生对象。

3. 抽象方法只需声明，而不需实现。

4. 含有抽象方法的类必须被声明为抽象类，抽象类的子类必须覆盖所有的抽象方法后才能被实例化，否则这个子类还是个抽象类。

 

关于接口

接口的本质是什么？是特殊的抽象类，所有的方法都是抽象的，不会有变量，可以有常量，方法都不会被实现。

1. 接口中的成员都是public访问类型的。接口里的变量默认是用public static final标识的，这是全局变量的一种表示方法

2. 我们可以定义一个新的接口用extends关键字去继承一个已有的接口

类和类之间的继承，接口和接口之间的继承都是extends

3. 我们也可以定义一个类用implements关键字去实现一个接口中的所有方法，
4. 定义一个抽象类用implements关键字去实现一个接口中定义的部分方法。

5. 一个类可以继承一个父类的同时，实现一个或多个接口，extends关键字必须位于implemnets关键字之前，先继承父类，再实现接口……

 

 

关于对象的类型转换

1. 子类对象可以自动转换成父类的对象，但是子类转换后原来比父类多余的变量和方法就没有了，不可以再用了。
2. 父类对象转换成子类对象却需要强制的类型转换，如类型AB，A是父类：

A a = new A();

B b = (B) a;

1. 我认为：强制类型转换的本质是让编译器开后门，让不合适的变量能够通过编译！编译的时候没有错误，但是运行的时候很可能就出错了
2. instanceof 操作符可以用它来判断一个实例对象是否属于一个类
3. 定义一个类，不过不显式的说明继承了哪个类，那么这个类隐式的继承了Object类
4. Object类有一个equals方法，学会用这个方法判断两个类的对象是否相同很方便

关于类的多态性

1. 只需对基类进行处理，不需要对每一个派生类进行处理，“以不变应万变”
2. 派生类的功能可以被基类的引用变量引用，这叫向后兼容，可以提高程序的可扩充性和可维护性。

 

关于Java中的异常

异常的处理try catch语句

try{

//有可能有异常的语句

//如果发生异常，系统生成异常的一个对象，传递给e

}

catch(exception e){ //异常时一个类，e是一个对象

//如果try中发生了异常，跳转到此继续执行，而不至于程序崩溃

System.out.println(e.getMessage（）); //打印出异常信息

}

throws

函数有可能发生异常时，可以在函数的后面加上标识：throws Exception

函数在使用的时候必须使用try catch语句进行处理，或者在调用这个可能有异常的方法是交给该模块的上一级使用throws Exception进行处理，但第二种方法不太好。异常应该及时处理。

 

在程序中定义自己的异常类

class DevideByMinusException extends Exception

{

public DevideByMinusException(String msg){

super(msg)

}

}

 

在程序中，if(//条件）{

throw new DevideByMinusException("异常的信息")

}

try后面可以接多个catch语句进行抛出多个异常的处理

try{

//有可能有异常的语句

//如果发生异常，系统生成异常的一个对象，传递给e

}

catch(ArithmentException e){ //异常时一个类，e是一个对象

//如果try中发生了异常，跳转到此继续执行，而不至于程序崩溃

System.out.println(e.getMessage（）); //打印出异常信息

}

catch(DivideByMinuseException e){

//处理

e.printStackTree(); //更详细的信息处理

}

finally{

//总是被执行，及时try中有return已经返回

//唯一不会执行的时候： 遇到返回之前遇到了System.exit(0); 彻底退出了。。。。。。。

}

注意：

1. 一个方法被覆盖时，覆盖它的方法必须扔出相同的异常或异常的子类。

2. 如果父类扔出多个异常，那么重写（覆盖）方法必须扔出那些异常的一个子集,也就是说不能扔出新的异常

 

关于包

对类能过分门别类的存放，使用方便

1. package语句作为Java源文件的第一条语句。如果没有package语句，则为缺省无名包。

2. import语句及应用

3. jdk中常用的包

java.lang----包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。

java.awt----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。

java.applet----包含applet运行所需的一些类。

java.net----包含执行与网络相关的操作的类。

java.io----包含能提供多种输入/输出功能的类。

java.util----包含一些实用工具类，如定义系统特性、使用与日期日历相关的函数。

 

关于Java的命名习惯

假设xxx，yyy，zzz分别是一个英文单词的拼写。

1. 包名中的字母一律小写,如：xxxyyyzzz。

2. 类名、接口名应当使用名词，每个单词的首字母大写，如：XxxYyyZzz。

3. 方法名，第一个单词小写，后面每个单词的首字母大写，如：xxxYyyZzz。

4. 变量名，第一个单词小写，后面每个单词的首字母大写,如：xxxYyyZzz。

5. 常量名中的每个字母一律大写，如：XXXYYYZZZ

 

关于Jar文件

jar –cvf

jar –tvf

jar –xvf

jar –tvf >a.txt

用rar查看jar文件中的内容

注意压缩后的jar文件中的目录结构

快速查看jar包中是否有我们想找的类