黑马程序员-面向对象的学习总结-2

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 修饰的构造代码块:

优于主方法执行，优于构造代码块执行，不管有创建多少对象，静态代码块只执行一次，可用于给静态变量赋值；

 

示例代码：

<span style="BACKGROUND-COLOR: #ffffff"><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--></span>

 

6、构造方法的私有化

有的时候我们为了避免外界创建某类的实例，就将某类的构造方法私有化，即将它的构造方法用private修饰：

外界如何用到？提供get方法！不提供的话外界就没法创建对象！（对反射无效）

 

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

 

应用：整个应用中有且只有一个实例，所有指向该类型实例的引用都指向这个实例。

常见单例模式类型：

饿汉式单例：直接将对象定义出来

懒汉式单例：只给出变量，并不将其初始化。

总结：

饿汉式，static修饰，随着类的加载而加载，会损耗性能，但是方法相对简单

懒汉式  第一次用的时候相对较慢，因为需要加载！线程，不安全！

代码：

<span style="BACKGROUND-COLOR: #ffffff">//单例模式//饿汉式,直接把对象构造出来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--></span>

 

8、final 关键字

1、　final可以修饰类,方法,变量。

2、final修饰类不可以被继承，但是可以继承其他类。

3、final修饰的方法不可以被覆写,但可以覆写父类方法。

4、final修饰的变量称为常量，这些变量只能赋值一次。

5、内部类在局部时，只可以访问被final修饰的局部变量。 

6、final修饰的引用类型变量,表示该变量的引用不能变,而不是该变量的值不能变;

 

9、抽象类

 

当编写一个类时，我们往往会为该类定义一些方法，这些方法是用来描述该类的行为方式，那么这些方法都有具体的方法体。

但是有的时候，某个父类只是知道子类应该包含怎么样的方法，但是无法准确知道子类如何实现这些方法。

 

抽象方法的定义：通过abstract关键字来修饰的类称为抽象类，抽象方法没有方法体。

 

总结：

抽象类用private修饰，里面可以有用private修饰的方法（没有方法体），强制子类进行覆写；

抽象类可以含有普通方法；

抽象类不能创建实例对象（不能new）；

    需要子类覆盖掉所有的抽象方法后才可以创建子类对象，否则子类也必须作为抽象类；

列举常见的几个抽象类：

流的四个基本父类

InputStream，OutputStream，Reader，Writer

示例代码：

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

 

abstract方法 

 

分析事物时，发现了共性内容，就出现向上抽取。会有这样一种特殊情况，就是功能声明相同，但功能主体不同。

那么这时也可以抽取，但只抽取方法声明，不抽取方法主体。那么此方法就是一个抽象方法。

abstract [非private访问修饰符] 返回值类型 方法名称(参数列表);

注意：抽象方法要存放在抽象类中。

  抽象方法也可以存在于接口中

<span style="BACKGROUND-COLOR: #ffffff">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();报错！因为抽象类不可以实例化}}</span>

 

10、匿名内部类

 

特点：

1、适合只使用一次的类

2、不能是抽象类，因为系统在创建匿名内部类的时候，会立即创建匿名内部类的对象。

3、匿名内部类不能定义构造器，因为匿名内部类没有类名。

 

格式：

new 父类构造器([实参列表]) 或 接口()

{

//匿名内部类的类体部分

}

 

11、枚举类

 

使用enum声明,默认直接继承了java.lang.Enum类，而不是Object类；

枚举类的对象是固定的,实例个数有限,不可以再new( ),枚举对象后可以跟()。

枚举元素必须位于枚举类体中的最开始部分,枚举元素后要有分号与其他成员分隔。

枚举类的构造方法的权限修饰符默认是private；

一旦枚举对象后面加上{},那么该对象实际是枚举匿名内部类对象;

所有枚举类都提供一个静态的values()方法(返回该枚举类所有对象组成的数组),便于遍历所有枚举对象；

所有枚举类都提供一个静态的valueOf(String name)方法, 返回枚举类中对象名等于 name的对象。

 

示例：

<span style="BACKGROUND-COLOR: #ffffff"><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--></span>

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