java的知识点12——==和equals方法、 super关键字、 继承树追溯、封装的作用和含义、封装的实现—使用访问控制符、封装的使用细节

==和equals方法

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

 Object 的 equals 方法默认就是比较两个对象的hashcode，是同一个对象的引用时返回 true 否则返回 false。但是，我们可以根据我们自己的要求重写equals方法。

equals方法测试和自定义类重写equals方法

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

package cn.dym.cl;
class Person{
	int id;
	String name;
	public Person(int id, String name) {
		super();
		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;
	}
}

public class TestEquals {
	public static void main(String[] args) {
		Person p1=new Person(123,"止小兮");
		Person p2=new Person(123,"止兮");
		System.out.println(p1==p2);
		System.out.println(p1.equals(p2));
		String s1=new String("苍小凌");
		String s2=new String("苍小凌");
		System.out.println(s1==s2);
		System.out.println(s1.equals(s2));
	}
}

---

 super关键字

super是直接父类对象的引用。可以通过super来访问父类中被子类覆盖的方法或属性。

使用super调用普通方法，语句没有位置限制，可以在子类中随便调用。

若是构造方法的第一行代码没有显式的调用super(...)或者this(...);那么Java默认都会调用super(),含义是调用父类的无参数构造方法。这里的super()可以省略。super()永远位于构造器的第一句

注： ctrl+T  快捷键为查看继承树

super关键字的使用

package cn.dym.cl;

class FatherClass{
	public int value;
	public void f() {
		value=100;
		System.out.println("FatherClass.value="+value);
	}
}

class ChildClass extends FatherClass{
	public int value;
	public void f() {
		super.f();
		value=200;
		System.out.println("ChildClass.value="+value);
		System.out.println(value);
		System.out.println(super.value);
	}
}

public class TestSuper01 {
	public static void main(String[] args) {
		new ChildClass().f();
	}
}

---

继承树追溯

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

      1. 查找当前类中有没有属性h

      2. 依次上溯每个父类，查看每个父类中是否有h，直到Object

      3. 如果没找到，则出现编译错误。

      4. 上面步骤，只要找到h变量，则这个过程终止。

构造方法调用顺序：

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

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

构造方法向上追溯执行测试

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

---

 封装的作用和含义

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

         编程中封装的具体优点：

     1. 提高代码的安全性。

     2. 提高代码的复用性。

     3. “高内聚”：封装细节，便于修改内部代码，提高可维护性。

     4. “低耦合”：简化外部调用，便于调用者使用，便于扩展和协作。

没有封装的代码会出现一些问题

package cn.dym01;
class Person{
	String name;
	int age;
	@Override
	public String toString() {
		return "Person [name="+name+",age="+age+"]";
	}
}
public class Test {
	public static void main(String[] args) {
		Person p=new Person();
		p.name="小红";
		p.age=-45;  //年龄可以通过这种方式随意赋值，没有任何限制
		System.out.println(p);
	}
}

 注：我们都知道，年龄不可能是负数，也不可能超过130岁，但是如果没有使用封装的话，便可以给年龄赋值成任意的整数，这显然不符合我们的正常逻辑思维。

如果使用封装，我们只需要稍微修改下Person类的setAge()方法即可，而无需修改使用了该类的客户代码。

---

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

Java是使用“访问控制符”来控制哪些细节需要封装，哪些细节需要暴露的。Java中4种“访问控制符”分别为private、default、protected、public，它们说明了面向对象的封装性，所以我们要利用它们尽可能的让访问权限降到最低，从而提高安全性。

                                                                                      访问权限修饰符

 1. private 表示私有，只有自己类能访问

 2. default表示没有修饰符修饰，只有同一个包的类能访问

 3. protected表示可以被同一个包的类以及其他包中的子类访问

 4. public表示可以被该项目的所有包中的所有类访问

---

封装的使用细节

类的属性的处理:

      1. 一般使用private访问权限。

      2.  提供相应的get/set方法来访问相关属性，这些方法通常是public修饰的，以提供对属性的赋值与读取操作(注意：boolean变量的get方法是is开头!)。

      3. 一些只用于本类的辅助性方法可以用private修饰，希望其他类调用的方法用public修饰。

JavaBean的封装实例

package cn.dym02;

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;
	}
}

封装的使用

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