java之继承

继承的概念

生活中，继承的概念随处可见，继承需要符合的关系： is-a； 父类更通用更抽象、子类更特殊更具体
继承背后的思想就是 基于已存在的类来构建新类
当从已存在类继承时，就重用了它的方法和属性，还可以添加新的方法和属性来定制新类以应对需求
约定：从其他类导出的类叫做子类。被导出的类叫做父类
在java中，除了Object类之外，所有类都是子类，都只有唯一的父类。
继承在00P中不可或缺
创建一个类时，总是在继承
继承的意义：代码重用、体现不同抽象层次
父子类关系：父类更抽象，更一般；子类更具体，更特殊

extends关键字

在java语言中，用extends关键字来表示一个类继承了另外一个

public class Teacher extends Person{

}

测试用例

package jicheng.helloworld.java;

class Person
{
	String name;
	String address;
	
	public void eat(){
		System.out.println("人吃饭");
	}
	public void Drink(){
		System.out.println("人喝水");
	}
	public void printInfo(){
		System.out.println("name = "+name);
	}
}

class Student extends Person
{
	int score;
	public void goToSchool(){
		System.out.println("去上学");
	}
}

public class Test {
	public static void main(String[] args) {
		Person p = new Person();
		p.name = "helloworld";
		p.eat();
		
		Student s = new Student();
		s.name = "helloworld";
		s.eat();
		s.printInfo();
	}
}

运行结果

人吃饭
人吃饭
name = helloworld

super关键字

super关键字的特点
super和this关键字的特点类似：super代表的是父类对象的引用
当子父类的成员出现同名时，可以通过super来区分
子类的构造方法中，通过super关键字调用父类的构造方法

public class JavaTeacher extends Teacher{
	public JavaTeacher(String name,String school){
		super(name,school);//通过调用父类的构造方法，完成对相关字段值的初始化
	}
}

强调：当构造一个子类对象的时候一定会先调用父类的构造方法来构造父类的对象。调用父类构造方法的语句必须是子类构造方法中的第一条指令。

package jicheng.helloworld.java;

class Person
{
	String name;
	String address;
	
	public Person(String name,String address){
		this.name = name;
		this.address = address;
		System.out.println("父类构造方法被调用");
	}
	public Person(String name){
		this.name = name;
	}
	//public Person(){}
	public void eat(){
		System.out.println("人吃饭");
	}
	public void Drink(){
		System.out.println("人喝水");
	}
	public void printInfo(){
		System.out.println("name = "+name);
	}
}

class Student extends Person
{
	public Student(String name, String address){
		super(name,address);
		System.out.println("子类构造方法被调用");
	}
	int score;
	public void goToSchool(){
		System.out.println("去上学");
	}
}

public class Test {
	public static void main(String[] args) {
		/*Person p = new Person();
		p.name = "helloworld";
		p.eat();*/
		
		Student s = new Student("hello","12345");
		//*s.name = "helloworld";
		//s.eat();
		s.printInfo();
	}
}

运行结果

父类构造方法被调用
子类构造方法被调用
name = hello

方法重写-override

方法重写是指子类可以根据需要对从父类继承来的方法进行改写，是多态机制的前奏。
方法重写注意点
重写方法必须和被重写方法具有相同的方法名称、参数列表和返回值
重写方法不能比被重写方法有更严格的访问权限
父类中的私有方法，不能被重写
在子类重写的方法中继续调用父类被重写的方法可以通过super.函数名获取

package jicheng.helloworld.java;

class Person
{
	String name;
	private String address;
	
	public void printInfo(){
		System.out.println("name = "+name);
	}
	void printAddr(){
		System.out.println("address = "+address);
	}
}

//重写方法必须和被重写方法具有相同的方法名称、参数列表和返回值
class Student extends Person
{
	int score;
	
	public void printInfo(){
		super.printInfo();
		System.out.println("子类打印name = "+name);
	}
	public void printAddr(){
		System.out.println("私有方法");
	}
}

public class Test {
	public static void main(String[] args) {
		Student s = new Student();
		s.name = "hello";
		s.printInfo();
		s.printAddr();
	}
}

运行结果

name = hello
子类打印name = hello
私有方法

Object常见方法

java中，所有类都直接或间接继承自java.lang.Object类，可以说Object是java中所有类的祖先即根类
java中任何类都继承了Ovject类中的方法，主要有

toString()
equals()
hashcode()
clone()
getClass()
finalize()

String toString() :
返回该对象的字符串描述信息。默认输出的格式： 类名【字段值，字段值···】
只要对象与一个字符串通过“+”连接，系统就会自动调用toString获得对象的字符串描述符
常被改写：可以根据用户的需求对其进行重写
Boolean equals() :
Object 类原始功能是实现判断两个对象是否具有相同的引用，要求判断两个对象状态的相等性。

package jicheng.helloworld.java;

class Person
{
	String name;
	String address;
	
	public void printInfo(){
		System.out.println("name = "+name);
	}
	private void printAddr(){
		System.out.println("address = "+address);
	}
	public String toString() {
	
		return "Person meassage:"+name+address;
	}
	public boolean equals(Object arg0) {
		Person p = (Person)arg0;//强制转换为Person
		if(this.address == p.address && this.name == p.name)
			return true;
		else
			return false;
	}
}

public class Test {
	public static void main(String[] args) {
		Person p = new Person();
		p.name = "hello";
		p.address = "12345";
		
		Person p2 = new Person();
		p2.name = "hello";
		p2.address = "12345";
		
		System.out.println(p.equals(p2));
		System.out.println(p.toString());
		
	}
}

true
Person meassage:hello12345

继承小练习

class Wapon{
	String name;
	public void waponAttack(){
		System.out.println("武器攻击");
	}
}

class K98 extends Wapon{
	public void waponAttack(){
		System.out.println("98K攻击");
	}
}

class quantou extends Wapon{
	public void waponAttack(){
		System.out.println("拳头攻击");
	}
}

class Player{
	String name;
	String duanwei;
	
	Wapon wapon; 
	int id;
	public void attack(){
		System.out.println("玩家攻击");
		wapon.waponAttack();
	}
}

public class chiji {
	public static void main(String[] args) {
		Player p = new Player();
		p.name = "hello";
		p.duanwei = "青铜";
		
		p.wapon = new quantou();//多态
		p.attack();
		
		p.wapon = new K98();//多态
		p.attack();
	}
}

玩家攻击
拳头攻击
玩家攻击
98K攻击

继承之简单工厂模式

class Fruit{
	String name;
	void grup(){
		System.out.println("野蛮生长的水果");
	}
	public Fruit(String name){
		this.name = name;
	}
}

class Apple extends Fruit{
	void grup(){
		System.out.println("野蛮生长的苹果");
	}
	public Apple(String name){
		super(name);
	}
}

class Pearch extends Fruit{
	
	void grup(){
		System.out.println("野蛮生长的梨");
	}
	public Pearch(String name){
		super(name);
	}
}

class Factory{
	
	public static Fruit getFruit(String name){
		if(name == "苹果"){
			return new Apple("苹果1");
		}
		if(name == "梨"){
			return new Pearch("梨1");
		}
		return null;
	}
}

public class Test {
	public static void main(String[] args) {
		Factory.getFruit("苹果").grup();
		Factory.getFruit("梨").grup();
	}
}

野蛮生长的苹果
野蛮生长的梨