正文：

上一篇是《Java基础教程、Java包（package）、Eclipse安装教程》，朋友们理解得怎么样？这篇分享的是《java访问权限和javaObject》，接下来我们直接进入技术性主题。

接下来开始今天的分享：

Java访问权限

公共类和非公共类

使用public修饰的类为公共类,没有使用public修饰的类为非公共类。

公共类的应用场景

如果这个类想要在其他包中使用就定义为公共类

非公共类只能在当前包中使用

Java类成员的访问权限

在定义类的成员时,遵循访问权限最小化的原则。

如果想在任意位置都可以使用,就定义为public公共的。

如果想在当前类和派生类中都可以直接使用,就定义为protected受保护的。

package com.bjpowernode.chapter01.demo02.p1;
public class Father {
	private int xx = 10;		//私有的, 只能在当前类中使用
	int yy =  20;				//默认的, 可以在当前包中使用
	protected int zz = 30;		//受保护的, 当前包/派生类中使用
	public int oo = 40;			//公共的, 任意位置
	//在当前类中
	public void m1() {
		System.out.println( xx );
		System.out.println( yy );
		System.out.println( zz );
		System.out.println( oo );
	}
}

package com.bjpowernode.chapter01.demo02.p1;
/**
 * 测试访问当前包中Father类的成员权限
 * 	在同一个包中,可以使用默认权限/受保护权限/公共权限的成员 ,不能使用私有成员
 * @author Administrator
 *
 */
public class Test {
	public static void main(String[] args) {
		//创建Father类的对象
		Father f = new Father();
		//访问f的实例成员
		System.out.println(f.xx);  	//The field(字段/域) Father.xx is not visible(不可见), 没有访问权限
		System.out.println(f.yy);	
		System.out.println(f.zz);
		System.out.println(f.oo);
	}
}

package com.bjpowernode.chapter01.demo02.p2;
import com.bjpowernode.chapter01.demo02.p1.Father;
/**
 * 在p2包中, 测试访问p1包中Father类的成员权限
 * 		只能访问公共成员 
 * @author Administrator
 *
 */
public class Test02 {
	public static void main(String[] args) {
		Father f = new Father();	
		//访问f的成员变量
		System.out.println(f.xx);  	//The field(字段/域) Father.xx is not visible(不可见), 没有访问权限
		System.out.println(f.yy);	
		System.out.println(f.zz);
		System.out.println(f.oo);
	}
}

package com.bjpowernode.chapter01.demo02.p3;
import com.bjpowernode.chapter01.demo02.p1.Father;
/**
 * p3包中定义Son类, 继承p1包中的Father类
 * 		子类继承了父类, 就自动拥有了父类的实例变量与实例方法
 * 		Son类从Father类继承了四个实例变量:xx,yy,zz,oo,和一个实例方法: m1()
 * @author Administrator
 *
 */
public class Son extends Father {
	//Son类从Father类继承了四个实例变量:xx,yy,zz,oo
	//子类的实例方法
	//因为继承,所有自动拥有, 是否能够直接使用,跟访问权限有关
	public void sm() {
		System.out.println( xx );
		System.out.println( yy );
		System.out.println( zz ); 		//受保护的
		System.out.println( oo );
	}
}

Java方法覆盖中的访问权限

Java访问覆盖(重写)的规则:

● 子类方法签名必须和父类方法一致, 方法签名就是方法名与参数列表

● 子类方法的返回值类型可以和父类方法返回值类型一样, 也可以是父类方法返回值类型的子类型

● 子类方法的访问权限可以和父类方法访问权限相同,也可以比父类方法访问权限更宽泛(更大)

如果父类方法是public修饰,子类方法只能是public修饰

如果父类方法是protected修饰,子类方法可以protected/public修饰

● 子类方法的异常不能比父类方法的异常更大

Java Object类

Java中Object类的方法

protected Object：clone() 对象的克隆

boolean：equals(Object obj) 判断对象的内容是否一样.

protected void：finalize() 当垃圾回收器回收这个对象时,会调用该方法

Class：getClass() 返回对象的运行时类.

int：hashCode() 返回对象的哈希码.

void：notify() 唤醒等待中的线程

void：notifyAll()

String：toString() 把对象转换为字符串.

void：wait() 线程等待

● clone()

对象克隆, 是在堆中再创建一个完全一样的对象

● finalize()

当一个对象没有变量引用它时, 垃圾回收器就会把这个对象释放, 回收该对象时会调用对象的finalize()方法, 垃圾回收器在什么时候回收这个对象不确定, finalize()方法的执行时间不确定, 该方法一般不用

● wait()/notify()

线程等待/唤醒线程

● getClass()

返回对象的运行时类对象

把所有小狗可以抽象为Dog类, 把所有小猫抽象为Cat类,把所有人抽象为Person类, 把Dog/Cat/Person/String/System等所有的类进一步抽象为Class类. Class类描述的是所有类的相同的特征

getClass()方法返回当前对象对应的Class对象

当前前可以简单地把getClass()方法理解为返回对象的类, 或者理解为返回对象对应的类的字节码文件, 可以利用这个方法判断两个对象的类是否是同一个类

Person  p1 = new Person();
Person  p2  =  new Person();
if(  p1.getClass() == p2.getClass()  ){
p1和p2是同一个类型的对象
}

● toString()

作用是把对象转换为字符串

当使用Sytem.out.println(obj)打印对象时,会调用obj对象的toString()方法

toString()默认显示完整类名@十六进制数, 如果想要打印obj对象的各个字段值, 需要重写toString()

使用Sytem.out.println(obj)打印对象时,如果显示的内容不是完整类名@哈希码十六进制形式时, obj的类或者父类肯定重写过toString()方法

package com.bjpowernode.chapter01.demo03;
import java.util.ArrayList;
/**
 * 测试toString()方法
 * @author Administrator
 *
 */
public class Test01 {
	public static void main(String[] args) {
		//创建Person对象
		Person lisi = new Person("lisi", 18, "男");
		//在屏幕上打印lisi
		System.out.println( lisi );
		/*
		 * 输出结果:
		 * 		com.bjpowernode.chapter01.demo03.Person@15db9742
		 * 			完整类名 @ 十六进制数	
		 * 分析:
		 * 		1) 在使用System.out.println()打印一个对象时, 在println()方法体中,先把对象转换为字符串再打印
		 * 			调用了String类的valueOf()方法
		 * 		2)在String类的valueOf()方法中,调用了对象的toString()方法
		 * 			toString()方法是从Object类继承来的
		 * 		3)在Object类中, toString()方法返回以下内容:
		 * 			getClass().getName() + "@" + Integer.toHexString(hashCode())
		 * 			运行时类的完整类名 + "@" + 哈希码的十六进制
		 * 结论:
		 * 		当使用System.out.println()打印一个对象时, 会调用对象的toString()方法
		 * 需求:
		 * 		当使用System.out.println()打印一个对象时, 显示该对象的各个字段值(各个成员变量值)
		 */
		//上面一行,相当于下面这一行,
		System.out.println( lisi.toString() );
		//toString()是从Object继承来的,默认显示完整类名 , 想要显示各个字段值 ,需要在子类中重写toString()
		//当子类从父类继承的方法,满足不了子类需求时,需要重写该方法
		String s1 = "feifei";
		System.out.println( s1 ); 	//feifei, 显示不是完整类名,String类应该重写了toString()方法
		Integer num = new Integer(456);
		System.out.println( num ); 	//456
		ArrayList list = new ArrayList<>();
		System.out.println( list ); //[], ArrayList的爷爷类AbstractCollection重写了toString()	
	}
}

package com.bjpowernode.chapter01.demo03;
public class Person {
	String name;
	int age;
	String gender; 			//性别  
	public Person() {
	}
	public Person( String name, int age, String gender){
		this.age = age;
		this.name = name;
		this.gender = gender;
	}
	//重写toString()方法
	@Override						//注解,验证重写是否正确
	public String toString() {
		return "name:" + name + ",age:" + age + ",gender:" + gender;
	}
}

● equals()

使用关系运算符 == 判断两个引用是否指向堆中的同一个对象

用equals()方法判断两个对象的内容是否一样,即各个字段值是否相等

如果两个类需要使用equals()判断两个对象是否一样时,需要重写equals()方法

就像之前判断两个字符串是否一样时,需要调用equals()方法, String类已经重写过equals()方法了

package com.bjpowernode.chapter01.demo03;
public class Book {
	String name;
	String author;
	String press;
	double price;	
	public Book( String name, String author, String press, double price) {
		this.author = author;
		this.name = name;
		this.press = press;
		this.price = price;
	}
	//重写equals()方法
	@Override
	public boolean equals(Object obj) {
		// 依次判断两个对象的内容, 如果一个不相同的就返回false, 如果都相同就返回true
		//1)两个变量引用同一个对象, 返回true
		if ( this == obj ) {
			return true;
		}
		//2)参数为null, 返回false
		if ( obj == null ) {
			return false;
		}
		//3) 如果参数对象和当前对象不是同一个类型,返回false
		if ( this.getClass() != obj.getClass() ) {
			return false;
		}
		//4) 当前对象与参数对象类型一样, 如果有一个字段的值不相等,就返回false
		//先把obj对象转换为Book类型
		Book other = (Book) obj;
		//判断书名, 如果书名不一样就返回false
		if ( this.name == null ) {
			if ( other.name != null ) {
				return false; 			//当前书名为null,参数对象书名不为null返回false
			}			
		}else if ( !this.name.equals(other.name) ) {   //当前书名不为null, 与参数对象的书名不一样 返回false
			return false;
		}
		//判断作者, 如果作者不一样就返回false
		if ( this.author == null ){
			if (other.author != null) {
				return false;
			}
		}else if ( !this.author.equals(other.author)) {
			return false;
		}
		//判断出版社
		if (this.press == null ) {
			if (other.press != null) {
				return false;
			}
		}else if ( !this.press.equals(other.press)) {
			return false;
		}
		//判断价格,price字段是一个小数, 在计算机 中小数采用近似值保存,不准确, 不能直接 使用== 判断
		//可以比较两个小数的差值, 根据差值是否小于指定的阈值,来判断两个小数是否相等
		if ( this.price - other.price > 0.01 || other.price - this.price > 0.01 ) {
			return false; 		//两本书的差值大于 0.01元就认为不相等
		}	
		return true;
	}
}

package com.bjpowernode.chapter01.demo03;
/**
 * 测试equals()方法
 * @author Administrator
 *
 */
public class Test02 {
	public static void main(String[] args) {
		Book myBook1 = new Book
		Book myBook2 = new Book
		System.out.println( myBook1 == myBook2 ); 		//false
		/*
		 * 关系运算符==, 判断两个变量的值是否相等  ,
		 * myBook1变量存储堆中的一个对象的引用, myBook2变量存储另外一个对象的引用
		 */
		//需求: 判断堆中两个对象的内容是否一样,可以调用equals()方法,该方法是从Object类继承的, Object类中equals()根据==判断是否相等
		System.out.println( myBook1.equals(myBook2) ); 	
		Book myBook3 = myBook1;			//两个变量引用堆中同一个对象
		System.out.println( myBook1.equals(myBook3));  		//true		
		Book mybook4 = null;
		System.out.println( myBook1.equals(mybook4));    	//false		
		Person  lisi = new Person();
		System.out.println( myBook1.equals(lisi));  		//false	
		Book myBook5 = new Book
		System.out.println( myBook1.equals(myBook5));  		//true		
	}
}

● hashCode()

根据哈希约定, 如果两个对象equals()相等, 这两个对象的哈希码也应该相等

在重写equals()方法时,必须同时重写hashCode()

上面就是《java访问权限和javaObject》的分享，接下来为大家梳理《Java中final关键字的作用和Java抽象类》。

也欢迎大家交流探讨，该文章若有不正确的地方，希望大家多多包涵。

你们的支持就是我最大的动力，如果对大家有帮忙给个赞哦~~~