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;
        }

    }