DAY12------面向对象 小结 2 Object类 代码块构造私有化 抽象类 接口 枚举类

基本数据类型以及包装类

java的数据类型分为基本数据类型和引用数据类型

包装类主要是为了java面向对象对基本数据类型的使用而产生的，主要作用是将基本数据类型包装为一个类

如何将基本数据类型称为对象

主要是将基本数据类型：byte、short、long、float、double、boolean类型首字母大写即可

int——>Integer

char——>Character//特殊的有两个

Interger.Byte.Float.Double.Short.Long 都是Number类的子类

Charater和Boolean都是Object直接子类

8个类都是final修饰的 不可以被继承

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

把基本数据类型——>包装类

通过对应的包装类型的构造方法实现

除了Character外，其他包装类都可以传入一个字符串参数构建包装类对象

包装类——>基本数据类型

包装类的实例方法xxxValue（）；//xxx表示包装类对应的基本数据类型

eg：

boolean bool=false；

Boolean b2=new Boolean（bool）；

Integer i=new Integer(3);

int i2 =i.intValue();

Boolean b1=new Boolean("TRue");//ture

boolean b2=b1.booleanValue();

Float f=new Float("3.14");

Integer i2=new Integer("123s");NumberFormatException

注：

自动装箱&自动拆箱

jdk1.5开始出现的新特性：

自动装箱：可把一个基本数据类型直接赋给对应的包装类对象或Object对象

自动拆箱：允许包包装类对象直接赋给对象对应的基本数据类型

EG：

Integer i=3;//装箱

int i2=i;//拆箱

Object flag =new Boolean（false）；

if（flag instanceof Boolean）{

Boolean b=（Boolean）flag；

boolean b2=b；

}

我的总结：对于基本数据类型和包装类之间的装换，我们可以直接的用，相互转换

因为java5之后的自动拆箱，装箱功能，即便不知道这个，其实使用中也不影响

Object类

多有类的公共父类，一旦一个类没有显示地继承一个类则其直接父类就是Object类

一切数据类型都可以使用Object接收

class OOXX extends Object{} 等价于 class ooXX{}

常见方法：

public boolean equals(Object obj);//对象比较

public int hashCode()//取得对象的hash码

pubulic String toString()//对象描述

Object类的toString()方法：“对象的描述”

建议所有的类都覆写此方法

直接打印输出对象时，会调用该对象的toString

直接打印对象的时候会调用此方法

全限定类名+@+十六进制的hashCode值，等价于

全限定类名+@+IntegertoHexString(该对象.hashCode)

代码块

代码块是指使用{}括起来的一段代码，更具代码块存在的位置可以分为4种：

普通代码块

构造代码块

静态代码块

同步代码块（线程同步用到）

代码块里的变量的作用域:

只在自己所在区域（前后{}内有效）;

普通代码块：

普通代码块就是直接定义在方法或语句中定义的代码块

pubulic void show(){

普通代码块

}

构造带代码块：

直接写在类中的代码块

优先于构造方法执行，每次实例化对象之前都会执行构造代码块

public class Demo{

{

System.out.println("我是构造代码块");

}

public Demo(){

System.out.println("我是构造方法");

}

public static void main(String[] args){

Demo d1 =new Demo();

Demo d2 =new Demo();

}

}

静态代码块：

使用static修饰的构造代码块：

优先于主方法执行，优先于构造代码块执行，不管有创建多少对象，静态代码块

只执行一次，可用于给静态变量赋值

Eg：

/** * 测试各代码块的优先级 *优先级顺序：静态代码块 　＞　构造代码块　＞　普通代码块 *备注：无论创建几个对象，静态代码块只执行一次！ */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("我是普通代码块！");}}输出：我是静态代码块！我是构造代码块！我是构造方法！我是构造代码块！我是构造方法！我是普通代码块！

构造方法的私有化

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

外界如何用到？

提供一个get方法，不提供的话外界就没法创建对象 反射无效

class Stu{//将构造方法私有化private Stu(){}}public class Demo15 {public static void main(String[] args) {Stu s = new Stu();}}

Singleton模式（单例设计模式）饿汉式和懒汉式

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

如同国家主席只有一个，叫主席的一定就是叫国家主席

常见的单例模式类型

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

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

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

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

package com.itheima;//单例模式//饿汉式,直接把对象构造出来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 Test9910 {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);}}

枚举更加安全

enum Stu{

jake;//将构造方法私有化起来，反射也不能创建对象，安全private Stu(){}}public class Demo {public static void main(String[] args) {}}

final关键字

1 final可以修饰类，方法，变量

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

3 final修饰的方法不可以被覆写，但是可以覆写父类方法

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

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

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

final不能被继承 final修饰最终类 或者最终方法

抽象类

当编写一个类时 我们常为该类定义方法，这些方法用来描述该类的行为方式

那么这些方法都有具体的方法体

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

抽象类的定义：通过abstract关键字来修饰

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

可以理解为：具有某些公共方法的一个总结类

抽象类可以含有普通方法

抽象类不能创建实例对象不能new

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

列举常见的几个抽象类

流的四个基本父类

InputStream,OutputStream,Reader,Writer

总结

抽象类是类的一种特殊情况，具有类的一切特点，但不能实例化；

一般都带有抽象方法

抽象类不可以实例化，有时看到的近似实例化是多态机制的体现，并不是真正

的实例化

抽象类是不能够实例化的类:
它的作用就是产生子类的同时给于子类一些特定的属性和方法.
来个简单的例子...
如果你的程序里面需要用到苹果和梨这2个类..那么你可以分别给出这2个类
但是你会发现这2个类里面有共同的属性和方法(属性: 都有核.. 方法: 都需要削皮吃...)那么你可以建立抽象类 "水果" 把这些共同的东西都定义在那里. 那么你的2个子类就只需要实其他必要的东东了(味道, 价格...)


优点: 当你需要对苹果和梨做新的,共同的修改或者添加的时候. 你现在就可以直接对他们的超类 水果 做就可以了.

Socket s = new Socket();OutputStream os = s.getOutputStream();左边是OutputStream类型变量的声明，右边是获取抽象类OutputStream的一个实例对象！package testDemo2;abstract class Person{}class Student extends Person{}public class Demo2 {public static void main(String[] args) {Person p = new Student();//体现的是多态，父类声明实例化子类对象。而不是抽象类实例化}}