java 继承 实例化,2.0Java面向对象【继承，重写，super关键字，子类实例化对象的过程，多态】...

继承，重写，super关键字，子类实例化对象的过程，多态

1.使用extend关键字实现类的继承

2.一旦子类继承了父类，子类就会获取父类所有的属性与方法

3.一个类只能继承一个父类，一个父类可以有多个子类

4.父类中private声明的属性或者方法，子类不能够直接调用，但是确实可以被获取

方法的重写(override)

1.子类继承父类

2.子类重新实现父类的方法

3.重写的方法，方法名，参数列表，方法体和返回值不同

注：如果父类的返回值类型为基本数据类型，那么重写的返回值必须也是相同的基本数据类型

如果父类的返回值类型为引用数据类型，那么重写的返回值可以是父类返回值类型的子类

4.重写的方法的权限修饰符无法小于父类的方法

5.如果父类的方法的权限修饰符为private那么子类不算重写父类的方法

super关键词

1)使用super关键词可以调用父类的方法或者属性

2)在构造器中使用super()来调用父类的构造器

3)在子类构造器中默认会调用父类的无参构造器

public class Person {

private int age;

private String name;

public Person() {

System.out.println("Person的无参构造方法被调用了");

}

public Person(int age, String name) {

this.age = age;

this.name = name;

System.out.println("Person的有参方法被调用了！！！！");

}

}

public class Worker extends Person {

private String address;

public Worker(){

System.out.println("worker无参构造....");

}

public Worker(String address){

this.address = address;

System.out.println("worker有参1个构造....");

}

public Worker(int age,String name,String address){

super();

this.address = address;

System.out.println("worker有参3个构造....");

}

public static void main(String[] args) {

Worker worker = new Worker("北京");

}

}

输出结果：

Person的无参构造方法被调用了

worker有参1个构造....

子类对象实例化的过程

调用子类的构造器，会往上逐级搜寻父类直到object，然后从object的构造器开始调用，直到调用子类的构造器

生物类->人类->工人类

public class NaturalLife {

public NaturalLife() {

System.out.println("生物类无参构造方法被调用....");

}

}

public class Person extends NaturalLife{

private int age;

private String name;

public Person () {

System.out.println("人类的无参构造方法被调用了");

}

}

public class Worker extends Person {

private String address;

public Worker(){

System.out.println("工人类的无参构造被调用了....");

}

public static void main(String[] args) {

Worker worker = new Worker();

}

}

输出结果：

生物类无参构造方法被调用....

人类的无参构造方法被调用了

工人类的无参构造被调用了....

多态

1.什么样会形成多态

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

例如 Person person = new Student();

2.虚拟方法的调用

在编译器实例对象只能调用父类中的方法，执行时会调用子类中重写的方法(编译看左边，执行看右边)

3.多态使用前提

子类继承父类，子类重写父类方法

4.无法调用子类的特有的属性和方法

注：多态性只适用于方法不适用于属性

以下代码最好自己敲一遍，有助于很好理解多态！！！！！！！！！！！！！

public class Test06 {

public void fn(Animal animal){

animal.eat();

animal.shot();

}

//如果没有多态我们就需要添加以下代码

/* public void fn(Dog dog){

dog.eat();

dog.shot();

}

public void fn(Cat cat){

cat.eat();

cat.shot();

}*/

public static void main(String[] args) {

Test06 test06 = new Test06();

test06.fn(new Cat());

test06.fn(new Dog());

}

}

class Animal{

public void eat(){

System.out.println("动物吃东西");

}

public void shot(){

System.out.println("动物叫");

}

}

class Cat extends Animal{

@Override

public void eat() {

System.out.println("猫吃鱼");

}

@Override

public void shot() {

System.out.println("猫喵喵叫");

}

}

class Dog extends Animal{

@Override

public void eat() {

System.out.println("狗吃骨头");

}

@Override

public void shot() {

System.out.println("狗汪汪叫");

}

}

输出结果：

猫吃鱼

猫喵喵叫

狗吃骨头

狗汪汪叫

向上转型或者向下转型

使用强制类型转换可以使得实例对象进行向上转型或者向下转型

Person person = new Man();

向下转型：父类行转化成子类型     Man man1 = (Man)person;

向上转型：子类型转化成父类型     Person person1 = (Person)man1;

a instanceof A:       a是否为A类的实例对象

在向下转型时使用instanceof 可以防止类型转化异常