学习java的第四天（2024.7.17）

于 2024-07-17 21:18:09 发布
阅读量865 收藏 20
点赞数 21
文章标签： 学习 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tuowenjian/article/details/140500194
版权

1.Object类：

Java语言是一门面向对象的语言，在Java的所有的引用类型（注意：所有引用类型的默认值都为null）中，都默认引用了Object类，Object类是所有类的终极父类。

2.在引用类型中==比较的是地址是否相同，每创建一个新对象，这个新对象都会分配到一个新地址

public class EasyObject { 
    public static void main(String[] args) {
        Object obj = new EasyObject();
        Object objA = obj;
        Object objB = new EasyObject();
        //在引用类型中==比较的是地址是否相同
        System.out.println(obj==objA);//相同对象为true
        System.out.println(obj==objB);//不同对象为false
    }
}

3.Object类中的toString()方法

public class EasyObject { 
    public static void main(String[] args) {
        Object obj = new EasyObject();
        System.out.println(obj);
        System.out.println(obj.toString()); 
        //直接输出obj和输出obj.toString()方法的效果是一样的，默认调用obj.toString()方法 
        //在不重写obj.toString()方法时，返回的是对象存储的地址      
    }
}

4.Object类中还有许多方法

5.封装类：

  java是面向对象的，所有独立的内存都是对象！！！java为了实现万物皆对象的理念，给每一个基本数据类型都提供了对应的封装类型

int a=12;

此处a不是Object，a不是对象，本数据类型记录的是数值，不是面向对象的
基本数据类型的封装类型

byte short int long 分别对应Byte Short Integer Long

float double 分别对应Float Double

char 对应Character

boolean 对应Boolean

采用封装类的原因：可以更好地迎合java万物皆对象的理念

6.装箱与拆箱

public static void main(String[] args) {
        //基本数据类型的封装类   可以和基本数据类型无障碍转换
        Integer i=12;;
        Double d=12.2;
        System.out.println(i);
        System.out.println(d);
        //基本数据类型转化成对应的封装类型的过程：装箱
        //将封装类型转化成对应的基本数据类型：拆箱
        //装箱和拆箱是自动完成的！！！！！！！！！！！！
    }

7.封装类型的缓存

public static void main(String[] args) {
        //12-->Integer 12
        //基本数据类型的封装类型的缓存(缓存了一个byte的范围-128~127)
        //整数类型都有缓存-128~127，浮点型都没有缓存，字符型Character缓存范围0~127
        //只有Integer类型的范围可以调整
        // -XX:AutoBoxCacheMax=<size>这段底层代码可以改变封装类型缓存的范围
        Character intA = 0;
        Character intB = new Character('\u0000');
        System.out.println(intA==intB);
        Integer intC = 200;
        Integer intD = 200;
        System.out.println(intC==intD);
        Boolean bb=true;
        Boolean cc=true;
        System.out.println(bb==cc);

        System.out.println("-------------------");
        //基本数据类型和封装类型进行比较：
        //封装类型拆箱之后再进行比较，拆箱成基本数据类型的值，此时==比较的是基本数据类型的值知否相同
        //封装类型之间只要类型不同，就不能进行比较
        Integer intN=12;
        int iN=12;
        System.out.println(intN==iN);
        Double dN=12.0;
        System.out.println(dN==iN);
                new Byte("12");
        new Short("12");
        new Long("12");
        new Float("12.0");
        new Double("12.0");
        new Character('a');
        Integer.valueOf("34");//返回封装类型   将字符串转化成int类型
        Integer.parseInt("12");//返回int类型
        System.out.println(Integer.valueOf("34"));//输出34
        System.out.println(Integer.parseInt("12"));//输出12
    }

8.包：包 package声明包 声明包必须放在代码的第一行

package com.easy0717;

上面声明包的代码要放到类的第一句！！！

        // 使用本包下的类不需要导包
        // 使用其他包下的类需要导包    import java.util.*   *表示导入包下的全部类
        // 所有的类默认引入java.lang包

        //import不能导入两个重名的包
        //类名重名的情况下，可以使用类的全名指定具体使用哪个类
        new com.easy0714.EasyA();
        new com.easy0715.EasyA();

        //包是有封装性的，没有子父之间的关系
        int[] arr = {1,2,3,4,5};
        Arrays.toString(arr);

想要导入包时，用import关键字，可以将其他包下的类导入。

import java.util.Arrays;
import java.util.List;
import java.util.*//此行代码用*表示导入java.util包下的所有类

9.static关键字

static意为：    静态的     属于此类的

class StaticObject{
    int age;
    static int maxAge;

    //静态方法中不能直接调用非静态的属性和方法，方法里创建对象后再调用非静态的属性和方法是可以的
    static void method(){
      age=22;
    }

    //静态方法中创建对象再调用静态属性和方法是可以的
    static void method(){
        new StaticObject().maxAge=99;
    }

    //对toString()方法进行重写,使输出时显示变量age和静态变量maxAge
    @Override
    public String toString() {
        return "StaticObject{" +
                "age=" + age +
                "maxAge=" + maxAge +
                "}";
    }
public class EasyStatic {
    public static void main(String[] args) {
        StaticObject sta = new StaticObject();
        StaticObject stb = new StaticObject();
        sta.age=22;
        stb.age=33;
        //static修饰的属性是属于类的，可以使用类名之间的调用（即静态）static修饰的属性和方法
        StaticObject.maxAge=260;
        //静态属性对本类所有的对象是共享的
        //本类的对象也可以调用静态的属性和方法，调用的方式还是静态方式
        System.out.println(sta);
        System.out.println(stb);
    }
}

10.抽象类：

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

public abstract class EasyAbstract {

}

抽象类有以下两条特征：1.抽象类没有直接实例（不能new） 2.抽象类中可以定义抽象方法（也可以不定义）

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

public abstract class EasyAbstract {
    //抽象方法    使用abstract修饰的方法
    //抽象方法没有方法体
    public abstract void methodB(int a,double b);//methodB就是抽象方法
}

 抽象类定义出来的目的：让其他类继承抽象类

注意：1.实体类想要继承抽象类，就必须重写（实现）抽象类中的抽象方法

           2.抽象类继承抽象类可以不实现抽象方法，抽象类也可以继承实体类（默认继承Object）

class Son extends EasyAbstract{//Son是实体类
    //实体类继承抽象类必须实现抽象类中的抽象方法
    public void methodB(int a,double b){

    }
}
abstract class SonA extends EasyAbstract{
    //抽象类继承抽象类可以不实现抽象方法
}

11.抽象类的实例：

首先定义一个卡车抽象类，抽象类里定义一个传入字符串类型的地址的参数（注意抽象方法没有方法体）

public abstract class AbstractTruck {
    public abstract void transport(String addresss);
}

创建大卡车，小卡车两个实体类（后面要用实体类创建对象），两个实体类都继承自卡车抽象类：

class BigTruck extends AbstractTruck{
    @Override
    public void transport(String address){
        System.out.println("大开车开往"+address);
    }
}
class SmallTruck extends AbstractTruck{
    @Override
    public void transport(String address){
        System.out.println("小卡车开往"+address);
    }
}

创建测试类:

创建实体类对象，传入地址参数并输出

class Test{
    public static void main(String[] args) {
        BigTruck a = new BigTruck();
        a.transport("北京");
        SmallTruck b = new SmallTruck();
        b.transport("上海");
    }
}

12.final关键字

final：最终的

final有以下三个用途：1.final写在类前面，表示这个类不能被继承（最终的类）

2.final写在方法前面，表示这个方法不能被重写（最终的方法）

3.final写在变量前面，表示变量不能被重新赋值"="（最终的变量）

final int[] arr={1,2,3};
//arr=new int[3];//不行（重新赋值）
arr[2]=30;//可以（内容改变）

对于final修饰变量的情况：

在final修饰变量时，要么直接在此句中进行初始化，要么使用构造函数进行初始化

public class EasyFinal {
    final int height=10;//final使用时必须先对变量进行初始化  1.直接赋值2.new对象时初始化

    public static void main(String[] args) {
        final int a=12;
    }
}

13.接口

创建接口：

interface IVehicle{
    void transport();
}

接口中可以定义属性，但是接口中定义的属性都是常量，默认为public static final修饰的常量

interface IVehicle{
    public static final String MAX_SPEED="20000";//常量必须初始化
    String MIN_SPEED="10";//常量必须初始化
    void transport();
}

 接口中只能定义抽象方法：接口中定义的方法默认为public abstract修饰

interface IVehicle{
    public static final String MAX_SPEED="20000";//常量必须初始化
    String MIN_SPEED="10";//常量必须初始化
    void transport();

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

在Java中类可以用implements关键字来实现接口：

class ObjectInterface implements IVehicle{
    public void transport(){}
}

 一个类可以实现多个接口，实现多个接口时逗号隔开“，”：

class ObjectInterface implements IVehicle,Cloneable, Serializable {
    public void transport(){}
}

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

这时可以使用@FunctionalInterface注解验证

14.克隆

1.被克隆的对象必须实现Cloneable()接口 2.重写克隆接口（类的外部）

    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;

    @Override
    public String toString() {
        return "Student{" +
                "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 +
                '}';
    }
}

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

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                '}';
    }
    public Object clone() throws CloneNotSupportedException{
        //克隆自身也要克隆关联的属性
        Object obj = super.clone();//将当前的对象克隆一份
        Object objTeacher = this.teacher.clone;//将当前对象的teacher属性克隆一遍
        //将克隆出来的teacher对象赋值给克隆出来的Student对象中
        ((Student)obj).teacher=(Teacher) objTeacher;
        return obj;
    }

}

AKA 埼玉
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值