java修行之路（四）
三、高级类特性
1.Object 类
(1)概念
Object类是所有Java类的根父类，Object类是所有Java类的根父类
如果在类的声明中未使用extends关键字指明其父类，则默认父类为Object类
(2)==操作符与equals方法
a、= =：
基本类型比较值:只要两个变量的值相等，即为true. 两边的数据类型可以不同，在不同的情况下，也可以返回true。
引用数据类型：比较引用类型变量的地址值是否相等。
b、equals()
只能比较引用类型，其作用与“==”相同,比较是否指向同一个对象.
特例：当用equals()方法进行比较时，对类File、String、Date及包装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对象
原因：在这些类中重写了Object类的equals()方法。
示例代码：
String str1 = new String("hello");
String str2 = new String("hello");
System.out.println(str1.equals(str2)); //true
System.out.println(str1 == str2 ); //false
(3)toString()
a、toString()方法在Object类中定义，其返回值是String类型，返回类名和它的引用地址
b、我们通常重写 toString方法，将对象的属性返回。
c、特例：对类File、String、Date及包装类（Wrapper Class）来说，已经实现了类中对toString方法的重写。
示例代码：
Object o1 = new Object();
System.out.println(o1);// java.lang.Object@1b6d3586
String str1 = new String("hello");
System.out.println(str1); //hello
2.包装类及基本数据类型，String类之间的转换
(1)概念
8种基本数据类型对应着一个类，此类即为包装类。
图2-1
(2)基本数据类型 转换成 包装类
示例代码：
@Test //此注释为junit4测试框架
public void test1(){
int i = 10;
System.out.println(i); //10 int类型
Integer i1 = new Integer("10");
Integer i2 = new Integer(10);
System.out.println(i1); // 10 Integer类型
System.out.println(i2); // 10
Person p = new Person();
System.out.println(p.b1); //null 注意：此属性为引用数据类型
System.out.println(p.b2); //false
}
class Person{
Boolean b1;
boolean b2;
}(3)包装类 转换成 基本数据类型：调用包装类XXX的xxxValue()方法
示例代码：
@Test
public void test2(){
Integer i2 = new Integer(10);
int i3 = i2.intValue();
System.out.println(i3);
}(4)自动装箱和拆箱 JDK1.5之后
不用上面那么麻烦了。
int i1 = 12;
Integer i2 = i1; //自动装箱 基本数据类型--->包装类
int i3 = i2; // 自动拆箱 包装类--->基本数据类型
(5)基本数据类型、包装类 –> String类:
调用String类的静态的重载的valueOf()方法
示例代码：
@Test
public void test3(){
int i1 = 10;
String str1 = i1 + "";
Integer i2 = i1;
String str2 = String.valueOf(i2);
}(6)String类 –> 基本数据类型、包装类
调用包装类的parseXXX(String str)方法
示例代码：
@Test
public void test4(){
String str1 = "10";
String str2 = "true";
Integer i1 = Integer.parseInt(str1);
Boolean b1 = Boolean.parseBoolean(str2);
System.out.println(i1);
System.out.println(b1);
}3.关键字static
(1)概念：static，静态的，可以用来修饰 属性、方法、代码块、内部类
(2)static修饰属性（类变量）
a、由类创建的所有的对象，都共用这一属性。
b、当其中一个对象对此属性进行修改，会影响其他对象对此属性的调用。
c、类变量随着类的加载而加载。
d、静态的变量可以直接通过"类.类变量"的形式来调用 。
e、类变量的加载早于对象。实例变量（非static修饰的属性）是随着对象的创建而被加载的。
示例代码：
class TestPerson{
public static void main(String[] args) {
Person p1 = new Person("xue",20);
Person p2 = new Person("xue",20);
p1.name = "chen";
System.out.println(Person.sex);// 女
p1.sex = '男'; //只给对象p1赋值
System.out.println(p1); //Person{name='chen', age=20, sex=男}
System.out.println(p2); //Person{name='xue', age=20, sex=男}
}
}
class Person{
String name;
int age;
static char sex = '女';
public Person(){}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age + ", sex=" + sex +
'}';
}
}(3)static修饰方法（类方法）
a、随着类的加载而加载
b、可以直接通过"类.类方法"的形式来调用
c、静态方法内部可以调用静态的属性或静态的方法，而不能调用非静态的属性或方法。
反之非静态的方法可以调用静态的属性或静态的方法。
(4)static应用举例
//创建多个银行账号，id是唯一的，不能重复
class TestAccount{
public static void main(String[] args) {
Account a1 = new Account("123456");
Account a2 = new Account("abc123");
System.out.println(a1); //Account{id=1000, password='123456'}
System.out.println(a2); //Account{id=1001, password='abc123'}
}
}
class Account {
private int id;
private String password;
private static double rate = 0.05; //利率
private static int init = 1000; //如果不设置此属性为static，创建的每个对象此属性都是唯一的
public Account(String password) {
this.password = password;
this.id = init++;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", password='" + password + '\'' +
'}';
}
}4.初始化块（代码块）
注意：代码块如果有有修饰符的话，只能是static
主要作用：初始化类的属性
(1)非静态代码块
a、可以对类的属性进行初始化操作
b、一个类可以有多个代码块，多个代码块之间顺序结构执行
c、每创建一个类的对象，非静态代码块都执行一次
d、非静态代码块的执行要早于构造器
(2)静态代码块
a、随着类的加载而加载，并且只加载一次
b、静态代码块的执行要早于非静态代码块
c、静态代码块中只能执行静态的结构（类属性、类方法）
示例代码：
class Order{
private String name = "";
private int id = 1001;
public Order() {
}
//非静态代码块
{
name = "xue";
id = 1002;
System.out.println("非静态代码块");
}
//静态代码块
static {
// name = "xue"; //报错，只能执行静态的属性或方法
// id = 1002;
System.out.println("静态代码块");
}
@Override
public String toString() {
return "Order{" +
"name='" + name + '\'' +
", id=" + id +
'}';
}
}
// 执行结果
// 静态代码块
// 非静态代码块
// Order{name='xue', id=1002}5.关键字final
(1)final,表示“最终”,可以用来修饰 类、属性和方法
(2)final修饰类，这个类不能被继承，如String类、System类、StringBuffer类
(3)final修饰方法,不能被重写。如Object类中的getClass()方法。
(4)final修饰属性，此属性就是一个常量，一旦初始化后，不可再被赋值。习惯上，常量用大写字符表示。
a、此常量不能使用默认初始化赋值
b、可以显式的赋值、代码块、构造器
(5)变量用static final修饰，代表全局常量。如 Math.PI
6.单例(Singleton)设计模式
(1)设计模式
设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式
(2)单例的设计模式
a、解决的问题：使得一个类只能够创建一个对象
b、如何实现？(以下是代码步骤)
class TestSingleton{
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.println(s1 == s2); //true 类的引用是一致的 说明是同一个对象
}
}
//恶汉式
class Singleton{
//1.私有化构造器，使得在类的外部不能够调用此构造器
private Singleton(){
}
//2.在类的内部创建一个类的实例
//3.私有化此对象，通过公共方法来调用
private static Singleton instance = new Singleton();
//4.此公共的方法只能通过类来调用，因此设置修饰符static,同时类的实例也必需为static声明的
public static Singleton getInstance(){
return instance;
}
}
//懒汉式
class Singleton1{
private Singleton1(){
}
private static Singleton1 instance = null;
public static Singleton1 getInstance(){
if (instance == null){
instance = new Singleton1();
}
return instance;
}
}