View Categories

Object类、包装类型wrap、内部类、枚举

闸总710
更新 2021年10月17日

2 min read

Object类 #

java.lang.Object是所有类的基类

常用方法 #

  • toString(); 用于打印时多态
  • getClass(): Class 获取对象的反射对象
  • hashCode(); int hash散列32位算法。 可以理解获取堆的地址: O(1)
  • equals(Object obj): boolean 比较
    • 默认 == 代表 地址相等。 ※基本类型== 比较值 0 == 0.0 . 对象类型比较地址
    • 需要子类覆盖定义 相等规则。 ※覆盖equals方法必须覆盖hashCode()方法
  • clone(): Object 慎用
    • 子类覆盖Object的clone方法修改 public权限访问修饰升级， 还要实现一个接口Cloneable Cloneable : 标记型接口，无方法。 表示类可以克隆Serializable： 标记型接口， 无方法。 可以序列化
    • 浅克隆与深度克隆
      • 浅克隆：默认 只克隆一层
      • 深度克隆：手写
  • notify(); 唤醒 等待池中 随机一个线程回到 可运行状态
  • notifyAll(); 唤醒 等待池中 所有线程回到 可运行状态
  • wati(); 当前线程进入 等待池中
  • finalize(): GC时 garbage Collect 回调
@Override
	public Object clone() throws CloneNotSupportedException {
		Object o = super.clone();
		Student cloneobj = (Student) o;
        // 深度克隆
		cloneobj.setBirthday((Date)this.getBirthday().clone());
		return o;
	}

包装类型wrap #

  1. 基本类型没有方法
  2. 基本类型的常用工具方法
  3. 包装类型和基本类型相互转换
类型字节型短整型整型长整型单精度浮点型双精浮点型字符型布尔型
基本数据类型byteshortintlongfloatdoublecharboolean
包装器类型ByteShortIntegerLongFloatDoubleCharacterBoolean
            int a = 10;
			Integer a1 = new Integer(10);
			System.out.println(a1.floatValue());
			a = Integer.parseInt("100"); // 字符串转换成 基本类型int
			String str = Integer.toBinaryString(10); // bin二进制
			System.out.println(str);
			Integer a2 = 10; // 隐式转换
			int a3 = a2;  // 隐式转换
            Integer.parseInt(str);   返回int
            Integer.valueOf(str);    返回Integer

内部类 #

  • 静态内部类： 正常用
  • 非静态内部类：实例化必须通过方法 返回值的形式实例化。 用 外部类名.this.XXX 调用外部类的属性或方法
 
  public class Outer {
  
  	private String property = "outer的propertyy";
  	public static void main(String[] args) {
  		
  		// 静态内部类正常用就可以
  		Outer.Inner2 a1 = new Outer.Inner2();
  		a1.abc();
  		
  		// 非静态内部类实例化？？？
  		Outer outerobj = new Outer();
  		Outer.Inner1 a2 = outerobj.newInstance(); // new Outer.Inner1();
  		a2.abc();
  		
  		// 局部内部类
  		class Inner3 {
  			
  		}
          Inner3 a3 = new Inner3();
  	}
  	public Inner1 newInstance() {
  		return new Inner1();
  	}
  	// 非静态内部类
  	class Inner1 {
  		private String property = "inner的property";
  		public void abc() {
  			// 调用外部类的属性。 外部类名.this.XXX
  			System.out.println(Outer.this.property);
  		}
  	}
  	// 静态内部类
  	static class Inner2 {
  		public void abc() {
  			// 调用不到property 
  		}
  	}
  }

局部内部类 #

调用局部变量必须是常量

// 局部变量 -----final
		int n = 100;
//		n = n + 1;
		// 局部内部类
		class Inner3 {
			public void abc() {
				// 调用局部变量必须是常量
				System.out.println(n);
			}
		}
		Inner3 a3 = new Inner3();
		a3.abc();

※匿名内部类 #

	public static void main(String[] args) {
		// 多态
		Jiaju sf = new Sofa(); // new 子类Sofa
		sf.seat();
		
		final int a = 100;
        // new 某个继承自 Jiaju的类 没名字--匿名
		Jiaju sf1 = new Jiaju() { 			// 类体

			@Override
			public void seat() {
				System.out.println("某个没有名字的类继承自Jiaju类" + a);
			}
		};
		
		sf1.seat();
	}

枚举： enum #

解决属性常量问题！

  1. 属性是对象类型时， 这个常量的属性不应该修改。
  2. 要拿出所有的常量做成一个数组。
public enum 枚举类名 {
     常量1(),常量2()....// 必须第一行
}

enum RGB {
	// 常量必须写在第一行
	RED(255, 0, 0),GREEN(0,255,0),GRAY(128,128,128),BLACK;
	private int r;
	private int g;
	private int b;
	
	// 枚举的构造器必须私有
	private RGB(int red, int green, int blue) {
		this.r = red;
		this.g = green;
		this.b = blue;
	}
	private RGB() {

	}
}

分享
更新 2021年10月17日