继承

继承

1.继承是将程序中共同的特征和行为抽取出来建立一个类，使其他类可以沿用此类中的属性和方法。

例如

父类代码：

/*
这里是一个类名为Student的父类
*/
public class Student {
	//这是父类里面的全局变量
	public String name;
	public int age;
	public String sex;
	//这个是父类里面的方法
	public void eat(){
	System.out.println(name + "正在吃东西！");
	}
}

/*
这是一个类名为Dog的子类，继承了父类Student父类的属性和方法
*/
public class Dog extends Student{
	
}

/*
这是一个类名为Test的测试类
*/
public class StudentTest {
	public static void main(String[] args) {
	Dog dog = new Dog();
	dog.name = "yang";
	dog.eat();
	}
}

控制台的输出为：

2.继承是通过extends关键字实现，注意：Java只支持单继承。

例如

如果有两个父类，直接报错。

3.不能被继承的属性和方法：注意：静态的方法和静态的成员变量是可以被继承的。
（1.）用private修饰的属性和方法都不能被继承
因为private是私有属性，只能本
当我把name的修饰服改为private的时候,测试类直接就报错了。


（2.）构造方法不能被继承
原因：因为构造方法必须和本类同名，所以不能被继承。

4.在创建子类的对象时，默认先执行父类的构造方法，后执行子类的构造方法。
5.在创建子类对象的时候，如果没有显示的调用父类的方法，则默认调用无参数的父类的构造方法，
6.可以在子类的构造方法中通过super(参数列表)调用父类的构造方法 （这个问题在下面的代码里面会给予演示）
7.Object类是所有类的祖宗，在没有显示声明父类的情况下，默认父类就是Object
8.当用final修饰类的时候，该类不能被继承

/*
Student是我的父类
Cat是我的子类
Test是我的测试类
*/
public class Test {
	public static void main(String[] args) {
		Cat cat = new Cat();
	}
}

super和this的用法

1.super()表示调用父类的无参构造方法，this()表示调用当前类的无参数构造方法
2.super(参数列表)表示调用父类带参数的构造方法，this(参数列表)表示调用当前类的带参数的构造方法

/*
这里是一个类名为Student的父类
*/
public class Student {
	//这是父类里面的全局变量
	public String name;
	public int age;
	public String sex;
	//这是父类的无参构造方法
	public Student() {
		System.out.println("---------Student无参构造方法---------");
	}
	//这是父类的有参构造方法
	public Student(String name, int age, String sex) {
		this.name = name;
		this.age = age;
		this.sex = sex;
		System.out.println("---------Student有参构造方法---------");
	}
	//这个是父类里面的方法
	public void eat(){
	System.out.println(name + "正在吃东西！");
	}
}

/*
这是一个类名为Dog的子类，继承了父类Student父类的属性和方法
*/
public class Dog extends Student{
	public Dog () {
		System.out.println("---------Dog 无参构造方法---------");
	}
//这是super(有参列表)调用父类的带参的构造方法
	public Dog (String name, int age, String sex,String color) {
		super(name, age, sex);
		System.out.println("---------Dog 有参构造方法---------");
	}
//这是this(有参列表)调用当前类的带参数的构造方法
	public Dog (String name, int age, String sex,String color) {
		super(name, age, sex);
		System.out.println("---------Dog 有参构造方法---------");
	}
}

public class StudentTest {
	public static void main(String[] args) {
	Dog dog = new Dog();
	dog.name = "yang";
	dog.eat();
	}
}

3.super()与this()在调用的时候必须放在构造方法的第一行，所以这两个方法不能同时使用

4.this表示当前类的对象，super表示父类的对象

public class Dog extends Student{
	public String color;
	public Dog () {
		System.out.println("---------Dog 无参构造方法---------");
	}
	public Dog (String name, int age, String sex,String color) {
		super(name, age, sex);
		this.color = color;
	}
}

方法覆盖（又叫方法重写）

1.定义：子类创建了一个与父类同名的方法，
2.在调用的时候，子类对象调用的实际是子类覆盖掉父类的方法（子类方法）

/*
这是一个类名为Father的父类
*/
public class Father(){
	public void print() {
		public String name;
		public int age;
		public String sex;
		
		System.out.println("我的名字是：" + name);
		System.out.println("我的年龄是：" + age);
		System.out.println("我的性别是：" + sex);
	}
}

/*
这是一个类名为Son的子类
*/
public class Son extends Father(){
public String color;
	public void print() {
		System.out.println("我的颜色是：" + color);
	}
}

/*
这是一个类名为Test的测试类
*/
public class Test {
	public static void main(String[] args) {
		Son son = new Son();
		son.print();
	}
}

运行后的结果是这样的，表示子类覆盖了父类。

3.如何实现方法重写：
1.方法重写的前提条件是必须存在继承关系
2.方法重写必须满足子类方法与父类方法同名
3.方法重写与下列因素相关：
（1）.参数列表必须完全相同，否则形成方法重载

public class Son extends Father{
	public void print(int age) {
		System.out.println("我的年龄是：" + age);
	}
	public void print(String name) {
		System.out.println("我的名字是：" + name);
	}
}

public class Test{
	public static void main(String[] args) {
		Son son = new Son();
		son.print("wxa");
	}
}

测试类输出的值为：

	（2）.与修饰符相关：子类的修饰符使用范围必须大于等于父类方法的修饰符使用范围

public class Son extends Father{
	protected void print() {
		System.out.println("我的年龄是：" + age);
	}
}

当父类的修饰符大于子类的时候，会直接报错

	（3）.与返回值相关：要么子类的返回值类型和父类相同，要么就是子类的返回值类型是父类返回值类型的子类。

public int print() {
		System.out.println("我的名字是：" + name);
		return 0;
}

public String print() {
		System.out.println("我的名字是：" + name);
		return null;
}

当返回值类型不相同的时候，直接报错
（4）最简单的方法重写方式就是直接复制父类的方法头部，保持父类和子类的方法头部一样。