java笔记day4

1.Object

Object类是java层次最顶层的基类（父类），java中所有的引用类都默认继承Object

所有引用类型的默认值是null

在引用类型中 " == " 是比较地址是否是同一个

finalize方法是一个对象的最后执行代码（要被销毁时）

package com.easy717;

public class EasyObject extends Object{
    //Object类
    //java是面向对象的，在java中所有的引用类默认继承Object
    //所有引用类型的默认值是null

    //在引用类型中 == 比较地址是否是同一个
    public static void main(String[] args){
        Object obj=new EasyObject();//向上转型

//        Object objA=obj;
//        System.out.println(obj==objA);//ture
        Object objB=new EasyObject();//new就是创建了一个新的对象
        System.out.println(obj==objB);//true
        System.out.println(obj.toString());
        obj=null;//让obj对象没有指向
        System.gc();
    }
    public String toString(){//重写toString方法
        return "this is a EasyObject";
    }

    @Override
    public void finalize(){
        //finalize方法是一个对象的最后执行代码（要被销毁时）
        System.out.println("-----finalize");
    }

}

2.包装类（缓存机制）

基本数据类型记录的是数值，不是面向对象的

java为了实现万物皆对象的理念，给每一个基本数据提供了对应的封装内容

基本数据类型的封装类型：

	byte	short	int	long	float	double	char	boolean
封装类型	Byte	Short	Integer	Long	Float	Double	Character	Booloean

基本数据类型的封装类，可以和基本数据类型直接转换

        Integer i=12;
        Double d=12.0;
        i=new Integer(22);
        int aa=new Integer(22);
        System.out.println(i+33);

3.装箱：把基本数据类型转换成对应的封装类型的过程叫做封箱

拆箱：把封装类型转换成对应的基本数据类型的过程叫做拆箱

4.基本类型的封装类型的缓存

整数类型缓存范围-128~127，只有Integer的范围可以调整

Character缓存范围是0-127

 //     Character缓存范围0-127
        Character intA=0;
//        Character intB='\000';
        Character intB= new Character('\000');
        System.out.println(intA==intB);
//        Integer intA=-129;//超出范围值就为false
//        Integer intB=-129;
//        //Long intA=127L;Long不能直接赋值int型,要在数值后加L
//        System.out.println(intA==intB);
//        Integer intC=200;
//        Integer intD=200;
//        System.out.println(intC==intD);

基本数据类型和封装类型比较，封装类型拆箱后再比较

        Number num=new Integer(12);//向上转型

        Integer intN=1200;
        int iN=1200;
        System.out.println(intN==iN);

封装类型一定是一个封装类型，封装类型之间类型不一样就不能比较

        Short sN=1200;
        System.out.println(sN==iN);//封装类型一定是个数值类型
        //封装类型之间类型不一样就不能比较
        Double dN=1200.0;
        System.out.println(dN==iN);
        new Byte("12");
        new Short("12");
        new Float("12");
        new Double("12");
        new Character('a');
        Integer.valueOf("34");//将字符转换成数值
        Integer.parseInt("12");//把字符串转换成数值

valueof, parseInt作用：将字符串换成数值

5.包 package

使用本包下的类不需要导包

使用其他包的类需要导包

所有的类默认引入Java.lang包

类名重名的情况下可以使用类的全名指定具体使用哪一个类  类全名：包名+类名

包有封装性，包和包之间没有子父关系

6.static

static 修饰的属性是属于类的  静态的

可以使用类名直接调用static修饰的属性和方法

静态属性对所有本类的对象是共享的

本类的对象也可以调用静态的属性和方法，调用的方式还是静态方式

静态方法中不能直接调用非静态的属性和方法

package com.easy717;

public class EasyStatic {
    public static void main(String[] args) {
        StaticObject staA=new StaticObject();
        StaticObject staB=new StaticObject();

        //static 修饰的属性是属于类的
        //可以使用类名直接调用static修饰的属性和方法

        //静态属性对所有本类的对象是共享的
        //本类的对象也可以调用静态的属性和方法，调用的方式还是静态方式
        StaticObject.maxAge=21;

        staA.age=22;
        staB.age=23;
        System.out.println(staA);
        System.out.println(staB);
    }
}
class StaticObject{
    //static 静态的 类的
    int age;//成员属性  非静态的
    //类的成员就是对象
    static int maxAge;
//空白行 右键 general

    static void method(){
//        age=22;//静态方法中不能直接调用非静态的属性和方法
        new StaticObject().age=22;
    }

    @Override
    public String toString() {
        return "StaticObject{" +
                "age=" + age +
                "maxAge="+maxAge+
                '}';
    }
}

7.抽象类

使用abstract修饰的类都是抽象类

抽象类没有直接实例  不能实例化（不能new）

抽象类中可以定义抽象方法

抽象类可以用来继承

抽象方法 ： 使用abstract修饰的方法   没有方法体

实体类继承抽象类，必须实现抽象类中抽象方法（重写）

重写：子类对父类中继承方法重新定义

抽象类实现抽象类可以不实现抽象方法

静态方法不能重写

8.final

final的用途：1.final可以修饰类 不能继承

2.final可以修饰方法  不能被重写

3.final可以修饰量  不能被重新赋值

9.接口

接口中只能定义方法，没有方法体（没有实现的能力）

接口中的方法 抽象方法：没有具体实现的方法

接口中可以定义属性，定义属性都是常量，常量必须全部大写，必须要初始化

接口中定义的属性都是常量，默认使用 public  static  final修饰

接口中定义的方法默认使用public abstra修饰

接口中可以定义default修饰的实体方法，虽然使用default修饰但是访问权限还是public

java中使用Implements声明一个类实现接口

一个类可以实现多个接口

如果一个接口中只有一个未实现的方法，那这个接口成为函数式接口

函数式接口：就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。

package com.easy717;

import java.io.Serializable;

public class EasyInterface implements IVehicle{


    @Override
    public void transport() {

    }

    @Override
    public void test() {
        IVehicle.super.test();
    }
}

@FunctionalInterface
//定义接口
//接口里面不能定义构造方法
    //extends Cloneable
interface IVehicle extends Cloneable{
    //接口中只能定义方法，没有方法体（没有实现的能力）
    //接口中的方法 抽象方法 ： --没有具体实现的方法
    //接口中可以定义属性，定义的属性都是常量
    //接口中定义的属性都是常量，默认使用public static final修饰

    //常量必须全部大写，必须要初始化
    public static final String MAX_SPEED="1000";
    //public static final 修饰
    String MIN_SPEED="90";
    //接口中定义的方法默认使用publi abstract修饰

    void transport();
    //接口中可以定义default修饰的实体方法
    //虽然使用default修饰但是访问权限还是public
    default void test(){

    }
}

//java中使用implements声明一个类实现接口
//一个类可以实现多个接口
//接口使用extends继承接口

//如果一个接口中只有一个未实现的方法，这个接口成为函数式接口
class ObjectInter implements IVehicle,Cloneable, Serializable {
    public void transport(){

    }
}

10.深浅拷贝

Object clone() 方法用于创建并返回一个对象的拷贝。

为什么要有clone？
new 与反射都可以创建内容一模一样的对象，
但是我们创建对象之后需要set方法来设置相关的一摸一样的内容，

如果需要创建更多的内容一致的对象，就需要一直重复上述操作----clone
clone使用步骤：
使用object的clone方法--使用步骤：
* 1.在需要调用clone方法的对象上添加实现cloneable接口
* 2.复写clone方法，在自己的clone方法中调用父类的clone方法，将返回值强转成本类类型,
*    将当前修饰符改成public
* 3.在测试中调用对象的clone方法
 

clone 方法是浅拷贝，对象内属性引用的对象只会拷贝引用地址，而不会将引用的对象重新分配内存，相对应的深拷贝则会连引用的对象也重新创建。

返回值：返回一个对象的拷贝。

由于 Object 本身没有实现 Cloneable 接口，所以不重写 clone 方法并且进行调用的话会发生 CloneNotSupportedException 异常。

以下实例创建了 obj1 对象，然后拷贝 obj1 给 obj2，通过 obj2 输出变量的值：

实例：

class RunoobTest implements Cloneable {
 
    // 声明变量
    String name;
    int likes;
 
    public static void main(String[] args) {
 
        // 创建对象
        RunoobTest obj1 = new RunoobTest();
 
        // 初始化变量
        obj1.name = "Runoob";
        obj1.likes = 111;
 
        // 打印输出
        System.out.println(obj1.name); // Runoob
        System.out.println(obj1.likes); // 111
 
        try {
 
            // 创建 obj1 的拷贝
            RunoobTest obj2 = (RunoobTest) obj1.clone();
 
            // 使用 obj2 输出变量
            System.out.println(obj2.name); // Runoob
            System.out.println(obj2.likes); // 111
        } catch (Exception e) {
            System.out.println(e);
        }
 
    }
}