Day14-引用类型数组(下)和继承

炸鸡&汉堡

已于 2022-10-15 11:42:03 修改

阅读量205

点赞数

文章标签： java

于 2022-10-15 11:03:10 首次发布

本文链接：https://blog.csdn.net/aiheshuicxy/article/details/127332606

版权

精华笔记：

引用类型数组(下)：
- 区别1：给引用类型数组的元素赋值时，需要new个对象
- 区别2：若想访问引用类型数组元素的数据，需要通过数组元素去打点
继承：
- 作用：代码复用
- 通过extends实现继承
- 超类/父类：共有的属性和行为
  
  派生类/子类：特有的属性和行为
- 派生类可以访问派生类的+超类的，但超类不能访问派生类的
- 一个超类可以有多个派生类，一个派生类只能继承一个超类----------单一继承
- 具有传递性
- java规定：构造派生类之前必须先构造超类
  - 在派生类的构造方法中若没有调用超类的构造方法，则编译器默认super()调用超类的无参构造方法
  - 在派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供
    
    注意：super()调用超类构造方法，必须位于派生类构造方法的第一行
super：指代当前对象的超类对象

super的用法：
- super.成员变量名----------------------访问超类的成员变量
  
  当超类和派生类中的成员变量同名时，若想访问超类的成员变量，则super不能省略
- super.方法名()--------------------------调用超类的方法---------------------下周一讲
- super()------------------------------------调用超类的构造方法
向上造型：
- 超类型的引用指向派生类的对象
- 能点出来什么，看引用的类型---------------这是规定，记住就OK了
  何时向上造型：
  - 多种角色能干的事都一样的时候，可以将多种角色统一造型到超类数组中，实现代码复用
    - 例如：侦察潜艇、鱼雷潜艇、水雷潜艇都能移动、都能被炸弹打-------说明干的事都一样
      就可以将三种潜艇统一造型到SeaObject超类数组中，这样一个for就OK----代码复用
  - 将超类作为参数或返回值，传递派生类对象或返回派生类对象，依然在向上造型—下周才能体会

笔记：

引用类型数组(下)：

区别1：给引用类型数组的元素赋值时，需要new个对象

区别2：若想访问引用类型数组元素的数据，需要通过数组元素去打点

ObserveSubmarine[] oses = new ObserveSubmarine[3];
oses[0] = new ObserveSubmarine();
oses[1] = new ObserveSubmarine();
oses[2] = new ObserveSubmarine();
System.out.println(oses[0].x);  //输出第1个侦察潜艇的x坐标
oses[1].y = 250; //修改第2个侦察潜艇的y坐标为250
oses[2].move(); //第3个侦察潜艇移动
for(int i=0;i<oses.length;i++){ //遍历所有侦察潜艇
    System.out.println(oses[i].x+","+oses[i].y+","+oses[i].speed); //输出每个侦察潜艇的x/y/speed
    oses[i].move(); //每个侦察潜艇移动
}

继承：
- 作用：代码复用
- 通过extends实现继承
- 超类/父类：共有的属性和行为
  
  派生类/子类：特有的属性和行为
- 派生类可以访问派生类的+超类的，但超类不能访问派生类的
- 一个超类可以有多个派生类，一个派生类只能继承一个超类----------单一继承
- 具有传递性
- java规定：构造派生类之前必须先构造超类
  - 在派生类的构造方法中若没有调用超类的构造方法，则编译器默认super()调用超类的无参构造方法
  - 在派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供
    
    注意：super()调用超类构造方法，必须位于派生类构造方法的第一行

super：指代当前对象的超类对象

super的用法：

super.成员变量名----------------------访问超类的成员变量

当超类和派生类中的成员变量同名时，若想访问超类的成员变量，则super不能省略
super.方法名()--------------------------调用超类的方法---------------------下周一讲

super()------------------------------------调用超类的构造方法

package ooday03;
//super的演示
public class SuperDemo {
    public static void main(String[] args) {
        Doo o = new Doo();
    }
}

class Eoo{
    Eoo(int a){
    }
}
class Foo extends Eoo{
    Foo(){
        super(5); //调用Eoo的有参构造方法
    }
    /*
    //如下代码为默认的
    Foo(){
        super();
    }
     */
}

class Coo{
    Coo(){
        System.out.println("超类构造方法");
    }
}
class Doo extends Coo{
    Doo(){
        super(); //默认的，调用超类的无参构造方法
        System.out.println("派生类构造方法");
    }
}

向上造型：

超类型的引用指向派生类的对象

能点出来什么，看引用的类型---------------这是规定，记住就OK了

何时向上造型：

多种角色能干的事都一样的时候，可以将多种角色统一造型到超类数组中，实现代码复用
例如：侦察潜艇、鱼雷潜艇、水雷潜艇都能移动、都能被炸弹打-------说明干的事都一样
就可以将三种潜艇统一造型到SeaObject超类数组中，这样一个for就OK----代码复用

将超类作为参数或返回值，传递派生类对象或返回派生类对象，依然在向上造型—下周才能体会

package ooday03;
public class UploadDemo {
    public static void main(String[] args) {
        Aoo o1 = new Aoo();
        o1.a = 1;
        o1.show();
        //o1.b = 2;  //编译错误
        //o1.test(); //编译错误，超类不能访问派生类的

        Boo o2 = new Boo();
        o2.b = 1;
        o2.test();
        o2.a = 2;  //正确
        o2.show(); //正确，派生类可以访问超类的

        Aoo o3 = new Boo(); //向上造型
        o3.a = 1;
        o3.show();
        //o3.b = 2;  //编译错误
        //o3.test(); //编译错误，能点出来什么，看引用的类型
    }
}

class Aoo{
    int a;
    void show(){
    }
}
class Boo extends Aoo{
    int b;
    void test(){
    }
}

补充：

继承要符合is(是)的关系
超类的意义：
- 封装共有的属性和行为--------------------实现代码复用
- 为所有派生类提供了统一的类型--------向上造型(实现代码复用)
一个文件建议只建一个类，类一定要单独创建
继承要符合si a（是一个) 的关系

类间的关系有关联，继承，组合，聚合等,不能乱用
继承的是成员变量和普通方法，不包括构造方法

构造方法是通过派生类通过super（）进行调用的
构造方法是用 new 时候调用方法
普通方法是用------引用打.去调用

public class Test{
    Test(){
        System.out.println"构造方法";
    }
    void Test(){
        System.out.println"普通方法";
    }
}

7.引用数组的三种写法参考基本类型数组的三种写法

int[] arr ={
    2,
    5,
    8
}
Mine[] ms = {
    new Mine(110,123);
    new Mine(123,234);
    new Mine(243,435)
}

int[] arr = new int{
    2,
    5,
    8
}
Mine[] ms = new Mine[]{
    new Mine(110,123);
    new Mine(123,234);
    new Mine(243,435)
}

int[] arr = new int[3];
arr[0] = 2;
arr[1] = 5;
arr[2] = 8;

Mine[] ms = new Mine[3];
    ms[0] = new Mine(110,123);
  	ms[1] = new Mine(123,234);
    ms[2] = new Mine(243,435);