java 把一个父对象下的所有子节点全部转成list java父类实例化子类

转载

mob64ca13f8eecb 2024-06-13 07:28:07

文章标签 java 继承实例化父类子类 System 文章分类 Java 后端开发

继承，重写，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("狗汪汪叫");
}
}

输出结果：

猫吃鱼

猫喵喵叫

狗吃骨头

狗汪汪叫

向上转型或者向下转型

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