Java学习笔记4

ject类(clone)

Java是面向对象的，在Java里所有的引用类，默认继承Object

    //所有应用类型的默认值是null

    //在引用类型中==比较的是地址是否是一个

public static void main(String[] args) {

        Object obj = new EasyObject();

        Object objA = new EasyObject();

        System.out.println(obj==objA);

        System.out.println(obj.toString());

        System.out.println(obj);

        obj=null;

        System.gc();
}

public void finalize(){

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

        System.out.println("--------finalize------");

    }

包装类(缓存机制★)

//a不是Object  a不是对象

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

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

        基本数据类型的封装类型

        //byte  short    int    long

        //Byte  Short  Integer  Long

        //float  double

        //Float  Double

        //char

        //Character

        //boolean

        //Boolean

        基本数据类型的封装类型，可以和基本数据类型无障碍转换（直接转换） 

例：      

 Integer i = (int)12;//强制类型转换只是为了解释可以转换

        i.toString();//此时就有了方法



        Double d = 12.0;



        i = new Integer(22);

        int aa = new Integer(22);

基本数据类型的封装类型的缓存

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

        // 浮点型没有缓存

        //Character的缓存只有0~127

//        Integer intA = -128;

//        Integer intB = -128;

//        System.out.println(intA==intB);

//        Integer intC = 200;

//        Integer intD = 200;

自动装箱和拆箱★

//基本数据类型转换成对应的封装类型的过程：装箱

        //将封装类型转换成对应基本数据类型的过程：拆箱

        //这两个过程自动完成

package

//包   

        package  声明包

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

        //使用其他包的类需要导包    import java.util.*;

        //所有的类默认引入java.lang

        //类名重名的情况下可以使用类的全名指定具体使用哪个类

static★★

static 静态的  类的

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

StaticObject.maxAge=260;

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

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

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

class StaticObject{

    int age;

    static int maxAge;

    static void method(){

        new StaticObject().age=12;

    }



    @Override

    public String toString() {

        return "StaticObject{" +

                "age=" + age +

                "maxAge=" + maxAge +

                '}';

    }

}

//常量定义示例

public static final String MAX_SPEED="20000";

抽象类
abstruct

定义示例：

public abstract class EasyAbstract {}

    //抽象类

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

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

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

EasyAbstract(){



    }

    //抽象类可以用来继承    

public void methodA(){

    }

    //抽象方法  使用abstract修饰方法

    //抽象方法没有方法体    

public abstract void methodB(int a,double b);

}



class Son extends EasyAbstract{

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

    public void methodB(int a,double b){



    }

}

abstract class SonA extends EasyAbstract{

    //抽象类继承抽象类可以不实现抽样方法

}

final

1、final可以修饰类 不能继承的类
2、final可以修饰方法，不能被重写
3、可以修饰变量或者常量 不能被重新赋值

接口★

只能去定义方法，但是没有方法体  interface来声明

例如

@FunctionalInterface

interface IVehicle extends Cloneable{}

接口中的方法，叫做抽象方法--没有具体实现的方法

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

public static final String MAX_SPEED="20000";

String MIN_SPEED= "10";

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

例如：void transport();

接口中可以定义default修饰的实体方法

虽然使用default但是访问权限还是public

例如：

default void test(){



    }

Java中使用implements声明一个类实现接口

//一个类可以实现多个接口

//接口使用extends继承接口

interface IVehicle extends Cloneable{}

一个接口中只有一个未实现的方法，这个接口称为函数式接口

//可以使用FunctionalInterface来验证

例如开始的例子

深浅拷贝

一个接口中只有一个未实现的方法，这个接口称为函数式接口

//可以使用FunctionalInterface来验证

public class Easy {

    //克隆  只有对象才可以克隆

    //被克隆对象的类必须实现Cloneable接口

    //

    public static void main(String[] args) throws CloneNotSupportedException {

//        Student stu = new Student();

//        Object object = stu.clone();//克隆新的对象

//        System.out.println(stu);

//        System.out.println(object);





        //浅拷贝

        Teacher tea = new Teacher("张三");

        Student stu = new Student();

        stu.teacher= tea;

        System.out.println(stu);



        Object obj = stu.clone();

        System.out.println(obj);

        System.out.println("-------------");



        //深拷贝

        stu.teacher.name="崔佛";

        System.out.println(stu);

        System.out.println(obj);

    }

}

class Student implements Cloneable{



    Teacher teacher;



    @Override

    public String toString() {

        return "Student{" +

                "teacher=" + teacher +

                '}';

    }



    protected  Object clone() throws CloneNotSupportedException {

        //克隆自身的同时克隆关联的属性

        Object obj = super.clone();//将当前对象克隆

        Object objTeacher = this.teacher.clone();//将当前对象的teacher属性克隆一遍

        //将克隆出来的teacher对象赋值给克隆出来的Student对象中

        ((Student)obj).teacher=(Teacher)objTeacher;

        return obj;

    }

}





class Teacher implements Cloneable{

    String name;



    public Teacher(String name){

        this.name=name;

    }

    protected  Object clone() throws CloneNotSupportedException {

        return super.clone();

    }





    @Override

    public String toString() {

        return "Teacher{" +

                "name='" + name + '\'' +

                '}';

    }

}