Java继承
1.1 类与类之间的关系
A:继承(extends)
* 让类与类之间产生关系,子父类关系
* 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的属性和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
特点：子类具有父类的所有属性和方法，并拥有自己的独有的属性和行为。
B:继承案例演示：
* 动物类,猫类,狗类
* 定义两个属性(颜色,腿的个数)两个功能(吃饭，睡觉)
代码：
public class Demo1_extends {
public static void main(String[] args) {
Dog dog = new Dog();
dog.eat();
dog.sleep();
}
}
/**
* 1.创建动物类，也就是父类
* 2.属性：动物的颜色，腿的的个数
* 3. 方法：吃饭，睡觉
*/
class Animal{
String color;
int leg;
public void eat(){
System.out.println("正在吃");
}
public void sleep(){
System.out.println("睡觉");
}
}
class Cat extends Animal{
}
class Dog extends Animal {
}
1.2继承的类型
Java不支持多继承,但是支持多重继承
继承的特性：
1.子类拥有父类非private的成员属性、成员方法（不继承父类的构造方法）。
2.子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
3.子类可以用自己的方式实现父类的方法。
4.Java 的继承是单继承，但是可以多重继承。
5.提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密， 代码独立性越差）。
1.2继承的好处与弊端
* A:继承的好处
* a:提高了代码的复用性
* b:提高了代码的维护性
* c:让类与类之间产生了关系，是多态的前提
* B:继承的弊端
* 类的耦合性增强了。
* 开发的原则：高内聚，低耦合。
* 耦合：类与类的关系
* 内聚：就是自己完成某件事情的能力
1.3 Java中类的继承特点
* A:Java中类的继承特点
* a:Java只支持单继承，不支持多继承。(一个儿子只能有一个爹)
* 有些语言是支持多继承，格式：extends 类1,类2,...
* b:Java支持多层继承(继承体系)
* B:案例演示
* Java中类的继承特点
* 如果想用这个体系的所有功能用最底层的类创建对象
* 如果想看这个体系的共性功能,看最顶层的类
代码：
public class Demo2_extends {
public static void main(String[] args) {
Demo3 demo3 = new Demo3();
demo3.print();
demo3.method();
demo3.show();
System.out.println("----------------------");
Demo1 demo1 = new Demo1();
demo1.show();
}
}
class Demo1 {
public void show(){
System.out.println("Demo1");
}
}
class Demo2 extends Demo1{
public void method(){
System.out.println("Demo2");
}
}
class Demo3 extends Demo2{ // 包含了最多功能
public void print(){
System.out.println("Demo3");
}
}
1.4 Java中继承的注意事项
* A:继承的注意事项
* a:子类只能继承父类所有非私有的成员(成员方法和成员变量)
* b:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。
* c:不要为了部分功能而去继承
* 项目经理 姓名 工号 工资 奖金
* 程序员 姓名 工号 工资
* B:什么时候使用继承
* 继承其实体现的是一种关系："is a"。
Person
Student
Teacher
水果
苹果
香蕉
橘子
采用假设法。
如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。
代码：
public class Demo3_extends {
public static void main(String[] args) {
Programmer p = new Programmer();
p.setEno("1001");
p.setName("程序员");
p.setSalary(10000);
System.out.println(p.getEno() +"...." + p.getName() + "...." + p.getSalary());
System.out.println("++++++++++++");
ProjectManager pro = new ProjectManager();
pro.setEno("0001");
pro.setName("项目经理");
pro.setSalary(20000);
pro.setBonus(5000);
System.out.println(pro.getEno() +"...." + pro.getName() + "...." +
pro.getSalary() + "...." + pro.getBonus());
}
}
class Person{
private String name; // 员工的姓名
private String eno; // 员工的编号
private double salary; // 员工的工资
// 无参数的构造方法
public Person(){
}
// 有参数的构造方法
public Person(String name, String eno, double salary){
this.name = name;
this.eno = eno;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEno() {
return eno;
}
public void setEno(String eno) {
this.eno = eno;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
class Programmer extends Person{
}
class ProjectManager extends Person{
private double bonus;
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
}
1.5继承中成员变量的关系
* A:案例演示
* a:不同名的变量
* b:同名的变量
子父类出现同名的变量只是在讲课中举例子用,在开发中是不会出现这种情况的
子类继承父类就是为了使用父类的成员,那么如果定义了同名的成员变量没有意义了
2.1 继承中构造方法的关系
* A:案例演示
* 子类中所有的构造方法默认都会访问父类中空参数的构造方法
* B:为什么呢?
* 因为子类会继承父类中的数据，可能还会使用父类的数据。
* 所以，子类初始化之前，一定要先完成父类数据的初始化。
* 其实：
* 每一个构造方法的第一条语句默认都是：super() Object类最顶层的父类。
代码：
public class Demo5_Extends {
public static void main(String[] args) {
/**
* 1. 创建对象时，构造方法会自动执行
* 2. 创建的是子类的对象，但是父类的构造方法先执行了。
*/
Son2 son2 = new Son2();
}
}
class Father2 {
String name;
public Father2() {
System.out.println("Father 的构造方法");
}
}
class Son2 extends Father2 {
public Son2() {
System.out.println("Son 的构造方法");
}
}
2.2继承中构造方法的注意事项
* A:案例演示
* 父类没有无参构造方法,子类怎么办?
* super解决
* this解决
* B:注意事项
* super(…)或者this(….)必须出现在构造方法的第一条语句上
代码：
public class Demo6_Extends {
public static void main(String[] args) {
/**
* 1. 创建一个子类的对象
* 2. 调用子类的无参数的构造方法
* 3. 调用super("张三"， 7)方法执行父类中有参数的构造方法
* 4. 执行子类中的无参数的构造方法
*/
SonOne s1 = new SonOne();
System.out.println(s1.getName() + "..." + s1.getAge());
System.out.println("--------------------");
/**
* 1. 调用子类的有参数的构造方法
* 2. 调用super("李四"， 28)方法执行父类中有参数的构造方法
* 3. 执行子类中有参数的构造方法
*/
SonOne s2 = new SonOne("李四",28);
System.out.println(s2.getName() + "..." + s2.getAge());
}
}
class FatherOne{
private String name; // 姓名
private int age; // 年龄
/*
// 无参数的构造方法
public FatherOne() {
System.out.println("FatherOne: 空参构造方法");
}*/
// 有参数的构造方法
public FatherOne(String name, int age){
this.name = name;
this.age = age;
System.out.println("FatherOne: 有参数的构造方法");
}
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;
}
}
class SonOne extends FatherOne{
public SonOne() { //空参构造
super("张三", 7); //无论写没写super() 方法，这一句话都会执行
System.out.println("Son 空参构造");
}
public SonOne(String name,int age) { //有参构造
super(name,age);
System.out.println("Son 有参构造");
}
}
public class Demo6_Extends {
public static void main(String[] args) {
/**
* 1. 创建一个子类的对象
* 2. 调用子类的无参数的构造方法
* 3. 调用super("张三"， 7)方法执行父类中有参数的构造方法
* 4. 执行子类中的无参数的构造方法
*/
SonOne s1 = new SonOne();
System.out.println(s1.getName() + "..." + s1.getAge());
System.out.println("--------------------");
/**
* 1. 调用子类的有参数的构造方法
* 2. 调用super("李四"， 28)方法执行父类中有参数的构造方法
* 3. 执行子类中有参数的构造方法
*/
SonOne s2 = new SonOne("李四",28);
System.out.println(s2.getName() + "..." + s2.getAge());
}
}
class FatherOne{
private String name; // 姓名
private int age; // 年龄
/*
// 无参数的构造方法
public FatherOne() {
System.out.println("FatherOne: 空参构造方法");
}*/
// 有参数的构造方法
public FatherOne(String name, int age){
this.name = name;
this.age = age;
System.out.println("FatherOne: 有参数的构造方法");
}
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;
}
}
class SonOne extends FatherOne{
public SonOne() { //空参构造
super("张三", 7); //无论写没写super() 方法，这一句话都会执行
System.out.println("Son 空参构造");
}
public SonOne(String name,int age) { //有参构造
super(name,age);
System.out.println("Son 有参构造");
}
}
