1.对象的比较
- “==”操作符用于比较两个对象的内存地址值是否相等
- equals() 方法用于比较两个对象的内容是否一致
如下列：
1 public class text3 { 2 3 public static void main(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 class text3 { 2 3 public static void main(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 class text3 { 2 3 public static void main(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 ? -->false str1 == str3 ? -->true str3 == 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 class Person 2 { 3 private String name; 4 private int age; 5 void talk() 6 { 7 System.out.println("wo shi: "+name+", jinnian: "+age+"sui"); 8 } 9 10 public void setName(String str) 11 { 12 name = str; 13 } 14 15 public void setAge(int a) 16 { 17 if(a > 0) 18 age = a; 19 } 20 21 public String getName() 22 { 23 return name; 24 } 25 26 public int getAge() 27 { 28 return age; 29 } 30 } 31 32 public class text17 { 33 34 public static void main(String[] args) { 35 36 Person p = new Person(); 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中却允许多层继承。
多层继承如：
class A { } class B extends A { } class C extends B { }
子类对象在实例化时会默认先去调用父类中的无参构造方法，之后再调用本类中的相应构造方法。
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标记的变量（成员变量或局部变量）即为常量，只能赋值一次。
