java应用类_Java类额应用

基本数据类型包装类

Integer    Character

其他的都是将首字母大写;

包装类和基本类型之间的转换:

Integer   int

Integer i = new  Integer(int value);

int i2 = i.intValue();

基本数据类型和String转换

String -->int

static int parseInt(String s)

int i = Integer.parseInt("123");

int ->String

String 类valueOf(int val);

String str = String.valueOf(123);

装箱和拆箱:

java5开始出现自动装箱和拆箱;

自动装箱:

可以直接把一个基本数据类型的值直接赋给它所对应的包装类对象;

Integer i = 17;

自动拆箱:把包装类对象直接赋给它所对应的基本类型的一个变量

int i2 = new Integer(2);

Object是所有类的超级父类,

Object的对象可以接受一切数据;

享元模式:

Byte,Short,Integer,Long缓存了一个区间的数据;[-128,127]看源代码

Integer i1 = 123;

Integer i2 = 123;

i1 == i2;//true

new Integer(123) == new Integer(123);//false

Object类:就是描述对象的一个类

是超级父类;

可以接受一切数据,包括数组;

Object o = {1,2,3};

Object o = new int[]{1,2,3};

boolean equals(Object otherObj);

就是那当前对象和otherObj相比较;

默认情况下,比较的是  内存里的地址,此时和 == 一样;

一般要求子类根据自身情况覆写该方法,

String 类覆写  equals方法

Integer  类也覆写了 equals方法

int hashCode();//返回对象的一个十进制的hash值,每个对象的hashCode都不一样

String toString();//把对象转成String类型,  描述对象信息

默认情况下,  类的全限定名 + @ + Integer.toHexString(this.hashCode());

一般要求子类覆写该方法

平时我们打印对象,其实打印的是对象的toString方法,也就说在底层该对象会去调用toString方法

class Person{

String name;

int age;

public Person(String name,int age)

{

this.name = name;

this.age   = age;

}

public String toString()

{

return this.name +", " + this.age;

}

}

public static void mian (String []args)

{

System.out.println(new Person("Will",17));

System.out.println(new Person("Lucy",16));

}

代码块:

1.普通(局部)代码块,写在方法;

2.构造代码: 类里面,方法外面, 特点: 先于构造方法的执行,每次创建对象,都会执行

3.静态代码块:  static 修饰的构造代码块, 特点: 优先于主方法的执行,只执行一次,  可以用来给静态变量赋值;

4.同步代码块

单例模式:

保证项目中的一个类在运行期间有且只有一个实例对象;

//1. 把构造方法给私有化,保证外界不能创建对象

//2. 自身在内部先创建一个对象,再使用private修饰起来,

//3. 向外暴露一个全局的静态的方法用于返回内部创建的对象;

因为静态成员只能访问静态成员,那么此时必须把对象使用static修饰,

饿汉式:

class Singleton

{

private Singleton(){}

private static final Singleton instance = new Singleton();

//线程安全

public  static Singleton getInstance()

{

return instance;

}

}

懒汉式:

class Singleton

{

private Singleton(){}

private static final Singleton instance = null;

//线程不安全的

public  static Singleton getInstance()

{

if(instance == null)

{

instance = new Singleton()

}

return instance;

}

}

final:

表示最终的;

可以修饰 类,方法,变量;

final 修饰的类 表示太监类,不能被继承;基本数据类型包装类全是

final 修饰的方法 表示 不能被子类覆写 ;

final 修饰的变量:

常量: 常量名大写,若是多个单词组成,单词之间使用下划线隔开;

全局常量: public static final 修饰的变量

常量只能赋值一次

若是引用类型的常量,表示 引用对象的地址不能变,但是对象的内容是可以改变的;

方法里的内部类,只能访问方法里使用 final 修饰的变量;

抽象类:

使用 abstract 修饰的类,  一般抽象类都应该包含抽象方法,但不是必须的;

若一个类有抽象方法,那么该类必须是抽象类;

不能创建对象(不能 new),其他的换个普通类一样

可以包含普通方法;

什么时候使用抽象方法:

父类定了子类应该具备的行为,但是 具体行为的实现必须得有子类来完成;

抽象方法:

使用 abstract 修饰的方法,

只有方法的申明,没有方法的具体实现;(交给子类去实现)

一般建议把 abstract 放在修饰符前面;

抽象类必须有子类,

而且子类必须全部覆写抽象类中的抽象方法,二者,子类也作为抽象类;

青年(Person)都有吃饭(eat)和坐(set)的行为；

但是文艺青年(ArtMan)和普通青年(NormalMan)各自的的吃饭和坐的行为的具体表现都不一样；

abstract class Person

{

abstract void eat();

abstract void set();

}

class ArtMan extends Person

{

void eat()

{

System.out.println("一根一根的吃");

}

}

class  NormalMan extends Person

{

void eat()

{

System.out.println("一口一口的吃");

}

}

class  B2 extends Person

{

void eat()

{

System.out.println("一坨一坨的吃");

}

void set()

{

System.out.println("腿搅成麻花儿");

}

void show()

{

System.out.println("腿搅成麻花儿");

}

}

...mian..//主函数

{

Person p = new B2();

p.eat();//实际调用的是B2里的方法

p.set();

//p.show();//编译通不过,在Person里找不到

}

posted on

2014-07-29 15:43

星空-ing

阅读(268)

评论(0)

编辑

收藏