Java学习（第四日）-CSDN博客

本文链接：https://blog.csdn.net/m0_66102016/article/details/140501095

包装类（Java面向对象所有内存都是对象）

int a = 12;
/* a不是Object a不是对象
基本数据类型记录的是数值，不是面向对象的
java为了实现万物皆对象的理念，给每一个基本数据类型提供了对应的封装类型*/

基本数据类型整数类型及其封装类型
基本数据类型	byte	short	int	long
封装类型	Byte	Short	Integer	Long

基本数据类型浮点数类型及其封装类型
基本数据类型	float	double
封装类型	Float	Double

基本数据类型字符类型及其封装类型
基本数据类型	char
封装类型	Character

基本数据类型布尔类型及其封装类型
基本数据类型	boolean
封装类型	Boolean

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

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

注意：基本数据类型和对应的封装类型比较，封装类型拆箱后比较

给封装类型对象赋值时必须使用相应的基本数据类型的数据

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

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

字符类型缓存范围 0~127

布尔类缓存就两个：true和false

包（package）

package a.b.c;//声明包

导包

import java.util.Arrays;
//import java.util.*;（使用"*"导入包下所有类）

注意：

1.所有的类默认引入java.lang包

2.使用本包下的类不需要导包，使用其他包下的类需要导包

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

com.easya.EasyA;
com.easyb.EasyA;

关键字static

static 静态的类的

class StaticObject{
    int age;//成员属性
    static int maxAge;//类的属性

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

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

public static void main(String[] args) {
        StaticObject staA = new StaticObject();
        StaticObject staB = new StaticObject();
        staA.age = 22;
        staB.age = 33;

        //static修饰的属性是属于类的  可以直接用类名直接调用static修饰的属性和方法
        StaticObject.maxAge = 260;
        
        //本类的对象也可以调用静态的属性和方法，调用的方式还是静态方式
        staA.maxAge = 270;

        //静态属性对所有的对象是共享的
        System.out.println(staA);//age=22  maxAge270
        System.out.println(staB);//age=33  maxAge270
    }

抽像类
使用abstract修饰的就是抽象类
抽象类没有直接实例不能new（实例化对象）
抽象类中可以定义抽象方法

public abstract class EasyAbstract {
    EasyAbstract(){

    }

    //抽象类用来被继承
    public void methodA() {

    }
    //抽象方法   使用abstract修饰的方法
    //抽象方法没有方法体
    public abstract void methodB(int a,double b);
}
class Son extends EasyAbstract {
    //实体类继承抽象类必须实现抽象类中的抽象方法(重写)
    @Override
    public void methodB(int a, double b) {
    }
}
abstract class SonA extends EasyAbstract {
    //抽象类继承抽象类可以不实现抽像方法
}

关键字final 最终的

final的用途：

1.final可以修饰类不能被继承的

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

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

public class EasyFinal {
    //final int height = 180;// 直接初始化
    public EasyFinal() {
        height = 180;
    }// 在构造方法中初始化

    public static void main(String[] args) {
        final int a = 22;
        //a = 11;不可以赋值
        final int[] arr = {1,2,3};
        //arr = new int[3];
        arr[2] = 44;//不能给arr赋值，但可以改变arr的内容arr[i]
    }

final class FinalClass{

}

//class AA extends FinalClass{不能继承
//
//}

接口（完全抽象的抽象类）

接口中只能定义方法，但是没有方法体

接口中不能定义构造方法

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

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

import java.io.Serial;
import java.io.Serializable;


@FunctionalInterface
//接口
interface IVehicle extends Cloneable,Serializable{
    public static final String MAX_SPEED = "200";//常量
    String MIN_SPEED = "10";//默认使用public static final修饰
    void transport();//接口中定义的方法默认使用 public abstract修饰

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

    }
}//如果一个接口中只有一个未实现方法，这个接口称为函数式接口

//Java中使用implements声明一个类实现接口
//一个类可以实现多个接口（单继承多实现）
//接口之间使用extends进行继承

public class EasyInterface {

}

class ObjectInter implements IVehicle, Cloneable, Serializable {
    @Override
    public void transport() {

    }
}

Object类（clone）

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

public class EasyObject {
    public static int num;
    //在引用类型中==比较的是地址是否一致
    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;
        objA=null;
        System.gc();//清理垃圾obj、objA，将会执行finallize方法
    }

    public String toString(){
        super.toString();
        return "this is a EasyObject";
    }
    @Override
    public void finalize(){
        //finalize方法是一个对象的最后执行的代码(要被销毁时)
        System.out.println("---------finalize");
    }
}

克隆（拷贝）

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(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对象赋值给克隆出来的Student对象中
        ((Student)obj).teacher = (Teacher)objTeacher;
        return obj;

    }
}
class Teacher implements Cloneable{
    String name;

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

深浅拷贝理解图