面向对象-oop-3-引用类型数组、继承、变量内存分配、super

最新推荐文章于 2024-04-13 21:22:01 发布

___信仰°冷暖自知丶

最新推荐文章于 2024-04-13 21:22:01 发布

阅读量120

点赞数

分类专栏：面向对象

本文链接：https://blog.csdn.net/weixin_36580930/article/details/114650194

版权

面向对象专栏收录该内容

8 篇文章 0 订阅

订阅专栏

引用类型数组：两种创建方式

Student[] stus = new Student[3]; //创建Student数组对象
          stus[0] = new Student("翠儿",25,"北京"); //创建Student对象
          stus[1] = new Student("小翠",26,"北京");
          stus[2] = new Student("翠花",24,"北京");

    Student[] stus = new Student[]{
          new Student("zhangsan",25,"LF"),
          new Student("lisi",26,"JMS"),
          new Student("wangwu",24,"SD")
    };

引用类型数组内存图

基本类型数组内存图

引用类型数组的相关理解
- 基本类型与对象无关；(即：跟new 无关)
- 堆：分配一个数组对象，每个元素都是成员变量
- 栈：方法里都是局部变量，即：局部变量分配到栈里
- 数组是new的，数组本身就是引用类型变量
- 数组的地址指向的是第一个元素的值；即：stus[0]
- 数组是连续的，是定长的，扩容、缩容会重新new一个数组，并不是在原数组上操作增删
- 数组指向第一个元素，根据下标就能找到后面相应的元素

public static void main(String[] args) {
        String[] s = {"1","2"};

        //创建一个数组对象
        Persion[] str =  new Persion[3];
        str[0] = new Persion("1",1,"1",s);

        //数组是连续的 
        Persion str1 = new Persion("3",3,"3",s);
        System.out.println(str[0].toString());// Persion{name='1', age=1, gender='1', otherInfo=[1, 2]}
        System.out.println(str1 .toString());// Persion{name='2', age=2, gender='2', otherInfo=[1, 2]}

        //因为str[1] 没有new对象，所以它的地址是null的
        System.out.println(str[1].toString());
        //java.lang.NullPointerException

    }

引用类型数组和基本类型数组的区别
- 基本类型数组给元素赋值，直接赋值；
- 引用类型数组给元素赋值，需要new对象；

int[] arr = new int[3];
arr[0] = 100;

Student[] stus = new Student[3]; //创建Student数组对象
stus[0] = new Student();         //创建Student对象
stus[0].age = 26;

成员变量、全局变量、局部变量名词解释
- 成员变量：在类体的变量部分中定义的变量，也称为字段。
- 局部变量：在方法内定义的变量称为“局部变量”或“临时变量”，方法结束后局部变量占用的内存将被释放。
- 全局变量：全局变量，又称“外部变量”，它不是属于哪个方法，作用域从定义的地址开始到源文件结束。
- 成员变量与局部变量的区别
  - 默认初始值上
    - 局部变量不会自动赋值
    - 成员变量如果没有赋初值，编译器会自动以类型的默认值而赋值
  - 内存中的生存时间上
    - 局部变量随着方法的调用开始而存在、随着方法的结束与栈帧一并被清除
    - 成员变量是对象的一部分，随着对象的创建而存在
  - 内存中的存储上
    - 局部变量存在于栈内存
    - 成员变量是对象的一部分，new的对象存在与堆内存
  - 语法上
    - 成员变量和局部变量都能被final关键字修饰
    - 局部变量不能被访问控制修饰符及static所修饰
    - 成员变量可以被public、private、static等修饰符修饰
    - 局部变量是在方法中定义的变量或是方法的参数
    - 成员变量是属于类的
关于数组在内存的位置分配
- 栈中存放的是局部变量，引用类型才会装有地址，所以new的引用类型数组对象在堆中的成员变量也会装有地址，它的地址指向new的引用类型对象
- 内存过程：
  - 栈：局部变量stus---装有地址---指向数组对象（第一个元素stus[0]）
  - 堆：数组对象--装有成员变量stus[0]（数组对象的元素个数）---装有地址---指向Student 对象
继承：作用：代码的复用
- 通过extends来继承
- 超类/父类：子类所有共有的属性和行为；只能访问父类的属性和方法
- 派生类/子类：子类所特有的属性和行为；可以访问父类+子类的的属性和方法
- 一个父类可以有多个子类，一个子类只能有一个父类；即：单一继承
- 子类不能继承父类的构造方法，只可以调用父类的构造方法
- 即：子类可以继承父类除了私有方法和私有属性以及构造方法之外的其他方法和属性
- 继承具有传递性
java规定：构造子类之前，必须先构造父类
- 在子类的构造方法中若自己没有调用父类的构造方法，则默认super()来嗲用父类的无参构造方法
- 在子类的构造方法中，若自己调用了父类的构造方法，则不在默认提供

class Person{ //------------------------超类/父类
  String name;
  int age;
  String address;
  void eat(){}
  void sleep(){}
}
class Student extends Person{-----------派生类/子类
  String stuId;
  void study(){}
}
class Teacher extends Person{-----------派生类/子类
  double salary;
  void teach(){}
}
class Doctor extends Person{------------派生类/子类
  String level;
  void cut(){}
}

super：指代当前对象的父类对象
super用法
- super.成员变量------------------访问父类的成员变量
- super.方法名---------------------调用父类的方法
- super()-----------------------------调用父类的构造方法
子类调用父类的构造方法，不写的话有默认调用无参构造，而super();必须写在子类构造方法的第一行
继承，new对象的时候就是必须先走父类的构造方法，然后再走子类的
访问父类的属性/方法，用super.，不过一般省略，同名的情况就不能省略了
子类自己的成员变量，用this.来访问
就近原则：子类方法访问的局部变量或参数
super具体用法：


    public class FlyingObject {
        int width;
        int height;
        int x;
        int y;

        //构造方法 这里this.获取的是成员变量
        FlyingObject(int width,int height,int x,int y){
            this.x = x;
            this.y = y;
            this.width = width;
            this.height = height;
        }
    }

//该类继承FlyingObject
public class Bullet extends FlyingObject{
    int width;
    int speed;    

    //构造方法
    Bullet(int x,int y){   //new Bullet(20,230);
        super(8,20,x,y);
        this.speed = 3;   
    }
}


    //即： 就近原则，属于局部变量/方法的参数，什么都不带，直接写该变量名字

    //方法访问成员变量默认有个this. 是省略的，当成员与局部变量名相同，this.不能省略

    //子类没有该属性，但是父类有，子类可以直接用，默认有个super.是省略的

    //当父类、子类成员变量名字相同时，super.访问父类的，this.访问子类的，不写默认访问子类的

    //子类没有，父类有，可以用this.也可以用super.
    //这里就是我继承了你，你的就是我的，我的还是我的

    height = 8;        //默认是 super.height 调用父类的，只不过super.隐藏了

    super.width = 12;  //这里访问的是父类的

    super.x = x;

    this.y = y;        //因为我继承了，父类的就是我的，所以这里用this访问，也没有问题

    this.width = 123;  //这里访问的是自己的，一般父类有的属性，自己不会再写，这里做个演示

    width = 20;        //这里是自己的，实际不会这样写，这里做个演示

数组的删除

/**
 * 删除数组元素测试
 */
public class Test {
    public static void main(String[] args) {
        int[] allOut = {1,2,7,4,5,6,3,8,9};
        int pw = 6;
        System.out.println(Arrays.toString(allOut));
        //获取pw的指针的位置
        int count = 0;
        for(int i=0;i<allOut.length;i++){
            if(allOut[i]==pw){
                count = i;
                break;
            }
        }
        allOut[count] =  allOut[allOut.length-1];
        allOut = Arrays.copyOf(allOut,allOut.length-1);
        System.out.println(Arrays.toString(allOut));
    }
}