Java —— Object、Class、泛型与集合

冷不防 2022-06-17 06:57 189阅读 0赞

一、Object 类

类层次结构的根。关键想粗略了解它有哪些基本方法。

package java.lang;
    
    public class Object {
    
       	private static native void registerNatives();
        	static {
           		registerNatives();
        	}
    	
     	public final native Class<?> getClass();/*返回对象的运行时的类，即该对象实际的类型*/
    
     	public native int hashCode();/*将返回一个对象的哈希码值，典型的实现方法是把该对象的内部地址转换为一个整形值，所以每个对象的此值具有唯一性*/
    
     	public boolean equals(Object obj) {/*注释中有一句：无论何时重载此方法，有必要同时重载hashCode(),这是为了维护equals相同的对象，其哈希码值也相同*/
    		return (this == obj);
        	}
    
        	protected native Object clone() throws CloneNotSupportedException;
    
      	public String toString() {
    		return getClass().getName() + "@" + Integer.toHexString(hashCode());/*toHexString()即转换为16进制字符串。*/
        	}
    
     	public final native void notify();/*唤醒在此对象上具有同步操作（Synchronized）的线程，被唤醒的每个线程都不具有可靠的权限与优势来争取操作此对象*/
    
     	public final native void notifyAll();/*唤醒其他所有等待的线程*/
    	/*注：能调用notify与notifyAll，则当前线程必须是该Synchronized变量或方法的拥有者，怎么才能成为拥有者呢？三种方法：1、执行对象的Synchronized实例方法；2、执行Synchronized 语句块；3、对于Class 类型的对象，执行sychronized 静态方法。简单理解，只有在synchronized修饰的方法或语句块中可使用notify与notifyAll*/
     
    	public final native void wait(long timeout) throws InterruptedException;/*线程进入等待状态，等待被notify或notifyAll*/
     
    	public final void wait(long timeout, int nanos) throws InterruptedException {
            	if (timeout < 0) {
                		throw new IllegalArgumentException("timeout value is negative");
            	}
    
            	if (nanos < 0 || nanos > 999999) {
                		throw new IllegalArgumentException(
    				"nanosecond timeout value out of range");
            	}
    
    		if (nanos >= 500000 || (nanos != 0 && timeout == 0)) {
    	    		timeout++;
    		}
    		wait(timeout);
        	}
     
    	public final void wait() throws InterruptedException {
    		wait(0);
        	}
     	protected void finalize() throws Throwable { }
    }

**说明：**

native 关键字：A native method is a Java method whose implementation is provided by non-java code。即非java语言写的方法，如构成java语言的这些最基础的方法，那它放在哪，怎么调用的？有兴趣再看。

二、Class 类

主要列下可能会用到的方法：

public String toString(){...}
    public static Class<?> forName(String className) throws ClassNotFoundException{...}//重点
    public static Class<?> forName(String name, boolean initialize, ClassLoader loader) throws ClassNotFoundException{...}
    public T newInstance() throws InstantiationException, IllegalAccessException{...}
    public native boolean isInstance(Object obj){...}
    public native boolean isInterface(){...}
    public native boolean isArray(){...}
    public native boolean isPrimitive(){...}//是否是原始类
    public boolean isAnnotation(){...}//是否是注解
    public String getName(){...}//结果形式(包括分号)：java.awt.Button;，若为数组，则形式为：[Ljava.awt.Button;（一维），[[Ljava.awt.Button;（二维）...
    public ClassLoader getClassLoader(){...}//重点
    public native Class<?>[] getInterfaces();//返回数组存储了该类直接实现的接口，按顺序排列
    public native Class<?> getComponentType();//表明数组型类的元素类型，若该类不是数组型类，则返回null。区别于getName方法，结果形式：java.awt.Button若是二维或多位数组，返回形式与getName相同，如String[][] str =new String[2][3];则str.getClass().getComponent()结果为：[Ljava.lang.String;
    public native int getModifiers();
    public String getSimpleName(){...}
    private String getSimpleBinaryName(){...}
    public Field[] getFields() throws SecurityException{...}//获取变量与方法列表。重点
    public Method[] getMethods() throws SecurityException{...}
    public Field getField(String name)throws NoSuchFieldException, SecurityException{...}
    。。。

对象类型转换说明：

1、声明时赋值，可以指向本类实例与子类实例。即一定要具有继承关系，包括接口。

//类B 是类A 的子类，或B 实现A，则：
    A a=new A();
    A b=new B();//可行
    B b1=new A();//反之，不可行

2、声明不同，本质不同，强制转换：

//同上
    A a=new B();
    B b=(B)a;//本质类型相同，但声明类型不同时，需强制转换。强制转换只能从声明的类型转换为本质类型。

3、声明相同，直接赋值。（一定记得初始化）

三、泛型Generics

JDK1.5 中推出，主要目的是可以建立具有类型安全的集合框架，如链表、散列映射等数据结构。用泛型代表声明时不确定的类型，多个泛型用逗号相隔。

1、泛型类声明

class 类名<泛型列表>

或通过extends 界定泛型范围：

class 类名<泛型T1 extends 某各类,泛型T2 >

**注意：**Java 中泛型类和C ++模板有很大不同，未用extends 指明为某个类的子类的泛型，只能调用最基础的Object 类的方法，如 toString，当然，我们可自己定义泛型的方法，也可重写Object 的toString 等方法。

2、泛型接口声明

interface 接口名<泛型列表>

与泛型类类似。

3、怎么使用泛型？

可用泛型实现类似多态功能，但最主要的是用于集合与链表。

四、java.util 包中链表、集合、散列映射

1、泛型链表List 接口

![Center][]

常用的几个：LinkedList、Stack、Vector

LinkedList<E> 泛型类：

创建：

LinkedList<String> list=new LinkedList<String>();//创建String型链表

添加：

add(E e);
    add(int index,E e);
    addFirst(E e);
    addLast(E e);//和顺序添加相同

删除：

clear();//清空
    E remove();//删除并返回链表头元素
    E remove(int index);
    E remove(Object e);//移除并返回第一个匹配的元素
    E removeFirst();
    E removeLast();

查找：

E peek();//查找第一个元素
    E peekFirst();
    E peekLast();
    E get(int index);
    E getFirst();
    E getLast();

修改：

E set(int index,E e);//设置并返回设置元素

其它：

int size();
    Object[] toArray();//所有元素生成数组
    T[] toArray(T[] a);

2、Map<K,V>泛型接口

特点：键值对存储，键不能重复，不能为null。

![Center 1][]

常用：HashMap<K,V>。此外，Properties 也实现了该接口，Properties 在Spring 中比较常用。

HashMap<K,V>:

创建：

HashMap<String,ElementClass> map=new HashMap<String,ElementClass>();

3、Set<E> 泛型接口

特点：不用元素添加的先后顺序存储，而是使用数据“大小”一层层依次排列，适合存储数值型、字符串型(会以字母判断大小)数据。

![Center 2][]

常用：TreeSet<E>、HashSet<E>

TreeSet<E>:

创建：

TreeSet<String> tree=new TreeSet<String>();

添加：

boolean add(E);//返回是否成功

删除：

boolean remove(Object o);
    void clear();

查找：

E first();
    E last();
    boolean contains(Object o);//判断是否包含元素

简单总结：

List 特点：按元素添加顺序排列，顺序存储；Map 特点，以键值对方式按元素添加顺序存储；Set特点，常用的HashSet<E>是按哈希码方式判断元素，具体那种结构存储不太清楚，TreeSet<E>按二叉树结构存储，树中元素按值的大小排列。

[Center]: /images/20220617/e59fb15fbb5243b1b9171c38bafef723.png
[Center 1]: /images/20220617/7ec289ffa42b4a238b59d924ca4cbc67.png
[Center 2]: /images/20220617/230470611c844d94ade4a2d30a92dc29.png