1.对象的比较

“==”操作符用于比较两个对象的内存地址值是否相等

equals() 方法用于比较两个对象的内容是否一致

如下列：

1 public classtext3 {2

3 public static voidmain(String[] args) {4 String str1 = new String("java");5 String str2 = new String("java");6 String str3 =str2;7

8 if(str1 ==str2)9 {10 System.out.println("str1 == str2");11 }12 else

13 {14 System.out.println("str1 != str2");15 }16 if(str2 ==str3)17 {18 System.out.println("str2 == str3");19 }20 else

21 {22 System.out.println("str2 != str3");23 }24

25 }26

27 }

运行结果为：

str1 !=str2

str2== str3

str1与str2的内容完全一样，为什么会不等于呢？ 这两个对象指向不同的内存空间，所以它们的内存地址是不一样的。用“==”比较的是内存地址值。

如要比较内容，可用“equals”。

1 public classtext3 {2

3 public static voidmain(String[] args) {4 String str1 = new String("java");5 String str2 = new String("java");6 String str3 =str2;7

8 if(str1.equals(str2))9 {10 System.out.println("str1 == str2");11 }12 else

13 {14 System.out.println("str1 != str2");15 }16 if(str2.equals(str3))17 {18 System.out.println("str2 == str3");19 }20 else

21 {22 System.out.println("str2 != str3");23 }24

25 }26

27 }

运行结果为：

str1 ==str2

str2== str3

2.两种String对象的声明方式到底有什么不同？

String str1 = new String("java");

String str2 = "java";

如下例：

1 public classtext3 {2

3 public static voidmain(String[] args) {4 String str1 = "java";5 String str2 = new String("java");6 String str3 = "java";7

8 System.out.println("str1 == str2 ? -->"+(str1 ==str2));9 System.out.println("str1 == str3 ? -->"+(str1 ==str3));10 System.out.println("str3 == str2 ? -->"+(str3 ==str2));11

12 }13 }

运行结果：

str1 == str2 ? -->falsestr1== str3 ? -->truestr3== str2 ? -->false

str1与str3相等，则证明str1与str3是指向同一个内存空间的。

String对象的内容一旦声明则不能轻易改变。

如果想改变一个String对象的值，则第一步要做的是先将原有的String引用断开，之后再开辟新的内存空间。

用new关键字开辟String对象的内存空间的话，则实际上就开辟了两个内存空间。

3.类对象的产生

格式：

类名 对象名 = new 类名()；

创建属于某类的对象，需要通过如下两个步骤来实现：

声明指向“由类所创建的对象”的变量

利用new创建新的对象，并指派给先前所创建的变量

举例：创建Person类的对象

Person p； //先声明一个Person类的对象p

p = new Person()； //用new关键字实例化Person的对象p

当然也可以用如下方式来声明变量：

Person p = new Person() ； //声明Person对象p并直接实例化此对象

对象只有在实例化之后才能被使用，而实例化对象的关键字就是new。

4.访问对象中某个变量或方法

访问属性： 对象名称。属性名

访问方法： 对象名称。方法名()

如：想访问Person类中的name和age属性

p.name； //访问Person类中的name属性

p.age; //访问Person类中的age属性

5.类的属性封装(private)

要设置或取得属性值，则只能用setXxx()、getXxx()方法，这是一个明确且标准的规定。

封装类中的属性或方法：

封装属性： private属性类型 属性名

封装方法：private 方法返回类型 方法名称(参数)

加入一些setXxx()、getXxx()方法，主要用来设置和取得类中的私有属性，解决封装问题，如下列：

1 classPerson2 {3 privateString name;4 private intage;5 voidtalk()6 {7 System.out.println("wo shi: "+name+", jinnian: "+age+"sui");8 }9

10 public voidsetName(String str)11 {12 name =str;13 }14

15 public void setAge(inta)16 {17 if(a > 0)18 age =a;19 }20

21 publicString getName()22 {23 returnname;24 }25

26 public intgetAge()27 {28 returnage;29 }30 }31

32 public classtext17 {33

34 public static voidmain(String[] args) {35

36 Person p = newPerson();37 p.setName("zhang san");38 p.setAge(-25);39 p.talk();40

41 }42

43 }

运行结果：

wo shi: zhang san, jinnian: 0sui

6.内部类

定义内部类的格式：

标示符 class外部类的名称

{//外部类的成员

标示符 class内部类的名称

{//内部类的成员

}

}

外部类是无法找到内部类中所声明的属性，而内部类则可以访问外部类的属性。

用static声明的内部类则变成外部类，但是用static声明的内部类不能访问非static的外部类属性。(《Java基础教程》P193)

7.类的继承

类的继承格式：

class 父类 //定义父类

{

}class 子类 extends 父类 //用extends关键字实现类的继承

{

}

在java中只允许单继承，不允许多重继承，也就是说一个子类只能有一个父类，但java中却允许多层继承。

多层继承如：

classA

{

}class B extendsA

{

}class C extendsB

{

}

子类对象在实例化时会默认先去调用父类中的无参构造方法，之后再调用本类中的相应构造方法。

super主要的功能是完成子类调用父类中的内容，也就是调用父类中的属性或方法。

用super调用父类中的构造方法，只能放在程序的第一行。

super调用属性或方法：

super.父类中的属性；super.父类中的方法()；

8.this与super的比较

this：

1.表示当前对象

2.调用本类中的方法或属性

3.调用本类中的构造方法时，放在程序首行

super：

1.子类调用父类的方法或属性

2.调用父类中的构造方法时，放在程序首行

从上表中发现，用super或this调用构造方法时都需要放在首行。所以，super与this调用构造方法的操作时不能同时出现的。

9.抽象类定义规则

抽象类和抽象方法都必须用abstract关键字来修饰

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

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

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

10.final关键字

在Java中声明类、属性和方法时，可使用关键字final来修饰。

final标记的类不能被继承。

final标记的方法不能被子类复写。

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