JAVA面向对象-----继承

面向对象之继承：

继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。继承是类与类之间的关系，是一个很简单很直观的概念，与现实世界中的继承（例如儿子继承父亲财产）类似。继承可以理解为一个类从另一个类获取方法和属性的过程。如果类B继承于类A，那么B就拥有A的方法和属性。

一：继承的实现：

我们先定义一个人类的类，人类的类记录了人类的基本属性。

默认这个"人"类为父类。

public class Person {/*** 昵称*/private String nickname;/*** 性别 1代表男 0代表女*/private int gender;/*** 年龄*/private int age;
}public String getNickname() {return nickname;}public void setNickname(String nickname) {this.nickname = nickname;}public int getGander() {return gander;}public void setGander(int gander) {this.gander = gander;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public Person() {}public Person(String nickname, int gander, int age) {this.nickname = nickname;this.gander = gander;this.age = age;}

那其他类，如Boy子类和Girl子类继承Person父类时，要使用 extends 关键字。

public class Boy extends Person{
}

public class Girl extends Person{}

二：面向对象之继承的代码实现

虽然子类里面什么也没有，但当子类继承父类时，会继承父类的属性和方法。

此时我们可以实例化Boy和Girl类，并采用set方法赋值，get方法读取，然后测试验证。

public class PersonTest {@Testpublic void test02(){Boy person = new Boy();person.setNickname("陈浩楠");person.setGander(1);person.setAge(20);System.out.println("姓名 >>>"+person.getNickname());System.out.println("性别 >>>"+(person.getGander()==1 ?"猛男":"靓女"));System.out.println("年龄 >>>"+person.getAge());}@Testpublic void test03(){Girl person = new Girl();person.setNickname("韵菡");person.setGander(0);person.setAge(21);System.out.println("姓名 >>>"+person.getNickname());System.out.println("性别 >>>"+(person.getGander()==1 ?"猛男":"靓女"));System.out.println("年龄 >>>"+person.getAge());}
}

三：super关键字

Super关键字，可以用来子类调用父类的成员用，它包括调用父类的public、protected修饰的变量方法。
注意事项：

调用父类的方法：super.父类的方法。
同时super也可以调用父类的构造方法，但是父类中构造方法用private修饰时，不能有子类去继承。
子类可以没有构造方法，他会自动调用父类的构造方法。
在子类中可以调用父类的构造方法，super必须放在子类构造方法的首句。

使用Super实现代码继承：

public class Boy extends Person {public Boy() {}public Boy(String nickname, int gender, int age) {super(nickname, gender, age);}
}

public class Girl extends Person {public Girl() {}public Girl(String nickname, int gender, int age) {super(nickname, gender, age);}
}

实例化Boy和Girl类，但可以不用set,方法赋值啦，因为在子类继承啦父类的构造方法

构造方法里已经有属性（此属性来自父类）啦，但你实例化赋值时，还是把值赋给啦父类，因为属性来自父类。


public class PersonTest {@Testpublic void test04(){Boy person = new Boy("浩楠",1,20);System.out.println("姓名 >>>"+person.getNickname());System.out.println("性别 >>>"+(person.getGander()==1 ?"猛男":"靓女"));System.out.println("年龄 >>>"+person.getAge());}@Testpublic void test05(){Girl person = new Girl("韵菡",0,21);System.out.println("姓名 >>>"+person.getNickname());System.out.println("性别 >>>"+(person.getGander()==1 ?"猛男":"靓女"));System.out.println("年龄 >>>"+person.getAge());}
}

四：子父类的实例化顺序

(测试中，结果先调用啦父类的构造方法，然后再调用啦子类的构造方法，但这并不

代表先实例化啦父类，其实时先实例化啦子类，只不过是实例化父类的过程先结束罢啦)

public class Person{/*** 昵称*/private String nickname;/*** 性别 1代表男  0代表女*/private int gander;/*** 年龄*/private int age;public Person() {System.out.println("我是Person类的无参构造方法");}public Person(String nickname, int gander, int age) {this.nickname = nickname;this.gander = gander;this.age = age;System.out.println("我是Person类的有参构造方法" );}public String getNickname() {return nickname;}public void setNickname(String nickname) {this.nickname = nickname;}public int getGander() {return gander;}public void setGander(int gander) {this.gander = gander;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

public class Boy extends Person {public Boy() {System.out.println("我是Boy类的无参构造方法");}public Boy(String nickname, int gander, int age) {super(nickname, gander, age);System.out.println("我是Boy类的有参构造方法");}
}

public class Girl extends Person {public Girl() {System.out.println("我是Girl类的无参构造方法");}public Girl(String nickname, int gander, int age) {super(nickname, gander, age);System.out.println("我是Girl类的有参构造方法");}
}

测试：

五:父类的引用指向子类实例化对象

实例化时，类型不用Boy , Girl啦，而使用Person这个类型同样可以。

因为子类的构造方法是继承父类的，所以类型也可以是父类的。

这种现象就叫做父类的引用指向子类实例化对象

public class PersonTest {@Testpublic void test06(){Person person = new Boy("浩楠",1,20);System.out.println("姓名 >>>"+person.getNickname());System.out.println("性别 >>>"+(person.getGander()==1 ?"猛男":"靓女"));System.out.println("年龄 >>>"+person.getAge());}@Testpublic void test07(){Person person = new Girl("韵菡",0,21);System.out.println("姓名 >>>"+person.getNickname());System.out.println("性别 >>>"+(person.getGander()==1 ?"猛男":"靓女"));System.out.println("年龄 >>>"+person.getAge());}
}

六：子类可以拥有单独的方法

注意：子类单独拥有的方法，父类无法直接调用

public class Boy extends Person {public void work(){System.out.println("工作");}
}

public class Girl extends Person {public void beauty(){System.out.println("美丽");}
}

public class PersonTest {@Testpublic void test08(){Boy boy = new Boy();boy.work();}@Testpublic void test09(){Girl girl = new Girl();girl.beauty();}
}

七：方法重写与方法方法重载

方法的重载：一个类中有多个具有相同名称但参数列表不同的方法，则称为方法重载，如果只需要执行一个操作，具有相同的方法名称将增加程序的可读性。

方法的重写：：方法重写基于继承，子类继承父类，子类可以调用父类的方法，同时子类也可以重写父类中的方法，来实现和父类中不同的业务处理逻辑。重写要求子类中方法与父类中的方法名称相同，参数相同，参数类型相同。当子类调用该方法时，基类中的方法则被覆盖。方法重写即：重写父类方法，同名也同参。例如：人类可以吃

public class Person{/*** 昵称*/private String nickname;/*** 性别 1代表男  0代表女*/private int gander;/*** 年龄*/private int age;public void eat(){System.out.println("吃吃吃");}
}

public class Boy extends Person {@Overridepublic void eat() {System.out.println("吃核桃");}
}

public class Girl extends Person {@Overridepublic void eat() {System.out.println("吃荔枝");}
}

测试：

public class PersonTest {@Testpublic void test08(){Boy boy = new Boy();boy.work();boy.eat();Person person = new Boy("浩楠",1,20);person.eat();}@Testpublic void test09(){Girl girl = new Girl();girl.beauty();girl.eat();Person person = new Girl("韵菡",0,21);person.eat();}
}

八：向上转型与向下转型

注意：向下转型，在子类中进行一定成功，在父类中进行会报错

public class PersonTest {
@Testpublic void test08(){Boy boy = new Boy();boy.work();boy.eat();//向上转型  父类的引用指向子类实例化对象Person person = new Boy("浩楠",1,20);person.eat();}
}

 public class PersonTest { @Testpublic void test010(){Person person = new Boy("浩楠",1,20);person.eat();//向下转型Boy boy= (Boy) person;boy.eat();boy.work();}
}

七：final修饰类和方法

final 修饰的类无法被继承

final 修饰的方法无法被重写

1. 当用final关键字修饰一个类时，表明这个类不能被继承。也就是说，如果一个类你永远会让他被继承，就可以用final进行修饰。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。

2.当用final关键字修饰一个方法时，表明这个方法不能被重写，但是这个方法可以被重载。也就是说我们使用final关键字修饰一个方法时，相当于给这个方法上了一把锁。