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()方法
示例代码：

@Testpublic 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()方法
示例代码：

@Testpublic void test3(){  int i1 = 10;  String str1 = i1 + "";  Integer i2 = i1;  String str2  = String.valueOf(i2);}

(6)String类 –> 基本数据类型、包装类
调用包装类的parseXXX(String str)方法
示例代码：

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