Java基础（Day4）

m0_73629914

已于 2024-07-22 13:48:22 修改

阅读量830

点赞数 9

文章标签： java 开发语言

于 2024-07-18 09:32:14 首次发布

本文链接：https://blog.csdn.net/m0_73629914/article/details/140501176

版权

一、Object

1.Object类--所以类的父类

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

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

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

  Easy01_Object easyObject = new Easy01_Object();
        Easy01_Object easyObject1 = new Easy01_Object();

        System.out.println(easyObject==easyObject1);

1.1 toString方法

重写 toString方法

//重写toString方法

public String toString(){
        return "this is a easyObject";
    }

调用toString方法----System.out.println(easyObject.toString());

1.2 finalize()

 public void finalize(){
        //一个对象要被销毁时执行的代码（没有东西执行他时，他有可能会销毁，是一个对象最后执行的方法）
        System.out.println("-------");
    }

1.3基本数据类型封装类

为什么要有基本数据类型？
答：Java为实现万物皆对象的理念，给每一个基本数据类型提供了一个包装类

基本数据类型封装类

  byte    Byte
* short    Short
* int      Integer
* long     Long
*
* float     Float
* double    Double
*
* char     Character
*
* boolean   Boolean
* */

基本数据类型与基本数据类型封装类转换

基本数据类型转换成对应的封装类型的过程：装箱（自动完成）--ValueOf
将封装类型转换成对应的基本数据类型的过程：拆箱（自动完成

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

封装类与相对应的基本数据类型比较：封装类型拆箱变成基本数据类型之后再比较

//封装类与基本数据类型比较：封装类型拆箱变成基本数据类型之后再比较
        Integer IntN =12;
        int iN=12;
        System.out.println(IntN==iN);//TRUE

        Integer IntN1 =1200;
        int iN1=1200;
        System.out.println(IntN==iN);//TRUE

        Short sN=1200;
        System.out.println(sN==iN);//false
       Double dN=1200.0;
        System.out.println(dN==iN);//false

       // System.out.println(dN==IntN);

为基本数据类型的封装类型的提供了缓存（-128~127）：
整数类型都有缓存，缓存范围：-128~127，只有Integer类型的范围可以调整范围大小

浮点型没有，char有缓存（0-127），boolean有缓存

//为基本数据类型的封装类型的提供了缓存（-128~127）：
        //整数类型都有缓存，缓存范围：-128~127，只有Integer类型的范围可以调整
        // 浮点型没有，char有缓存（0-127），boolean有缓存
        Integer int1=12;
        Integer int2=12;

        System.out.println(int1==int2);//true--缓存对象
        Integer int3=1122;
        Integer int4=1122;
        System.out.println(int4==int3);//false

        Character intB =0;
        Character intA = new Character('\u0000');
        System.out.println(intB==intA);//false

将String 转化成数值型

//将String 转化成数值型
        Integer.valueOf("34"); //将String 转化成Integer
        Integer.parseInt("12"); //将String 转化成int

包 package
使用本包下的类不需要导包，使用其他包的类需要导包
所有类默认引入java.lang 包
类名重名时，可以使用类的全名，指定具体使用哪一个类
      ！！！！包具有封装性，没有子父之间的关系

包 package--声明包：约束不同功能的类
   //使用本包下的类不需要导包，使用其他包的类需要导包
   //所有类默认引入java.lang 包
    //类名重名时，可以使用类的全名，指定具体使用哪一个类
        //！！！！包具有封装性，没有子父之间的关系
    new com.easya.EasyA();
    new  com.easyb.EasyD();

二、抽象类

2.1抽象类

抽象类--使用abstract修饰的类
抽象方法没有方法体
可以没有抽象方法
/*都有构造方法

抽象类与普通类区别：
1.抽象类没有直接实例（不能new）
2.抽象类--使用abstract修饰的类 *

2.抽象类中可以定义抽象方法*/

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

抽象类的继承

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

2.2 Final

final 最后的，最终的
/*1。final可以修饰类---不能被继承的类

//Cannot inherit from final 'com.easy7_17.FinalClass'
//不能被继承
/*
class AA extends  FinalClass{

}*/

* 2.可以修饰方法名----不能被重写
* 3.可以修饰量---变量，常量---不能被重新赋值  =

  final int a=12;
       // a=11;  //3.可以修饰量---变量，常量---不能被重新赋值
       // static int b=12;//static 是累的，应该写外边--全局变量

注意点：
1.量没有抽象的
2.fianl与static时相互悖论的，上面两个结论 
3.stract与final相悖

可以直接赋值，或者在构造方法中进行赋值，一定要初始化，finnal不能重写赋值

2.3接口

接口中只能定义方法，但是没有方法体
//接口中的方法--抽象方法：没有具体实现的方法（没有方法体）--默认使用public abstract修饰
//接口中可以定义属性--必须是常量（接口中默认修饰 public static final）
//常量必须大写，必须要初始化
//static  类的  每个类只有一个内存

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

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

interface  IVechicle extends Cloneable,Serializable{
    //接口中只能定义方法，但是没有方法体
   
    void transport();
    public static final String  MAX_SPEED="20000";
    String  MIN_SPEED="10";

    default void test(){

    }

}


class ObjectInter implements  IVechicle,Cloneable, Serializable {

    public void transport(){

    }
}

//接口没有构造方法，抽象类中有构造方法
//抽象方法没有方法体
//空接口Cloneable  Serializable
//接口通过extends继承接口，继承
//抽象类可以实现接口

如果接口中只有一个没有实现（只有一个抽象方法）的方法，这个接口称为函数式接口，
可以使用@FunctionalInterface---都能用lambda表达式表示

2.4 Static

static  ：静态的  类的
* static修饰的属性是属于类的，可以使用"类名"直接调用static修饰的属性与方法
* 静态属性对所有的对象（本类的）是共享的
* 本类的对象也可以调用静态的属性与方法，调用的方式还是静态方式

注意点：

//静态方法中不能直接使用非静态属性和方法（类的不能直接使用对象的）

//有对象一定有类，有类不一定有对象，故静态方法不能直接使用非静态属性与方法（除非指定明确的对象，因为他不确定有没有类）

有static必须会有方法体，他是类的一开始加载完成的
//静态方法不能重写（属于类的）

想用类名直接调用就是要static  想用对象直接调用属性方法就要用非静态类

2.5 clone

为什么要有clone？

new 与反射都可以创建内容一模一样的对象，
// 但是我们创建对象之后需要set方法来设置相关的一摸一样的内容，
// 如果需要创建更多的内容一致的对象，就需要一直重复上述操作----clone

clone使用步骤：

使用object的clone方法--使用步骤：
* 1.在需要调用clone方法的对象上添加实现cloneable接口
* 2.复写clone方法，在自己的clone方法中调用父类的clone方法，将返回值强转成本类类型,
*    将当前修饰符改成public
* 3.在测试中调用对象的clone方法

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

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