Java面向对象——继承

1 .继承得主要目的就是扩展类的功能：

类的继承格式：Java中使用extends关键字来实现类类的继承

extends 关键字：称扩展类，子类有时候也称派生类

class 父类名 {}		//定义父类

class 子类名 extends 父类名{}

例如：

class Person{
	private String name;	//定义name属性
	private String sex;		//定义sex属性
	private int age;		//定义sex属性
	public String getName() { // 设置get方法
		return name;
	}

	public void setName(String name) { // 设置set方法
		this.name = name;
	}

	public String getSex() {		// 设置get方法
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
}
class Student extends Person{
	private String school;
	public void setSchool(String school) {
		this.school = school;
	}
	public String getSchool() {
		return school ;
	}
}
public class ExtDemo01 {
	  public static void main(String args[]) { 
		  Student s = new Student(); //实例化子类对象 
		  s.setName("张三"); 		//该方法在student类中没有定义，继承父类中的方法
		  s.setAge(18); 
		  s.setSchool("五道口");
		  System.out.print("姓名：" + s.getName() + ",年龄：" + s.getAge() + "，学校:" + s.getSchool() ) ;
	  }
  }

2. 继承类的限制：

在Java中继承类只能是单继承，不能使用多重继承，也就是一个子类只能有一个父类，但可以实现多层继承，也就是说一个子类可以继承父类，父类还可以继承父类。
Java面向对象——继承

3 .访问限制：

在使用继承的时候，只能直接继承父类中非私有的，不能直接访问父类中的私有成员，但子类可以调用父类中的私有方法（setter或getter方法），不能直接调用父类中的私有成员

Java面向对象——继承

对于子类实例化过程，子类在实例化之前必须首先调用父类中的构造方法之后在调用子类中的构造方法 。实例化之后调用构造方法就是为属性初始化的，在子类的构造方法中隐含了一个super语句，默认隐藏，

三种访问权限：

private ：（最小的）私有的
default : 什么都不声明 String name;
public : 最大的访问权限
大小关系 private < default < public

4 .方法的覆写：

在继承的关系中也存在方法的覆写，所谓方法的覆写就是☞子类定义了一个与福父类重名的方法，不过在覆写的时候需要考虑到访问权限，即子类覆写方法的权限不能比父类方法更加严格，所以在父类使用public定义的方法在子类中也必须使用public 否则程序无法编译。

class Person01{		//定义一个父类
	public void print() {		//定义一个普通方法
		System.out.print("Person --> void print()");
	}
}
class Student01 extends Person01{
	public void print() {		//覆写父类中的方法 去掉public权限程序就会报错，因为什么都不声明就是default 他的权限小于pulbic
		System.out.println("Student -->void print()") ;
	}
}
public class ExtDemo02 {
	public static void main(String[] args) {
		Student01 s = new Student01();
		s.print();	//调用Print()方法，被子类覆写调用子类覆写的，没有覆写则调用父类中的该方法
	}
}

5 .super关键字：

super关键字可以从子访问父类中的内容，如果要要访问被覆写过的方法要使用super.方法

class Person{ 			//定义一个类
	public void print(){			//定义一个普通方法
			System.out.println("person---->void print")
	}
}
class Students extends Person{
	public void print(){		//覆写父类中的方法	
		super.print();			//访问父类中别子类覆写过的方法
		System.out.println("Student -->void print()") ;
	}
}
public class ExtDemo02 {
	public static void main(String[] args) {
		Student01 s = new Student01();
		s.print();	//调用Print()方法
	}
}

果使用super不一定要覆写方法之后使用，也可以明确表示某个方法是先从父类中继承而来的。使用super明确的告诉程序该方法实在父类中的，不用再从子类中找了。
如果在父类中使用private 在子类中使用default权限算是扩大权限吗？其实不算是被覆写像以下fun()方法调用的结果是父类中的Print（）方法，也就是说该方法并没有被覆写，而是相当于在子类又重新定义了一个新的方法

class Person01{		//定义一个父类
	private void print() {		//定义一个普通方法
		System.out.println("Person --> void print()");
	}
	public void fun() {		//定义一个fun（）方法
		this.print();		//调用print（）方法
	}
}
class Student01 extends Person01{
	 void print() {		//覆写父类中的方法
		//super.print();		//访问父类中别子类覆写过的方法
		System.out.println("Student -->void print()") ;
	}
}
public class ExtDemo02 {
	public static void main(String[] args) {
		Student01 s = new Student01();
		s.fun();	//调用Print()方法
	}
}

6 .属性的覆盖：

方法的覆写有很多要求属性的覆盖就是在子类中声明了与父类相同的属性。
在子类中使用this 关键字，例如this.info 他会现在本类中寻找，如果本类中没有他才会自从父类中寻，如果父类中的属性被覆盖了，输出的一定是本类中的属性，当然也可以想方法那样使用super关键字来输出父类中的属性值。意义不大

class Person0{		//定义一个父类
	public String info = "java编程";		//定义了一个公共的属性
}
class Student01 extends Person0{
	public String info = "php语言";	//定义了一个与父类相同的属性
	 void print() {		//定义一个print（）方法
		System.out.println("子类中的属性" + this.info) ;
		System.out.println("父类中的属性" + super.info) ;
	}
}
public class ExtDemo {
	public static void main(String[] args) {
		Student01 s = new Student01();
		s.print(); 	//调用Print()方法
	}
}

7 .方法的覆写和重载的区别：

Java面向对象——继承
super表示的是从子类调用父类中指定的操作，调用属性、方法、构造等。因为在子类实例化的的时候会默认调用父类中的无参构造方法，如果调用有参的则必须声明。

8 .super和this的区别：

Java面向对象——继承
子类实例化对象的过程：
先调用父类的构造方法（默认的是无参构造方法），在调用子类的构造方法

关于super的使用：例如
（1）Student继承Person，增加私有属性math和english，都是浮点型，存放数学和英语成绩，设置setter和getter方法，定义一个无参构造方法，一个五参构造方法（使用super调用父类三参构造方法），重写普通方法，用来输出全部5个属性值。在主方法中分别实例化Person和Student类，分别调用普通方法显示内容。

class Person {
	private String name;		//声明姓名属性
	private String sex;
	private int age;
	public String getName() {	//设置get方法
		return name;
	}
	public void setName(String name) {	//设置set方法
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Person() {		//定义无参构造方法
		
	}
	public Person(String name, String sex, int age) {//定义有参构造方法
		this.name = name;
		this.sex = sex;
		this.age = age;
	}
	public String print() {
		return ("姓名：" + this.getName() + "性别"+ this.getSex()+ "年龄"+ this.getAge());
		//new Person().print();
	}
}
class Student extends Person {
	private float math;
	private float english;
	public float getMath() {
		return math;
	}
	public void setMath(float math) {
		this.math = math;
	}
	public float getEnglish() {
		return english;
	}
	public void setEnglish(float english) {
		this.english = english;
	}
	public Student() {
			
		}
	public Student(String name, String sex, int age, float math, float english) {
		super(name ,sex ,age);
		this.math = math;
		this.english = english;
	}
	public String print() {
		return (super.print() +"数学"+ this.getMath()+"英语"+ this.getEnglish());
	}
	
	public static void main(String[] args) {
		Person p= new Person("张三","男",18);
		Student s = new Student("张三","男",18,1f,2f);
		
		System.out.println(p.print());
		System.out.println(s.print());
	}
}