三、高级类特性

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;

}

}