Java-2面向对象下

Object类的方法

toString

public String toString()

equals

默认使用==，但是很多需要重写比如String

public boolean equals(Object obj)

hashCode

public native int hashCode()

native表示实现的不是Java语言，散列码是整数，对象相同则散列码相同

子类重写equals则必须重写hashCode

不同的对象也可能具有相同的散列码，尽可能避免

finalize

protected void finalize() throws Throwable

垃圾回收，如果对象不再能被访问，则变成垃圾

Clone

protected native Object clone() throws CloneNotSupportedExeption

复制创建一个单独内存空间的新对象

getClass

public final native Class<?> getClass()

返回元对象；元对象为包含类信息的对象，包括类名，构造方法，方法

一个类只有一个元对象

1.什么是native方法-不是Java实现的

2.判断两个对象内容是否相同应该用-equals而不是==

3.重写equals有什么要求-hashCode也必须重写

抽象类和接口

抽象类-抽象而没有具体实例的类，关键字abstract

拥有数据域，方法和构造方法，但是不能用new操作符创建实例

抽象方法：使用关键字abstract修饰，只有方法签名但是没有具体的实现，实现由子类提供

因此抽象方法都不是静态的，因为自己实现不了，

非抽象类不能包含抽象方法；如果抽象类的子类无法实现所有的抽象方法，那么也必须声明为抽象类

但是抽象类也可以包含非抽象类的方法

接口-interface修饰，只包含可见性为public的常量和抽象方法

不包含变量和具体方法

不能用new

Java8开始接口方法可以由默认实现（原来只能public abstract），Java9开始允许定义私有方法

一个类只能继承一个父类，但是一个接口可以继承多个接口-子接口

抽象类和接口的区别：

抽象类可以有变量接口只有常量

抽象类有构造函数，子类通构造方法链调用构造方法，接口不包含

接口可以继承多个接口

自定义比较方法：

两个接口：

Comparable接口-类实现了这个接口，里面包含了抽象方法CompareTo,类实现了该接口后，就可以进行排序了，这样就是本身具有排序的能力了

Comparator是比较器接口、如果类本身不支持也就是没有实现上面那个接口，可以用比较器接口

包含两个抽象方法，compare在实现类中实现，equals默认已经都实现

排序时定义比较器

1.抽象类和接口是否可以被实例化

2.包含抽象方法的类是否必须被声明成抽象类？抽象类是否必须包含抽象方法？

3.从继承的角度而言，抽象类和接口的区别是什么？

4.从变量，构造方法和方法的角度，阐述抽象类和接口的区别

5.如何对一个数组中的多个对象按照不同的依据进行排序？

Arrays.sort(arrt,comparator1);

Arrays.sort(arrt,comparator2);

基本数据类型和包装类

基本数据类型-》不是对象--》包装成对象--称为包装类.8类

Byte->Short->Integer->Long->Float->Double

Character, Boolean

构造方法都是有参数的

实例都是不可变的----应该是说原对象不可变，比如1比如字符串

但是并不是说不可以

String str = "123";
str = "1";

此时str指的时一个新的内存空间，新的实例，所以原来的123并没有变得，不可变指的是原来指向得那个地址得内容不可以再变了。

基本数据类型得值转换为包装类---》装箱

反之拆箱

深入剖析Java中的装箱和拆箱 - Matrix海子 - 博客园

Integer a = new Integer(100);

自动装箱之后，就不需要那么麻烦。直接Integer a = 1; int b = a;

Integer.valueOf(), Integer.intValue()

Integer a = 100;
Integer b = 100;
Integer c = 200;
Integer d =200;
System.out.println(a==b);
System.out.println(c==d);

true;

flase;

-128,127范围得也就是byte范围得都是同一个对象原本存在得，但是超过这些得，就是new新的对象了。

深入理解Java中的不可变对象 - Matrix海子 - 博客园

面向对象思想

类的关系：

关联：二元关系

many to many

class Depositor{
    private List<Bank> bankList;
    public Depositor(){
        bankList = new ArrayList<Bank>();
    }
    public void addBank (Bank account){
        bankList.add(account);
    }
}


class Bank{
    private List<Depositor> depositorList;
    public Bank(){
        depositorList = new ArrayList<Depositor>();
    }
    public void addUser(Depositor depositor){
        depositorList.add(depositor);
    }
}

聚集和组合

聚集：特殊的关联形式，表示两个对象之间的从属关系

聚集模拟具有（has-a）关系

所有者对象称为聚集对象，对应的类称为聚集类

从属对象称为被聚集对象，对应的类称为被聚集类

一个对象可以被几个聚集对象所拥有，如果一个对象被一个聚集对象所专有，该对象和聚集对象之间的关系就称为组合

java里面的聚集 组合_JAVA中的聚集和组合的区别和联系_零溢的博客-CSDN博客

Java里组合和聚合的概念及其实现_「已注销」的博客-CSDN博客

在实际写代码时：
组合方式一般会这样写：
A类的构造方法里创建B类的对象，也就是说，当A类的一个对象产生时，B类的对象随之产生，当A类的这个对象消亡时，它所包含的B类的对象也随之消亡。
聚合方式则是这样：
A类的对象在创建时不会立即创建B类的对象，而是等待一个外界的对象传给它
传给它的这个对象不是A类创建的。
————————————————
版权声明：本文为CSDN博主「「已注销」」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_51945027/article/details/117406653

组合之间唇齿相依，但是聚集是弱关系

设计模式中聚合和组合--代码中的实现_邱慕夏的博客-CSDN博客

Association, Composition and Aggregation in Java - GeeksforGeeks  

Association > Aggregation> Composition

依赖

一个类使用另一个类，客户client使用供应方supplier

实现依赖的方式是客户类的方法包含供应方的参数。

  

public abstract class Calendar implements Serializable,Cloneable,Comparable<Calendar>{

    public final void setTime(Date date){
    
        setTimeInMillis(date.getTime());
    }

}

 Date是供应方，Calendar是客户类

继承

继承模拟是（is-a）关系

Strong is-a 关系描述继承；弱关系描述接口，具有一些属性

类的设计原则：

内聚性： 高内聚，负责同一个目标，低耦合，不同模块之间关联程度低

封装性： 数据域避免直接访问，，getter,setter

实例和静态：是否依赖于具体的实例，比如长度，是否是所有实例公有的

oop - Inheritance vs. Aggregation - Stack Overflow

has is 

序列化和反序列化

对象----->字节序列

可序列化接口Serializable

关键字transient---变换是否可以序列化，

反射机制：

动态加载类以及获取类的信息，

Class类， Class.forName获得对象

getName，类的名字