黑马程序员-面向对象总结（2）


----------------------------android培训、java培训、期待与您交流！---------------------------------

前言：学习JAVA最重要的一个技能就是会查阅API,以下的是一些API中重要类的概念与使用总结

1、基本数据类型的包装类

 
数据类型的划分出现了基本数据类型和引用数据类型，那么我们怎么能把基本数据类型称为对象呢？
除了Integer和Character定义的名称和对应的基本类型差异大，其他六种都是将首字母大写就可以了。
Integer,Byte,Float,Double,Short,Long都是Number类的子类。(Number类后面讲)；
Character和Boolean都是Object直接子类；
8个类都是final修饰的(不可被继承)。
 

2、基本数据类型和包装类相互转换

 
把基本数据类型 → 包装类：通过对应包装类的构造方法实现
除了Character外，其他包装类都可以传入一个字符串参数构建包装类对象。
包装类 → 基本数据类型：包装类的实例方法xxxValue();    // xxx表示包装类对应的基本数据类型
示例语句：
boolean bool = false;
Boolean b2 = new Boolean(bool);
Integer i = new Integer(3);
int i2 = i.intValue();
Boolean b1 = new Boolean("TRue");//true
boolean b2 = b1.booleanValue();
Float f = new Float("3.14");//3.14
Integer i2 = new Integer("123s");//NumberFormatException

jdk1.5开始出现的特性：自动装箱&自动拆箱
自动装箱：可把一个基本类型变量直接赋给对应的包装类对象或则Object对象
自动拆箱：允许把 包装类对象直接赋给对应的基本数据类型
示例语句：
Integer i = 3;//装箱
int i2 = i;//拆箱
Object flag = new Boolean(false);
if(flag instanceof Boolean){
Boolean b = (Boolean)flag;
boolean b2 = b;
}

3、基本类型和String之间的转换

 
String →基本类型，除了Character外所有的包装类提供parseXxx(String s)静态方法，用于把一个特定的字符串转换成基本类型变量；
基本类型 → String，String 类有静态方法valueOf()，用于将基本类型的变量转换成String类型。
示例语句：
String str = "17";
int i = Integer.parseInt(str);//String  --> 基本类型
String s1 = String.valueOf(i);//基本类型 --> String
 
 

4、Object类

 
所有类的公共父类，一旦一个类没有显示地继承一个类则其直接父类一定是Object。
一切数据类型都可用Object接收
class OOXX  extends Object{}等价于class ooXX {}
 
常见方法
public boolean equals(Object obj)：对象比较
public int hashCode()：取得该对象的Hash码
public String toString()：对象描述
 
Object类的 toString()方法：“对象的描述”建议所有类都覆写此方法
直接打印输出对象时，会调用该对象的toString()方法。//可以不写出来
打印对象的时候,实际调用的对象实际指向的类的自我描述；
 
equals也是判断是否指向同一个对象,没有实际意义，有必要可以重写public boolean equals(Object obj) {}
String 覆写了 Object的equals方法：只比较字符的序列是否相同
==用于判断两个变量是否相等（引用类型：必须指向同一个对象，才true)
 
 

5、代码块

 
代码块指的是使用"{}"括起来的一段代码，根据代码块存在的位置可以分为4种:
普通代码块;
构造代码块;
静态代码块;
同步代码块(线程同步的时候讲解)。
代码块里变量的作用域：
只在自己所在区域(前后的{})内有效；
普通代码块：
普通代码块就是直接定义在方法或语句中定义的代码块：
public void show(){

普通代码块
}
构造代码块：
直接写在类中的代码块:优于构造方法执行，每次实例化对象之前都会执行构造代码块。
静态代码块
使用static 修饰的构造代码块:
优于主方法执行，优于构造代码块执行，不管有创建多少对象，静态代码块只执行一次，可用于给静态变量赋值；
 
示例代码：

<strong><span style="background-color: rgb(255, 255, 204);">public class Demo {
Demo(){
System.out.println("我是构造方法！");
}
{
System.out.println("我是构造代码块！");//实例化对象的时候才会去调用！
}
static{
System.out.println("我是静态代码块！");
}

public static void main(String[] args) {
new Demo();
new Demo();//再次创建对象，证明无论创建几次对象，静态代码块都只执行一次
System.out.println("我是普通代码块！");
}
}/**输出：</span></strong><p class="p0" style="text-indent: 21pt; margin-top: 0pt; margin-bottom: 0pt;"><span style="background-color: rgb(255, 255, 204);"><span style="color: rgb(0, 0, 0); font-family: 'Courier New'; font-size: 10.5pt; mso-spacerun: 'yes';">我是静态代码块！</span><span style="font-family: 'Courier New'; font-size: 10.5pt; mso-spacerun: 'yes';"></span></span></p><p class="p0" style="text-indent: 21pt; margin-top: 0pt; margin-bottom: 0pt;"><span style="background-color: rgb(255, 255, 204);"><span style="color: rgb(0, 0, 0); font-family: 'Courier New'; font-size: 10.5pt; mso-spacerun: 'yes';">我是构造代码块！</span><span style="font-family: 'Courier New'; font-size: 10.5pt; mso-spacerun: 'yes';"></span></span></p><p class="p0" style="text-indent: 21pt; margin-top: 0pt; margin-bottom: 0pt;"><span style="background-color: rgb(255, 255, 204);"><span style="color: rgb(0, 0, 0); font-family: 'Courier New'; font-size: 10.5pt; mso-spacerun: 'yes';">我是构造方法！</span><span style="font-family: 'Courier New'; font-size: 10.5pt; mso-spacerun: 'yes';"></span></span></p><p class="p0" style="text-indent: 21pt; margin-top: 0pt; margin-bottom: 0pt;"><span style="background-color: rgb(255, 255, 204);"><span style="color: rgb(0, 0, 0); font-family: 'Courier New'; font-size: 10.5pt; mso-spacerun: 'yes';">我是构造代码块！</span><span style="font-family: 'Courier New'; font-size: 10.5pt; mso-spacerun: 'yes';"></span></span></p><p class="p0" style="text-indent: 21pt; margin-top: 0pt; margin-bottom: 0pt;"><span style="background-color: rgb(255, 255, 204);"><span style="color: rgb(0, 0, 0); font-family: 'Courier New'; font-size: 10.5pt; mso-spacerun: 'yes';">我是构造方法！</span><span style="font-family: 'Courier New'; font-size: 10.5pt; mso-spacerun: 'yes';"></span></span></p><p class="p0" style="margin-top: 0pt; margin-bottom: 0pt;"><span style="color: rgb(0, 0, 0); font-family: 'Courier New'; font-size: 10.5pt; mso-spacerun: 'yes';"><span style="background-color: rgb(255, 255, 204);">   我是普通代码块！</span></span></p><p class="p0" style="margin-top: 0pt; margin-bottom: 0pt;"><span style="color: rgb(0, 0, 0); font-family: 'Courier New'; font-size: 10.5pt; mso-spacerun: 'yes';"><span style="background-color: rgb(255, 255, 204);">*/</span></span></p><!--EndFragment-->

6、构造方法的私有化
有的时候我们为了避免外界创建某类的实例，就将某类的构造方法私有化，即将它的构造方法用private修饰：
外界如何用到？提供get方法！不提供的话外界就没法创建对象！（对反射无效）
 

7、Singleton模式(单例模式) 饿汉式和懒汉式

 
应用：整个应用中有且只有一个实例，所有指向该类型实例的引用都指向这个实例。
常见单例模式类型：
饿汉式单例：直接将对象定义出来
懒汉式单例：只给出变量，并不将其初始化。
总结：
饿汉式，static修饰，随着类的加载而加载，会损耗性能，但是方法相对简单
懒汉式  第一次用的时候相对较慢，因为需要加载！线程，不安全！
代码：

//单例模式
//饿汉式,直接把对象构造出来
class SingleDemo{
private static SingleDemo s1 = new SingleDemo();
private SingleDemo(){
//提供私有化的构造方法，那么外界就不能构造对象了！
}

public static SingleDemo getS1() {
return s1;
}
}

//懒汉式，先定义，但是不创建对象
class SingleDemo2{
private static SingleDemo2 s3 ;

private SingleDemo2(){
//提供私有化的构造方法，那么外界就不能构造对象了！
}

public static SingleDemo2 getS3() {//这是一个方法，返回值为创建的对象！
if(s3 == null){
s3 = new SingleDemo2();
}//和饿汉式的区别，此时才来创建对象！
return s3;
}
}

public class Demo14 {
public static void main(String[] args) {
SingleDemo s1 = SingleDemo.getS1();
SingleDemo s2 = SingleDemo.getS1();

SingleDemo2 s3 = SingleDemo2.getS3();
SingleDemo2 s4 = SingleDemo2.getS3();

System.out.println(s1 == s2);
System.out.println(s3 == s4);

}
}//<span style="font-family: '宋体'; font-size: 10.5pt; mso-spacerun: 'yes';">true true</span><!--EndFragment-->

8、final 关键字
1、　final可以修饰类,方法,变量。
2、final修饰类不可以被继承，但是可以继承其他类。
3、final修饰的方法不可以被覆写,但可以覆写父类方法。
4、final修饰的变量称为常量，这些变量只能赋值一次。
5、内部类在局部时，只可以访问被final修饰的局部变量。 
6、final修饰的引用类型变量,表示该变量的引用不能变,而不是该变量的值不能变;
 

9、抽象类

 
当编写一个类时，我们往往会为该类定义一些方法，这些方法是用来描述该类的行为方式，那么这些方法都有具体的方法体。
但是有的时候，某个父类只是知道子类应该包含怎么样的方法，但是无法准确知道子类如何实现这些方法。
 
抽象方法的定义：通过abstract关键字来修饰的类称为抽象类，抽象方法没有方法体。
 
总结：
抽象类用private修饰，里面可以有用private修饰的方法（没有方法体），强制子类进行覆写；
抽象类可以含有普通方法；
抽象类不能创建实例对象（不能new）；
    需要子类覆盖掉所有的抽象方法后才可以创建子类对象，否则子类也必须作为抽象类；
列举常见的几个抽象类：
流的四个基本父类
InputStream，OutputStream，Reader，Writer
示例代码：

abstract class Person{
}
class Student extends Person{
}
public class Demo2 {
public static void main(String[] args) {
Person p = new Student();//体现的是多态，父类声明实例化子类对象。而不是抽象类实例化
}
}

abstract方法 
 
分析事物时，发现了共性内容，就出现向上抽取。会有这样一种特殊情况，就是功能声明相同，但功能主体不同。
那么这时也可以抽取，但只抽取方法声明，不抽取方法主体。那么此方法就是一个抽象方法。
abstract [非private访问修饰符] 返回值类型 方法名称(参数列表);
注意：抽象方法要存放在抽象类中。
  抽象方法也可以存在于接口中

abstract class Person3{
abstract void show();
abstract void inof();
void turn(){
}
}
class NewP extends Person3{
void show() {
}
void inof() {
}
//不覆写的话会报错
}
public class Demo15 {
public static void main(String[] args) {
//new Person3();报错！因为抽象类不可以实例化
}
}

 

10、匿名内部类

 
特点：
1、适合只使用一次的类
2、不能是抽象类，因为系统在创建匿名内部类的时候，会立即创建匿名内部类的对象。
3、匿名内部类不能定义构造器，因为匿名内部类没有类名。
 
格式：
new 父类构造器([实参列表]) 或 接口()
{
//匿名内部类的类体部分
}
 
11、枚举类
 
使用enum声明,默认直接继承了java.lang.Enum类，而不是Object类；
枚举类的对象是固定的,实例个数有限,不可以再new( ),枚举对象后可以跟()。
枚举元素必须位于枚举类体中的最开始部分,枚举元素后要有分号与其他成员分隔。
枚举类的构造方法的权限修饰符默认是private；
一旦枚举对象后面加上{},那么该对象实际是枚举匿名内部类对象;
所有枚举类都提供一个静态的values()方法(返回该枚举类所有对象组成的数组),便于遍历所有枚举对象；
所有枚举类都提供一个静态的valueOf(String name)方法, 返回枚举类中对象名等于 name的对象。
 
示例：

<strong>enum Color{
Green,Blue,Yellow;
public String toString() {
String ret = super.toString();
switch (this) {
case Green:
ret = "绿色";
break;
case Blue:
ret = "蓝色";
break;
case Yellow:
ret = "黄色";
break;
default:
break;
}
return ret;
}
}
class Personp{
Color c = Color.Blue;
void show(){
System.out.println(c);
}
}
public class Demo {
public static void main(String[] args) {
Color []color = Color.values();
for (Color c : color) {
System.out.println(c);
}
new Personp().show();
}
}//输出：</strong><p class="p0" style="text-indent: 21pt; margin-top: 0pt; margin-bottom: 0pt;"><span style="color: rgb(0, 0, 0); font-family: 'Courier New'; font-size: 10.5pt; mso-spacerun: 'yes';">绿色</span><span style="font-family: 'Courier New'; font-size: 10.5pt; mso-spacerun: 'yes';"><o:p></o:p></span></p><p class="p0" style="text-indent: 21pt; margin-top: 0pt; margin-bottom: 0pt;"><span style="color: rgb(0, 0, 0); font-family: 'Courier New'; font-size: 10.5pt; mso-spacerun: 'yes';">蓝色</span></p><p class="p0" style="text-indent: 21pt; margin-top: 0pt; margin-bottom: 0pt;"><span style="color: rgb(0, 0, 0); font-family: 'Courier New'; font-size: 10.5pt; mso-spacerun: 'yes';"></span><span style="color: rgb(0, 0, 0); font-family: 'Courier New'; font-size: 10.5pt; mso-spacerun: 'yes';">黄色</span><span style="font-family: 'Courier New'; font-size: 10.5pt; mso-spacerun: 'yes';"><o:p></o:p></span></p><p class="p0" style="margin-top: 0pt; margin-bottom: 0pt;"><span style="color: rgb(0, 0, 0); font-family: 'Courier New'; font-size: 10.5pt; mso-spacerun: 'yes';">   蓝色</span></p><!--EndFragment-->

枚举类覆写接口抽象方法的两种方式：在枚举类中实现接口的抽象方法；在枚举匿名内部类中实现接口的抽象方法；

-----------------------android培训、java培训、期待与您交流！----------------------

黑马训练营：http://edu.csdn.net/