Java学习Day4

Object类

Java面向对象，所有的内存都是对象。

Object类是所有类的父类。

Object的方法：

equals()方法            getClass()方法                 hashCode()方法                 clone()方法                      toString()方法          notify()方法                         wait()方法                         finalize()方法

在定义基本数据类型时 int a=10;其中a不是对象，基本数据类型是记录数值的，不是面向对象的。Java为了实现万物皆对象的理念，给出了每一类数据类型的封装过程，基本数据类型的封装过程：

Byte（byte）  Short(short)  Integer(int) Long(long)

Float(float) Double(double) Character(char) Boolean(boolean)

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

装箱：基本数据类型转换为对应封装类型的过程

拆箱：封装类型转换成对应基本数据类型的过程

Integer i=12;
Double d=12.0;
i.toString();
i=new Integer(10);

封装后的数据类型进行比较时，有一个缓冲区，整数类型的缓冲区范围为-128~127，浮点数没有缓冲区，char类型的缓冲区是0~127。Boolean类型也有缓冲区（true和flase）只有Integer类型的范围可以调整-XX:AutoBoxCacheMax=<size>

基本数据类型和封装类型之间的比较是拆箱之后进行比较

封装类型之间不同的封装类型是不能进行比较

包package

所有类默认引用的包为java.lang包，使用本包下的类不需要引用，使用其他包下的类需要引入外包。

类在重名的情况下需要使用类的全名来具体指定是那个包下的类
包是封装性，没有继承性

Abstract 修饰抽象类
抽象类没有直接实例 不能new
抽象类中可以定义抽象方法，抽象方法没有结构体，既没有{}

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

实体类继承抽象类的必须要实现父类的抽象方法，必须重写抽象方法

抽象类继承抽象类不必重写抽象方法，抽象类也可以继承抽象方法。

抽象继承实例

abstract  class CarAbstract {
   public void trans(String str){
    }
    public abstract void tran(String str);
}
class SmallCar extends CarAbstract{
    @Override
    public void tran(String str){
        System.out.println("小卡车运输到"+str);
    }
}
class BigCar extends CarAbstract{
    @Override
    public void tran(String str){
        System.out.println("大卡车运输到"+str);
    }
}
public class TestCar{
    public static void main(String[] args){
        SmallCar smallCar=new SmallCar();
        BigCar bigCar=new BigCar();
        smallCar.tran("beijing");
        bigCar.tran("nanjing");
    }
}

final

最终的  final的用途
1.final可以修饰类 不能继承的类
2.final 可以修饰方法  不能被重写
3.final可以修饰量 不能被重新赋值

final int height;
    public EasyFinal(){
        height=200;
    }
    public static void main(String[] args) {
        final int a=1;
        final int[] arr = {1,2,3};
        arr[2]=44;
    }
    public void test(final int a){
    }
final class FinalClass{
}

static

修饰的属性是属于类的  可以使用类名直接调用static修饰的属性和方法
StaticObject.maxAge=260;
静态对象对所有的对象是共享的（本类）

本类的对象也可以调用静态的属性和方法，调用的方式还是静态方法

class StaticObject{
    static 静态的 类
    int age;
    static int maxAge;
静态方法中不能直接调用非静态的属性和方法,但是可以通过非静态对象来调用属性
    static void method(){
        new StaticObject().age=12;
        //age =12;
    }

StaticObject staA=new StaticObject();
StaticObject staB=new StaticObject();
staA.age=22;
staB.age=33;

接口

Interface

接口中只能定义方法，但是没有方法体
接口中的方法为抽象方法 ，没有具体实现的方法
接口没有构造方法
接口定义属性，接口中定义的属性必须是常量,常量必须初始化.默认适用public static final修饰
接口中定义的方法默认使用public abstract修饰

public static final String MAX_SPEED="20000";
String MIN_SPEED="90";
void transport();

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

java中使用implements声明一个类实现接口
一个类可以实现多个接口
接口使用extends继承接口，一个接口可以继承多个接口（不能有冲突的方法）
如果一个接口中只有一个未实现的方法，这个接口称为函数式接口，可以使用@FunctionalInterface来验证
interface IVechicle extends Clones{}
    class ObjectInter implements IVehicle,Cloneable, Serializable {
       public void transport(){

       }

   }

克隆（clone）

只有对象才可以克隆，被克隆的对象的类必须实现Cloneable接口
在类外访问接口，要在类外重写clone方法

浅拷贝：被拷贝的对象的所有属性值都与原来的对象相同，而对象的所有属性引用仍然指向原来的属性所指向的内存地址。需要注意的是cloneObj == obj 返回的是false，所以使用的Object的clone（）是浅拷贝。

深拷贝：被拷贝的对象的所有属性值都与原来的对象相同，而对象的所有属性的引用都指向新的克隆出来的属性的内存地址。

深拷贝

public Object clone() throws CloneNotSupportedException {
    //克隆自身的同时克隆相关的属性
    Object obj = super.clone();//将当前对象克隆一份
    Object objTeacher= this.teacher.clone();//将当前对象的teacher属性克隆一遍
    //将克隆出来的Teacher对象赋值给克隆出来的Student对象中
    ((Student)obj).teacher=(Teacher)objTeacher;
    return obj;
}