java extend implement 同时存在 java中extend

继承概述
继承是面向对象三大特征之一。可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法

继承的格式:

public class 子类名 extends 父类名{}

范例：

public class Zi extends Fu{}

Fu:是父类，也被称为基类、超类
Zi：是子类，也被称为派生类

package ExtendsDemo;
//子类
public class Zi extends Fu {
	public void moehod() {
		System.out.println("使用method方法");
	}
}

package ExtendsDemo;
//父类
public class Fu {
	public void show() {
		System.out.println("使用show方法");
	}
}

package ExtendsDemo;
//测试类
public class Demo {
	public static void main(String[] args) {
		Fu f = new Fu();
		f.show();
		Zi z = new Zi();
		z.moehod();
		z.show();
	}
}

运行结果：

继承的好处

提高了代码的复用性（多个类相同的成员可以放到同一个类中）

提高了代码的维护性（如果方法的代码需要修改，修改一处即可）

继承的弊端
继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性

什么时候使用继承？
继承体现的关系：is a
假设法：有两个类A和B，如果他们满足A是B的一种，或者B是A的一种，就说明他们存在继承关系，这个时候就可以考虑使用继承来体现，否则就不能滥用继承

继承中变量的访问特点

在子类方法中访问一个变量

• 子类局部范围找
• 子类成员范围找
• 父类成员范围找
• 如果都没有就报错（不考虑父亲的父亲…）

package ExtendsDemo;
//子类
public class Zi extends Fu {
	public int height = 175;
	public int age = 20;

	public void show() {
		int age = 30;
		System.out.println(age);// 满足就近原则，该方法会率先在该方法中找，若没有再去子类中找，还没有再去父类中找
		System.out.println(height);
//		System.out.println(weight);//报错
	}
}

package ExtendsDemo;

//父类
public class Fu {
	public int age = 40;

}

package ExtendsDemo;

//测试类
public class Demo {
	public static void main(String[] args) {
		Zi z = new Zi();
		z.show();

	}
}

运行结果：

super关键字

super关键字的用法和this关键字的用法相似

this：代表本类对象的引用

super：代表父类存储空间的表示（可以理解为父类对象引用）

关键字	访问成员变量	访问构造方法	访问成员方法
this	this.成员变量访问本类成员变量	this(…)访问本类构造方法	this.成员变量(…)访问本类成员方法
super	super.成员变量访问父类成员变量	super(…)访问父类构造方法	super.成员变量(…)访问父类成员方法

package SuperDemo;

//子类
public class Zi extends Fu {
	public int age = 20;

	public void show() {
		int age = 30;
		System.out.println(age);
		// 需求：访问本类成员变量age
		System.out.println(this.age);
		// 需求：访问父类成员变量age
		System.out.println(super.age);
	}
}

package SuperDemo;

//父类
public class Fu {
	public int age = 40;
}

package SuperDemo;

//测试类
public class Demo {
	public static void main(String[] args) {
		Zi z = new Zi();
		z.show();

	}
}

继承中构造方法的访问特点

子类中所有的构造方法默认都会访问父类中的无参构造方法

• 因为子类会继承父类中的数据，可能还会使用父类的数据，所以，子类初始化之前，一定要先完成父类数据的初始化
• 没一个子类构造方法的第一条语句默认都是：super()

如果父类中没有无参构造方法，只有带参构造方法，该怎么办？

• 通过使用super关键字去显示的调用父类的带参构造方法
• 在父类中自己提供一个无参构造方法（推荐）

package SuperDemo;

//子类
public class Zi extends Fu {

	public Zi() {
//		super();//写不写都一样，默认不写
//		super(20);//可以指定调用父类的带参构造方法
		System.out.println("Zi中无参构造方法被调用");
	}

	public Zi(int age) {
//		super();
//		super(20);//可以指定调用父类的带参构造方法
		System.out.println("Zi中带参构造方法被调用");
	}
}

package SuperDemo;

//父类
public class Fu {

	public Fu() {
		System.out.println("Fu中无参构造方法被调用");// 若父类中的无参构造被注释调后
	}

//	public Fu() {
//		
//	}
	public Fu(int age) {
		System.out.println("Fu中带参构造方法被调用");
	}
}

package SuperDemo;

//测试类
public class Demo {
	public static void main(String[] args) {
		Zi z = new Zi();
		Zi z2 = new Zi(2);

	}
}

运行结果：

继承中成员方法的访问特点

通过子类对象访问一个方法

• 子类成员范围找
• 父类成员范围找
• 如果都没有就报错（不考虑父亲的父亲…）

package SuperDemo;

//子类
public class Zi extends Fu {

	public void method() {
		System.out.println("Zi中method()方法被调用");
	}

	public void show() {
		super.show();// 调用父类中的show
		System.out.println("Zi中show()方法被调用");// 子类中也有show方法时调用本类中的
	}
}

package SuperDemo;

//父类
public class Fu {

	public void show() {
		System.out.println("Fu中show()方法被调用");
	}
}

package SuperDemo;

//测试类
public class Demo {
	public static void main(String[] args) {
		Zi z = new Zi();
		z.method();
		z.show();

	}
}

运行结果：

方法重写

方法重写概述

• 子类中出现了和父类中一模一样的方法声明

方法重写的应用

• 当子类需要父类的功能，而功能主体子类有自己特有的内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，有定义了子类特有的功能
• 练习：手机类和新手机类

@Override

• 是一个注解
• 可以帮助我们检查重写方法的方法声明的正确性

package SuperDemo;

//手机类
public class Phone {
	public void call(String name) {
		System.out.println("给" + name + "打电话");
	}
}

package SuperDemo;

//新手机类
public class NewPhone extends Phone {
	public void call(String name) {
		System.out.println("开启视频功能");
//		System.out.println("给"+name+"打电话");
		super.call(name);
	}

//	@Override//注解，用于检查重写方法的正确性
//	public void calll(String name) {//名字并不相同，
//		System.out.println("开启视频功能");
		System.out.println("给"+name+"打电话");
//		super.call(name);
//	}
}

package SuperDemo;

//测试类 
public class PhoneDemo {
	public static void main(String[] args) {
		Phone p = new Phone();
		p.call("小白");
		System.out.println("————————");
		NewPhone n = new NewPhone();
		n.call("小白");
	}
}

运行结果：

方法重写的注意事项

• 私有方法不能被重写（父类私有成员子类是不能继承的）
• 子类方法访问权限不能更低（public>默认>私有）

package SuperDemo;

//子类
public class Zi extends Fu {
//	@Override
//	public void method() {//正确
//		System.out.println("Zi中method()方法被调用");
//	}

//	@Override
//	private void show() {//报错，因为私有不可重写
//		System.out.println("Zi中show()方法被调用");// 子类中也有show方法时调用本类中的
//	}

//	@Override
	public void method() {// public可不加，子类重写父类时，访问权限要不比父类低
		System.out.println("Zi中method()方法被调用");
	}

}

package SuperDemo;

//父类
public class Fu {

//	private void show() {
//		System.out.println("Fu中show()方法被调用");
//	}
//	
//	public void method() {
//		System.out.println("Fu中method()方法被调用");
//	}

	void method() {
		System.out.println("Fu中method()方法被调用");
	}
}

Java中继承的注意事项

• Java中类只支持单继承，不支持多继承
• Java中类支持多层继承

package SuperDemo;
//儿子类

//public class Son extends Father,Mother{//只能继承一个类
//	
//}

public class Son extends Father {

}

package SuperDemo;

//爸爸类
public class Father extends Granddad {
	public void smoke() {
		System.out.println("爸爸爱抽烟");
	}
}

package SuperDemo;

//爷爷类
public class Granddad {
	public void drink() {
		System.out.println("爷爷爱喝酒");
	}
}

package SuperDemo;

//妈妈类
public class Mother {
	public void dance() {
		System.out.println("妈妈爱跳舞");
	}
}

案例：老师和学生

需求：定义老师类和学生类，然后写代码测试，最后找到老师类和学生类当中的共性内容，抽取出一个父类，用继承的方法改下代码

package ExtendsDemo;

//学生类
public class Student extends People {
	public void study() {
		System.out.println("好好学习");
	}

	public Student() {

	}

	public Student(String name, int age) {
		super(name, age);
	}

}

package ExtendsDemo;

//老师类
public class Teacher extends People {
	public void teach() {
		System.out.println("教书育人");
	}

	public Teacher(String name, int age) {
		super(name, age);// 通过父类的变量给带参构造赋值
//		this.name=name;
//		this.age=age;
	}

	public Teacher() {// 一旦有带参构造，系统将不再提供无参构造，因此要手动创建

	}

}

package ExtendsDemo;

//人类 父类
public class People {
	private String name;
	private int age;

	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 People() {
	}

	public People(String name, int age) {
		this.name = name;
		this.age = age;
	}

}

package ExtendsDemo;

//测试类
public class Demo {
	public static void main(String[] args) {
		Teacher t=new Teacher();
		t.setName("小白");
		t.setAge(33);
		System.out.println(t.getName()+","+t.getAge());
		t.teach();
		
		Teacher t2=new Teacher("小红",34);
		System.out.println(t2.getName()+","+t2.getAge());
		t2.teach();
		
		Student s=new Student();
		s.setName("黑黑");
		s.setAge(12);
		System.out.println(s.getName()+","+s.getAge());
		s.study();
		
		Student s2=new Student("兰兰",14);
		System.out.println(s2.getName()+","+s2.getAge());
		s2.study();

	}
}

运行结果：