java——继承
类是对象的抽象，继承是对某一批类的抽象，从而实现对现实世界会更好的建模
提高代码的复用性
继承关键字——extends.子类是父类的扩展
如果定义一个类没有使用extends来继承，他们都会去继承他们的父类java.util.object
直接上代码演示：
先创建父类的东西，即子类共有的属性和方法
在这里我写的是动物是父类
子类不能继承父类的所有资源：
不能访问私有属性
子类与父类不在同一个包下
构造方法
Super关键字的概述很应用
super关键字：super关键字是父类对象的引用。
super关键字的用途;
1.可以在子类中调用父类在子类中覆盖的方法，super.父类方法名
2.在调用父类方法的时候，一定要位于第一行。
3.在构造方法中super关键字和this关键字不能同时出现
4.父类中的私有属性和方法不能被调用
总结：
在创建对象时，父类会优先与子类。
super关键字的示例代码
package Extend;
public class SuperDemo {
public static void main(String[] args) {
new ChildClass().f();
}
}
class FatherClass{
public int value;
public void f(){
value = 100;
System.out.println("FatherClass.value"+value);
}
}
class ChildClass extends FatherClass{
public int value;
public void f(){
super.f();
value = 200;
System.out.println("ChildClass.value"+value);
System.out.println(value);
System.out.println(super.value);
}
}
package Extend;
public class Pet {
private String name;
private int age;
private String gender;
public Pet(){
}
public Pet(String name, int age, String gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
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 String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
}
创建子类的代码，来继承父类的属性和方法
package Extend;
public class Dog extends Pet{
private String sound;
public Dog(){
}
public Dog(String name, int age, String gender, String sound) {
super(name,age,gender);
this.sound =sound;
}
public String getSound() {
return sound;
}
public void setSound(String sound) {
this.sound = sound;
}
public void show(){
System.out.println("name:"+getName()+"age:"+this.getAge()+"gender:"+this.getGender()+"sound:"+getSound());
}
}
package Extend;
public class Penguin extends Pet{
private String color;
public Penguin(){
}
public Penguin(String name, int age, String gender, String color) {
super(name,age,gender);
this.color = color;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public void show(){
System.out.println("name:"+getName()+"age:"+this.getAge()+"gender:"+this.getGender()+"color:"+getColor());
}
}
创建测试类进行测试
package Extend;
public class PetTest {
public static void main(String[] args) {
Dog dog= new Dog();
dog.setName("小黑");
dog.setAge(6);
dog.setGender("雄性");
dog.setSound("汪汪汪~");
dog.show();
Penguin penguin = new Penguin();
penguin.setName("花花");
penguin.setAge(4);
penguin.setColor("蓝色");
penguin.setGender("雌性");
penguin.show();
}
}
多重继承关系的初始化顺序：
父类属性、父类的构造方法、子类属性、子类构造方法
方法重写------@Override
当父类中的方法无法满足子类的需求时可以用方法重写。
重写方法和被重写方法具有相同的参数列表、方法名称、
重写方法不能比被重写方法的的访问修饰更严格
父类public 子类只能使用public
父类protected 子类使用public protected
父类default子类使用public protected default
父类的静态方法子类可以进行调用，但是不能重写
toString重写是为了方便以后的调用
抽象类和抽象方法
抽象类：abstract,限制实例化
抽象方法：abstract也可以用于方法-----抽象方法，
抽象方法没有方法体，抽象方法必须在抽象类，
抽象方法必须在子类中被实现，除非子类就是抽象类
创建抽象类
package Extend.home;
public abstract class Pet {
private String name;
private int age;
public Pet(){
}
public Pet(String name, int age) {
this.name = name;
this.age = 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 abstract void print();
}
创建普通类来继承抽象类
package Extend.home;
public class Dog extends Pet {
private String gender;
@Override
public void print() {
System.out.println("name:"+super.getName()+"age:"+super.getAge()+"gender"+this.gender);
}
public Dog(){
}
public Dog(String name,int age,String gender){
super(name,age);
this.gender = gender;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
}
创建测试类
package Extend.home;
public class PetTest {
public static void main(String[] args) {
Dog dog = new Dog("小黑",8,"雄性");
dog.print();
}
}
|