7-17学习笔记

L14173233

已于 2024-08-03 14:15:56 修改

阅读量1.1k

点赞数 23

文章标签：学习笔记

于 2024-07-17 18:50:14 首次发布

本文链接：https://blog.csdn.net/L14173233/article/details/140488625

版权

一、Object类

java是面向对象的，在java中所有的引用类，默认继承了Object类
所有引用类型的默认值是null

    Object方法：getClass()、hashCode()、equals()、clone()、toString()、notify()、
                notifyAll()、wait()、finalize()

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

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

二、封装类

java是面向对象的所有的内存都是对象

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

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

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

基本数据类型的封装类型
byte  short   int     long    float  double  char       boolean
Byte  Short  Integer  Long    Float  Double  Character  Boolean

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

封装类型间不能相互转换但可以向上转型

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

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

2、缓存机制

    基本数据类型的封装类型的缓存 
        整数类型 1个byte  -128~127  只有Integer类型的范围可以调整 
        通过代码-XX:AutoBoxCacheMax=<size>进行调整
        浮点型没有缓存
        字符型 Character  0~127
        布尔型 Boolean 有缓存

        基本数据类型与对应的封装类型比较，封装类型拆箱后比较

封装类型可以自动把对应基本数据类型或String装箱成封装类型

三、包

        package  声明包

使用本包下的类不需要导包
使用其他包的类需要导包  import java.util.* 导入java.util包下所有的类
所有类默认引入java.lang
类名重名的情况下 可以使用类的全名(包名.类名)指定具体使用哪个类
包具有封装性，没有子父关系 父包中的类不能直接使用子包中的类

四、static

        static    静态的    类的

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

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

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

        静态方法在子类中无法被重写

五、抽象类、抽象方法

1、抽象类

使用abstract修饰的类是抽象类
抽象类常用来被继承

抽象类没有直接实例不能new
抽象类中可以定义抽象方法也可以定义实现了的方法
抽象类中也可以定义构造方法

2、抽象方法

        抽象方法  使用abstract修饰的方法
        抽象方法没有方法体
        抽象方法被子类重写

3、继承抽象类

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

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

六、final

       即最终的

final的用途
         1 final可以修饰类  不能被继承的类
         2 final可以修饰方法   不能被重写
         3 final可以修饰量   不能被重新赋值  =

在类中定义的用final修饰的属性可以直接用=赋值或在构造方法中初始化

七、接口

接口中只能定义方法，但没有方法体
接口中的方法叫做抽象方法  --没有具体实现的方法
接口中定义的方法默认使用public abstract修饰

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

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

接口里不能定义构造方法

如果一个接口中只有一个未实现的方法，这个接口称为函数式接口
@FunctionalInterface表示下方接口是函数式接口

接口使用extends继承接口 可以多继承 但可能会有方法冲突 
例如：父接口1有int test(); 父接口2有void test();

java使用implements声明一个类实现接口
一个类可以实现多个接口

八、深浅拷贝

        克隆（拷贝）  被克隆的对象的类必须实现Cloneable接口

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);
    }
}

class Student implements Cloneable{

    Teacher teacher;

    public Object clone() throws CloneNotSupportedException {

        return super.clone();
    }
}

浅拷贝  只拷贝自身内存  不拷贝关联的属性

public class Easy {

    public static void main(String[] args) throws CloneNotSupportedException {
        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(obj);//李世民
        System.out.println(stu);//李世民

    }
}

class Student implements Cloneable{

    Teacher teacher;

    @Override
    public String toString() {
        return "Student{" +
                "teacher=" + teacher +
                '}';
    }


    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

class Teacher implements Cloneable{
    String name;

    public Teacher(String name){
        this.name=name;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                '}';
    }
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

深拷贝拷贝自身内存也拷贝关联的属性

public class Easy {
    public static void main(String[] args) throws CloneNotSupportedException {
        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(obj);//唐僧
        System.out.println(stu);//李世民

    }
}

class Student implements Cloneable{
    Teacher teacher;

    @Override
    public String toString() {
        return "Student{" +
                "teacher=" + teacher +
                '}';
    }


    public 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;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                '}';
    }
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}