javaSE基础面向对象笔记(2)final关键字，重写toString方法，重写hashcode和equals方法

子类是无法继承父类的构造方法的，子类也无法重写父类的构造方法
static修饰的方法允许被继承不允许被重写

final关键字
正常情况下
1.声明final修饰的成员变量的时候就应该直接赋值
在特殊情况下
1.构造代码块 赋值一次 构造方法里则不可以再赋值
2.直接在构造方法里面赋值 每一个构造方法里面都必须赋值
final关键字：最终的
1.可以修饰
成员变量，局部变量，方法，类
2.修饰以后的特点
成员变量:声明的时候必须赋值，只能赋值一次
局部变量：声明的时候可以不赋值，只能赋值一次
把final修饰的变量叫做常量
方法：最终方法，只能被继承，不能被重写
最终类：只能自己正常使用，不能被继承
3.使用场景
成员变量：经常final和static连用 版本号，接口
public static final
方法：为了保证原有逻辑
最终类：保证类的原始状态，不能让人修改的时候，类似于String Integer

public final class Animal {
	String name;
	final int age;
	{
		age = 5;
	}
	public final void eat() {
		System.out.println("吃");
	}
}
public class Test {
	//静态常量
	final static int age = 7;
	public static void main(String[] args) {
		final int height;
		height = 6;		
		Animal animal = new Animal();
		animal.eat();
	}
}

1.静态的属性方法先进内存
2.当创建对象以后 非静态的属性和方法才进内存
方法是静态，属性是非静态，不能在方法中使用属性
属性是静态的，对象是非静态（创建对象以后才进内存），允许存在
要求:必须内存中有才可以使用
this和super在静态方法中是不允许存在的
在静态的方法中不能直接使用非静态的属性和方法,此时非静态的属性方法还没有进入到内存区域中

public class Test {
	static int age = 9;
	public static void main(String[] args) {
		Test test = new Test();//age不会进内存 进的是堆空间
		test.b();	
		System.out.println(age);
		a();
			}
	public static void a() {
//		System.out.println(age);		
	}
	private static void b() {
		System.out.println(age);		
	}
}

2.重写toString方法
Object所有类默认继承Object不需要显示的写出来

public class Aniaml extends Object{
	String name;
	int age;
	String gender;
	public Aniaml(String name, int age, String gender) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	public Aniaml() {
		super();
		
	}
	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 String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	//Object类的toString打印的是内存地址 子类不需要
	//子类想要打印对象属性值 重写父类的toString方法
	@Override
	public String toString() {
		return "Aniaml [name=" + name + ", age=" + age + ", gender=" + gender + "]";
	}
}
public class Cat extends Aniaml{
	String color;
	String hobby;	
	public Cat(String name, int age, String gender, String color, String hobby) {
		super(name, age, gender);
		this.color = color;
		this.hobby = hobby;
	}
	public Cat() {
		super();		
	}
	@Override
	public String toString() {		
		return "Cat ["+super.toString()+", color=" + color + ", hobby=" + hobby + "]";
	}
}
public class Test {
	public static void main(String[] args) {
		Aniaml aniaml = new Aniaml("Tom",18,"公");
		Aniaml aniaml2 = new Aniaml("Tom",18,"公");
		System.out.println(aniaml);
		System.out.println(aniaml2.toString());		
		Cat cat = new Cat();
		System.out.println(cat.toString());
	}
}

3.重写hashcode和equals方法
equals是String类中的方法,String类中的equals方法比较的是字符串内容
Object类中的equals方法 比较的是内存地址 ==比较的是内容
如果想要比较内容相同则认为是同一个对象 则返回true需要重写equals方法
地址不同,要挨个比较属性是否相同

public class Animal {
	String name;
	int age;
	String gender;
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((gender == null) ? 0 : gender.hashCode());
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		//this==null
		//null.equals(null)
		if (obj == null)
			return false;//两个对象不相同
		//this和obj都不是null 内存地址不同
		//比较属性
		//getClass()得到运行时类
		if (getClass() != obj.getClass())
			return false;
		Animal other = (Animal) obj;
		if (age != other.age)
			return false;//年龄不同
		if (gender == null) {
			if (other.gender != null)
				return false;
		} else if (!gender.equals(other.gender))
			return false;//性别不同
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;//姓名不同
		return true;
	}
}
public class Person extends Object{

	String name;
	int age;
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	//如果想要比较内容相同则认为是同一个对象  则返回true需要重写equals方法
	@Override
	public boolean equals(Object obj) {
		if (this == obj) {
			return true;		
	}
	//地址不同,要挨个比较属性是否相同
	Person person = (Person)obj;
	if(this.age==person.age) {
		//年龄相同
		//继续比较姓名
		if(this.name.equals(person.name)) {
			return true;//两个person对象的属性值相同
		}
	}
	return false;//两个person对象的属性值不同
	}
}
public class Test {
	public static void main(String[] args) {
		//==equals
		//string 存的是常量池的地址
		String string = "aa";
		String string2 = "aa";
		System.out.println(string==string2);
		//string3堆空间地址
		String string3 = new String("aa");
		System.out.println(string==string3);		
		//equals是String类中的方法,String类中的equals方法比较的是字符串内容		
		Object object = new Object();
		Object object2 = new Object();
		//Object类中的equals方法 比较的是内存地址 ==比较的
		System.out.println(object2);		
		Person person = new Person("zhangsan", 18);
		Person person2 = new Person("lisi", 18);		System.out.println(person.equals(person2));
	}
}