JAVA基础之继承

[b]一、继承[/b]
1.概念
继承是类与类的一种关系，是一种"is a"的关系，如：狗是动物，我们就可以说狗是继承动物的。狗类就是子类、派生类，动物类就是父类、基类。继承是单继承的。
2.好处：
a.子类拥有父类的所有属性和方法，private修饰的除外。
b.实现代码的复用
3.语法规则：
class 子类 extends 父类
如：
class Dog extends Animal {
......
}
程序示例：

//创建父类
public class Animal {
	public String name;
	public int age;
	public void run(){
		System.out.println(age+"岁的"+name+"可以跑");
	}
	public void eat(){
		System.out.println(age+"岁的"+name+"要吃东西");
	}
}

//创建子类，继承父类
public class Dog extends Animal {

}

//控制类
public class Control {
	public static void main(String[] args) {
		Dog dog=new Dog();
		dog.name="哮天犬";
		dog.age=18;
		dog.run();
		dog.eat();
	}
}

运行结果：
18岁的哮天犬可以跑
18岁的哮天犬要吃东西
[b]二、方法的重写[/b]
1.概念
如果子类对继承父类的方法不满意，可以重写父类的方法，当调用方法时会优先调用子类的方法。
2.语法规则
返回值类型、方法名、参数类型及个数都要与父类继承的方法相同，才叫方法的重写。
如上所述的程序示例，我们可以在Dog类中重写run方法：

public class Dog extends Animal {
	public void run(){
		System.out.println(age+"岁的"+name+"可以跑和走");
	}
}

运行主程序后的结果：
18岁的哮天犬可以跑和走
18岁的哮天犬要吃东西
[b]三、继承的初始化顺序[/b]
1.初始化父类再初始化子类（也就是创建对象的时候先创建了父类对象，然后才创建了子类对象）
2.先执行初始化对象中属性，再执行构造方法中的初始化
[b]四、final关键字[/b]
final关键字做标识有“最终的”含义，即不可再修改
final可以修饰类、方法、属性和变量
a.修饰类时，该类不允许被继承
b.修饰方法时，该方法不允许被覆盖（重写）
c.修饰属性时，该类的属性不会进行隐式初始化（类的初始化属性必须有值）活在构造方法中赋值（但只能选其一）
d.修饰变量时，该变量的值只能赋一次，即变为常量
[b]五、super关键字[/b]
在对象内部使用，可以代表父类对象
1.访问父类属性
super.age
2.访问父类的方法
super.eat（）
示例代码：

//创建父类
public class Animal {
	public String name;
	public int age=18;
	public void run(){
		System.out.println(age+"岁的"+name+"可以跑");
	}
	public void eat(){
		System.out.println(age+"岁的"+name+"要吃东西");
	}
}

//创建子类，继承父类
public class Dog extends Animal {
	public void method(){
		super.run();
		System.out.println(super.age+"岁的"+name+"可以走");
		super.eat();
	}
}

//控制类
public class Control {
	public static void main(String[] args) {
		Dog dog=new Dog();
		dog.name="哮天犬";
		dog.method();
	}
}

运行结果：
18岁的哮天犬可以跑
18岁的哮天犬可以走
18岁的哮天犬要吃东西
3.super的应用
子类的构造过程当中必须调用其父类的构造方法
子类的构造方法当中隐式含有语句super（）；
如果子类的构造方法中没有显示调用父类的构造方法，则系统默认调用父类无参的构造方法。
当父类的构造方法是有参构造方法的时候，子类的构造方法当中必须要写super（）；语句，如：

//创建父类
public class Animal {
	public Animal(String name){
		System.out.println("我是"+name);
	}
	public String name;
	public int age=18;
	public void run(){
		System.out.println(age+"岁的"+name+"可以跑");
	}
	public void eat(){
		System.out.println(age+"岁的"+name+"要吃东西");
	}
}

//创建子类，继承父类
public class Dog extends Animal {
	public Dog (String name){
		super(name);
		this.name=name;
		System.out.println("biubiubiu!!!");
	}
	public void method(){
		super.run();
		System.out.println(super.age+"岁的"+name+"可以走");
		super.eat();
	}
}

//控制类
public class Control {
	public static void main(String[] args) {
		Dog dog=new Dog("哮天犬");
		dog.method();
	}
}

运行结果：
我是哮天犬
biubiubiu!!!
18岁的哮天犬可以跑
18岁的哮天犬可以走
18岁的哮天犬要吃东西
[b]六、Object类[/b]
Object类是所有类的父类，如果一个类没有使用extends关键字明确标识继承另一个类，那么这个类默认继承Object类。
Object类中的方法适合所有的子类。
1.在Object类里面定义toString（）方法的时候返回的对象的哈希code码（对象地址字符串）
可以重写toString（）方法表示出对象的属性
2.equals()方法
a.比较的是对象的引用是否指向同一块内存地址

public class Control {
	public static void main(String[] args) {
		Dog dog1=new Dog();
		Dog dog2=new Dog();
		if(dog1.equals(dog2)){
			System.out.println("两个对象是相同的");
		}else{
			System.out.println("两个对象是不同的");
		}	
	}
}

运行结果：
两个对象是不同的
b.一般情况下比较两个对象是比较他的值是否一致，所以要进行重写。

public class Dog  {
	public String name;
	public int age;
	public void print(){
		System.out.println("名字"+name + "年龄"+age);
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Dog other = (Dog) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
}

equals方法可以通过工具栏上的Source -> Generate hashCode() and equals()直接重写。

public class Control {
	public static void main(String[] args) {
		Dog dog1=new Dog();
		Dog dog2=new Dog();
		if(dog1.equals(dog2)){
			System.out.println("两个对象是相同的");
		}else{
			System.out.println("两个对象是不同的");
		}	
	}
}

运行结果：
两个对象是相同的