0基础学JAVA！！！（第四天）

标签：JAVA String 基础 System 接口第四天 println 抽象类 public

1.包装类

整型：

Byte，Short，Integer，Long

浮点型:

Float，Double

字符型:

Character

布尔型：

Boolean

         Integer inta=21;
         Integer intb=12;
        System.out.println(inta==intb);
        Integer intac=200;
        Integer intc=200;
        System.out.println(intc==intac);
        Boolean bb=true;
        Boolean cc=true;
        Character intA=0;
        Character intB='\u0000';
        Character intC=new Character('\u0000');
        System.out.println(intA==intB);

装箱：

将基本数据类型转换成对应的包转类就是装箱

        Integer.valueOf("34");
        Integer.parseInt("12");

拆箱：

将包装类转换成对应的基本数据类型就是拆箱

包装类和基本数据类型比较的时候一般是先拆箱再比较

缓存：

包装类都有缓存，是因为在装箱操作的时候为了少占用内存，有一个字节的缓存范围是-128---127(只有int类型的缓存范围可以调整用：-XX:AutoBoxCacheMax= )，如果需要的数值在缓存范围内直接从缓存里面拿出，不需要再new一个

         Integer inta=21;
         Integer intb=12;
        System.out.println(inta==intb);
        Integer intac=200;
        Integer intc=200;
        System.out.println(intc==intac);

整型，字符型，布尔型都有缓存

浮点型没有缓存

装箱和拆箱的操作都是自动完成的

2.包：package

1.在创建类的时候，用package包声明

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

3.*代表所有的包都需要导入

4.所有的类默认导入java.lang

5.在类重名的情况下，使用类的全称声明所需要使用的类（重名不能都导入）

6.包之间是有封装性的，没有子父之间的关系，cahpter3包下面的test包下的Circle类不属于cahpter3包

package java.lang;

import jdk.internal.misc.CDS;
import jdk.internal.misc.VM;

3.static关键字

static 静态的类的

    int age;//(非静态)
    int age1;
    static int maxAge;（静态的）

1.static修饰的属性是属于类的   
2.可以使用类名直接调用static修饰的属性和方法
Static Object.maxAge=22;
3.静态属性对所有的对象是共享的
4.本类的对象也可以调用静态的属性和方法，
5.静态方法中不能直接调用非静态的属性，但是用对象可以调用

4.抽象类

1.抽象类

定义抽象类用abstract

抽象类中会有抽象方法，抽象类是需要被继承的，在实体类继承抽象类之后需要重写方法，抽象类没有直接实例，不能new ，但是有构造方法

在抽象类继承抽象类的时候，可以不实现抽象方法

1.抽象类中可以定义抽象方法

2.抽象类可以用来被继承

示例：实现写一个抽象卡车类，定义一个运输的抽象方法接受一个地址字符串大卡车小卡车继承卡车类（这个示例用到抽象类继承，抽象方法重写等知识）

public abstract class EasyAbstract{
    public static void main(String[] args) {
        Bigkache k=new Bigkache();
        kache  k1=new Smallkache();
        k1.yunshu("我的家");
        k.yunshu("我的家");

    }
 abstract class kache{
    public abstract void yunshu(String dizhi);
    }
 class Smallkache extends kache{
    @Override
        public void yunshu(String dizhi){
        System.out.println("小卡车开往"+dizhi);
    }
    }
class Bigkache extends kache{
    @Override
    public void yunshu(String dizhi){
        System.out.println("大卡车开往"+dizhi);
    }


}

2.抽象方法

抽象方法   使用abstract修饰的方法
抽象方法没有方法体（没有大括号）

接口中定义的方法都是抽象方法，没有具体的方法体

接口中可以定义属性，但是定义的属性都是常量，String MAX_SPEED="2222",在Sring类型前面默认有public static final，也可以写public String MAX_SPEED="2222"，在中间都会默认加上，在这里面必须声明常量必须初始化,下面这三种情况都可以

public static final String MAX_SPEED="20000";
 public  String MAX_SPEED="20000";
 String MAX_SPEED="21512"

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

5.接口

1
JAVA中使用implements声明一个类实现接口
一个类可以实现多个接口
一个接口可以被多个类实现
一个接口使用extends继承接口

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

interface IVehicle extends Cloneable{
default void test(){}
public static final String MAX_SPEED="20000";
        String MIN_SPEED="90";
void transport();
}
}

如果接口中只有一个未实现的方法，那这个接口称为函数式接口，上图中的void transport（）;可以使用@FunctionalInterface验证

class ObjectInter implements EasyInterface.IVehicle ,Cloneable, Serializable {
    //JAVA中使用implements声明一个类实现接口
    //一个类可以实现多个接口
    //一个接口使用extends继承接口
    @Override
    public void transport(){


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

6.final

final可以修饰类，这样这个类就不能被继承

final可以修饰方法，这样这个方法不能被重写

final可以修饰属性，这样这个属性在第一次被赋值之后不能被再次赋值

下面这些代码都可以，初始化之后就不能在变化了

final int height；
heigh=21；

        final int[] arr={1,2};
        arr[1]=12;//虽然用final修饰了，但是可以给他赋值

7.深浅拷贝

克隆要实现必须要实现Cloneable接口，如果在类外面要实现克隆，那么需要重写

浅克隆：复制了一份与自己相同的值，并且一起指向与自己相关的对象

深克隆：复制了一份与自己相同的值，并且复制了一份与自己的相关的对象，分别指向对应的对象

  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(stu);
        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 +
                '}';
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Teacher implements Cloneable {
    String name;
public  Teacher(String name){
    this.name=name;
}
    public Object clone() throws CloneNotSupportedException {
    //克隆自身的同时，也要克隆关联的属性
        Object obj=super.clone();//将当前对象克隆一份
        Object objTeacher=this.teacher.clone();//将当前对象属性克隆一份
        ((Student)obj).teacher=(Teacher)objTeacher;
        return obj;
    }
    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                '}';
    }
}

这是实现克隆的方法

标签：JAVA,String,基础,System,接口,第四天,println,抽象类,public
From： https://blog.csdn.net/m0_73570063/article/details/140499521