包装类(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();
}
}
深浅拷贝理解图