探索Java面向对象编程的奇妙世界(五)

⭐ Object 类

Object 类基本特性

🐟	Object 类是所有类的父类，所有的 Java 对象都拥有 Object 类的属性和方法。
🐟	如果在类的声明中未使用 extends，则默认继承 Object 类。

【eg】Object 类

	public class Person {
		...
	}
		//等价于：
	public class Person extends Object {
	...
	}

⭐ toString 方法

Object 类中定义有 public String toString()方法，其返回值是 String 类型。Object类中 toString 方法的源码为：

	public String toString() {
		return getClass().getName() + "@" + Integer.toHexString(hashCode());
	}

根据如上源码得知，默认会返回"类名+@+16 进制的 hashcode"。在打印输出或者用字符串连接对象时，会自动调用该对象的 toString()方法。

【eg】重写 toString()方法

	class Person {
		String name;
		int age;
	@Override
	public String toString() {
	return name+",年龄："+age;
	}
}
	public class Test {
	public static void main(String[ ] args) {
		Person p=new Person();
		p.age=20;
		p.name="李东";
	System.out.println("info:"+p);
	Test t = new Test();
	System.out.println(t);
	}
}

⭐ == 和 equals 方法

“==”代表比较双方是否相同。如果是基本类型则表示值相等，如果是引用类型则表示地址相等即是同一个对象。

equals() 提供定义“对象内容相等”的逻辑。比如，我们在公安系统中认为 id 相同的人就是同一个人、学籍系统中认为学号相同的人就是同一个人。

equals()默认是比较两个对象的 hashcode。但可以根据自己的要求重写 equals 方法。

【eg】自定义类重写 equals()方法

	public class TestEquals { 
		public static void main(String[ ] args) {
			Person p1 = new Person(123,"oldwang");
			Person p2 = new Person(123,"高小七");
			System.out.println(p1==p2); //false，不是同一个对象
			System.out.println(p1.equals(p2)); //true，id相同则认为两个对象内容相同
			String s1 = new String("北京");
			String s2 = new String("北京");
			System.out.println(s1==s2); //false, 两个字符串不是同一个对象
			System.out.println(s1.equals(s2)); //true, 两个字符串内容相同
	}
}
		class Person {
			int id;
			String name;
	public Person(int id,String name) {
			this.id=id;
			this.name=name;
	}
	public boolean equals(Object obj) {
		if(obj == null){
		return false;
	}else {
		if(obj instanceof Person) {
		Person c = (Person)obj;
		if(c.id==this.id) {
		return true;
		}
	}
}
	return false;
	}
}

JDK 提供的一些类，如 String、Date、包装类等，重写了 Object 的 equals 方法，调用这些类的 equals 方法， x.equals (y) ，当 x 和 y 所引用的对象是同一类对象且属性内容相等时（并不一定是相同对象），返回 true 否则返回 false。

⭐ super 关键字

🐟	super“可以看做”是直接父类对象的引用。可通过 super 来访问父类中被子类覆盖的方法或属性。
🐟	使用 super 调用普通方法，语句没有位置限制，可以在子类中随便调用。
🐟	在一个类中，若是构造方法的第一行没有调用 super(...)或者 this(...); 那么 Java 默认都会调用 super(),含义是调用父类的无参数构造方法。

【eg】super 关键字的使用

	public class TestSuper { 
		public static void main(String[ ] args) {
			new ChildClass().f();
	}
}
	class FatherClass {
 		public int value;
 		public void f(){
 		value = 100;
 	System.out.println ("FatherClass.value="+value);
	 }
}
	class ChildClass extends FatherClass {
		public int value;
		public int age;
		public void f() {
 		super.f(); //调用父类的普通方法
 		value = 200;
 	System.out.println("ChildClass.value="+value);
 	System.out.println(value);
 	System.out.println(super.value); //调用父类的成员变量
 }
		public void f2() {
 			System.out.println(age); }
}

⭐ 继承树追溯

· 属性/方法查找顺序：(比如：查找变量 h)

🐟	查找当前类中有没有属性 h
🐟	依次上溯每个父类，查看每个父类中是否有 h，直到 Object
🐟	如果没找到，则出现编译错误。
🐟	上面步骤，只要找到 h 变量，则这个过程终止。

· 构造方法调用顺序：

🐟	构造方法第一句总是：super(…)来调用父类对应的构造方法。所以，流程就是：先向上追溯到 Object，然后再依次向下执行类的初始化块和构造方法，直到当前子类为止。

注：静态初始化块调用顺序，与构造方法调用顺序一样，不再重复。

【eg】继承条件下构造方法的执行过程

		public class TestSuper02 { 
			public static void main(String[ ] args) {
			System.out.println("开始创建一个ChildClass对象......");
			new ChildClass();
	}
}
		class FatherClass {
		public FatherClass() {
		System.out.println("创建FatherClass");
	}
}
		class ChildClass extends FatherClass {
		public ChildClass() {
		System.out.println("创建ChildClass");
	}
}

⭐ 封装(encapsulation)

封装是面向对象三大特征之一。

封装的作用和含义

我要看电视，只需要按一下开关和换台就可以了。有必要了解电视机内部的结构吗？有必要碰碰显像管吗？制造厂家为了方便我们使用电视，把复杂的内部细节全部封装起来，只给我们暴露简单的接口。

我们程序设计要追求 高内聚，低耦合。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合是仅暴露少量的方法给外部使用，尽量方便外部调用。

编程中封装的具体优点：

🐟	提高代码的安全性。
🐟	提高代码的复用性。
🐟	 “高内聚”：封装细节，便于修改内部代码，提高可维护性。
🐟	 “低耦合”：简化外部调用，便于调用者使用，便于扩展和协作。

封装的实现—使用访问控制符

Java 是使用“访问控制符”来控制哪些细节需要封装，哪些细节需要暴露的。

Java 中 4 种“访问控制符”分别为 private、default、protected、public。

【注】关于 protected 的两个细节：

🐟	若父类和子类在同一个包中，子类可访问父类的 protected 成员，也可访问父类对象的protected 成员。
🐟	若子类和父类不在同一个包中，子类可访问父类的 protected 成员，不能访问父类对象的 protected 成员。

封装的使用细节

开发中封装的简单规则:

🐟	属性一般使用 private 访问权限。
🐟	属性私有后， 提供相应的 get/set 方法来访问相关属性，这些方法通常是public 修饰的，以提供对属性的赋值与读取操作（注意：boolean 变量的 get方法是 is 开头!）。
🐟	方法：一些只用于本类的辅助性方法可以用 private 修饰，希望其他类调用的方法用 public 修饰。

【eg】JavaBean 的封装演示

		public class Person {
			// 属性一般使用 private 修饰
		private String name;
		private int age;
		private boolean flag;
			// 为属性提供 public 修饰的 set/get 方法
		public String getName() {
			return name;
	}
		public void setName(String name) {
			this.name = name;
	}
		public int getAge() {
			return age;
}
		public void setAge(int age) {
			this.age = age;
	}
		public boolean isFlag() {// 注意：boolean 类型的属性 get 方法是 is 开头的
			return flag;
	}
		public void setFlag(boolean flag) {
			this.flag = flag;
	}
}

【eg】封装的使用

	class Person {
		private String name;
		private int age;
		public Person() {
	}
		public Person(String name, int age) {
			this.name = name;
		// this.age = age;//构造方法中不能直接赋值，应该调用 setAge 方法
			setAge(age);
	}
		public void setName(String name) {
			this.name = name;
	}
		public String getName() {
			return name;
	}
		public void setAge(int age) {
		//在赋值之前先判断年龄是否合法
			if (age > 130 || age < 0) {
			this.age = 18;//不合法赋默认值 18
		} else {
			this.age = age;//合法才能赋值给属性 age
	}
}
		public int getAge() {
			return age;
	}
		@Override
		public String toString() {
			return "Person [name=" + name + ", age=" + age + "]";
	}
}
		public class Test2 {
			public static void main(String[ ] args) {
				Person p1 = new Person();
				//p1.name = "小红"; //编译错误
				//p1.age = -45; //编译错误
					p1.setName("小红");
					p1.setAge(-45);
				System.out.println(p1);
				Person p2 = new Person("小白", 300);
				System.out.println(p2);
	}
}

执行结果：