ject类(clone)
Java是面向对象的,在Java里所有的引用类,默认继承Object
//所有应用类型的默认值是null
//在引用类型中==比较的是地址是否是一个
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;
System.gc();
}
public void finalize(){
//finalize方法是一个对象最后执行的代码(要被销毁时执行的代码)
System.out.println("--------finalize------");
}
包装类(缓存机制★)
//a不是Object a不是对象
//基本数据类型记录的是数值,不是面向对象的
//java为了实现万物皆对象的理念,给每一个基本数据类型提供了对应的封装类型
基本数据类型的封装类型
//byte short int long
//Byte Short Integer Long
//float double
//Float Double
//char
//Character
//boolean
//Boolean
基本数据类型的封装类型,可以和基本数据类型无障碍转换(直接转换)
例:
Integer i = (int)12;//强制类型转换只是为了解释可以转换
i.toString();//此时就有了方法
Double d = 12.0;
i = new Integer(22);
int aa = new Integer(22);
基本数据类型的封装类型的缓存
// 整数类型缓存就只有-128~127 只有Integer类型的范围可以调整
// 浮点型没有缓存
//Character的缓存只有0~127
// Integer intA = -128;
// Integer intB = -128;
// System.out.println(intA==intB);
// Integer intC = 200;
// Integer intD = 200;
自动装箱和拆箱★
//基本数据类型转换成对应的封装类型的过程:装箱
//将封装类型转换成对应基本数据类型的过程:拆箱
//这两个过程自动完成
package
//包
package 声明包
//使用本包下的类不需要导包
//使用其他包的类需要导包 import java.util.*;
//所有的类默认引入java.lang
//类名重名的情况下可以使用类的全名指定具体使用哪个类
static★★
static 静态的 类的
static修饰的属性是属于类的 可以使用类名直接调用static修饰的属性和方法
StaticObject.maxAge=260;
静态属性对所有的本类对象是共享的
本类的对象也可以调用静态的属性和方法,调用的方式还是静态模式
静态方法中不能直接调用非静态的属性和方法
class StaticObject{
int age;
static int maxAge;
static void method(){
new StaticObject().age=12;
}
@Override
public String toString() {
return "StaticObject{" +
"age=" + age +
"maxAge=" + maxAge +
'}';
}
}
//常量定义示例
public static final String MAX_SPEED="20000";
抽象类
abstruct
定义示例:
public abstract class EasyAbstract {}
//抽象类
//使用abstract修饰的类是抽象类
//抽象类没有直接实例 不能实例化不能new
//抽象类中可以定义抽象方法
EasyAbstract(){
}
//抽象类可以用来继承
public void methodA(){
}
//抽象方法 使用abstract修饰方法
//抽象方法没有方法体
public abstract void methodB(int a,double b);
}
class Son extends EasyAbstract{
//实体类继承抽象类,必须实现抽象类中的抽象方法(重写)
public void methodB(int a,double b){
}
}
abstract class SonA extends EasyAbstract{
//抽象类继承抽象类可以不实现抽样方法
}
final
1、final可以修饰类 不能继承的类
2、final可以修饰方法,不能被重写
3、可以修饰变量或者常量 不能被重新赋值
接口★
只能去定义方法,但是没有方法体 interface来声明
例如
@FunctionalInterface
interface IVehicle extends Cloneable{}
接口中的方法,叫做抽象方法--没有具体实现的方法
接口中定义属性都是常量 默认使用public static final修饰
public static final String MAX_SPEED="20000";
String MIN_SPEED= "10";
接口中定义的方法默认使用public abstract修饰
例如:void transport();
接口中可以定义default修饰的实体方法
虽然使用default但是访问权限还是public
例如:
default void test(){
}
Java中使用implements声明一个类实现接口
//一个类可以实现多个接口
//接口使用extends继承接口
interface IVehicle extends Cloneable{}
一个接口中只有一个未实现的方法,这个接口称为函数式接口
//可以使用FunctionalInterface来验证
例如开始的例子
深浅拷贝
一个接口中只有一个未实现的方法,这个接口称为函数式接口
//可以使用FunctionalInterface来验证
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(stu);
System.out.println(obj);
}
}
class Student implements Cloneable{
Teacher teacher;
@Override
public String toString() {
return "Student{" +
"teacher=" + teacher +
'}';
}
protected Object clone() throws CloneNotSupportedException {
//克隆自身的同时克隆关联的属性
Object obj = super.clone();//将当前对象克隆
Object objTeacher = this.teacher.clone();//将当前对象的teacher属性克隆一遍
//将克隆出来的teacher对象赋值给克隆出来的Student对象中
((Student)obj).teacher=(Teacher)objTeacher;
return obj;
}
}
class Teacher implements Cloneable{
String name;
public Teacher(String name){
this.name=name;
}
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
@Override
public String toString() {
return "Teacher{" +
"name='" + name + '\'' +
'}';
}
}