Java学习第三天：递归-Arrays使用-封装-继承

递归

• 递归头：不需要调用自身方法时退出递归循环，如果每有递归头/或者递归头逻辑出现错误，导致程序无法退出递归，陷入死循环，会导致栈溢出错误，即内存不够用

• 递归体：需要的时候调用自身方法

• Java底层使用的是栈，所以Java中使用递归会占据大量的空间和使用更多的时间，所有能不用递归就尽量不适用递归

• 递归尽量在基数比较小时使用

Java内存分析

• 堆：存放new的对象和数组； 可以被所有的线程共享，不会存放其他的对象引用

• 栈：存放基本变量类型（会包含这个基本变量的具体数据）； 引用对象的变量（会存放这个引用在堆里面的具体地址）

• 方法区：可以被所有的线程共享； 包含了所有的class和static变量

// 声明数组+创建数组
int[] testArray = new int[10];
testArray 这个声明将放入栈中
int[10]及其中的数据将放入堆中

java.lang.ArrayIndexOutOfBundsException----数组越界

• 数组也是对象，数组元素相当于对象的成员变量

• int[] test1 = {2,3,9,7,1,5,0,8,6,4};
  System.out.println(Arrays.toString(test1));//可用Arrays.toString(数组名)输出整个数组，而避免使用循环打印

• int[] test1 = {2,3,9,7,1,5,0,8,6,4};
  Arrays.sort(test1);//对数组进行排序，由小到大

• Arrays.fill(test1,2);  // 将数组所有值设置为该值
  Arrays.fill(test1,2,4,32);  // 将2----4区间的值设为32

• Arrays.equals(test1,test2)  // 比较两个数组，其内容是否一致，且元素位置必须一致，该方法是逐项比较

• Arrays.binarySearch(test1,2)   // 该方法必须对排序好的数组使用才有效，其底层代码使用二分法查询

冒泡排序

• 双层循环，暴力破解

稀疏数组----压缩算法

• 即核心思想是数组有时候会存放很少的有效数据，其他空间未被使用，为了节省空间，就产生了稀疏数组

• 稀疏数组第一行存放三个数据，分别为原数组的行列即有效数据个数

  [6,6,2] //6行，6列，2个有效数据

• 后面存放具体数据的位置即大小

  [0,1,2]   // 0行，1列，值为2
  [3,5,3]   // 3行，5列，值为3
  ​
  [0，2，0，0，0，0]   0行
  [0，0，0，0，0，0]   1行
  [0，0，0，0，0，0]   2行
  [0，0，0，0，0，3]   3行
  [0，0，0，0，0，0]   4行
  [0，0，0，0，0，0]   5行
  列0 1  2 3  4  5

  面向对象思想--OOP

• 面向过程思想：即线性思维，一步步做什么，适合解决一些简单的问题

• 面向对象思想：即分类的思维模式，将问题细化分类，对每一个细化的分类再进行面向过程的解决，适合用于处理比较复杂，需要多个对象协作的问题

• 面对对象编程的本质：以类的方式组织代码，以对象的组织封装数据

• 三大特点：封装、继承、多态

• 同类下，静态与非静态方法的调用

    public static  void main(String[] args){
        System.out.println(judge());
    }
    public static int judge(int x,int y) {}
    
    // 这里想要说的是如果主体方法是静态的，那其他同类下的方法必须也定义成静态的，且main函数必须是静态的
    
    public void main(String[] args){
        System.out.println(judge());
    }
    public int judge(int x,int y) {}

• 不同类下，静态与非静态方法调用的区别

  //不同类下的静态方法调用
  public class Demo01 {
      public static  void main(String[] args){
          Demo2.test();
      }
  }
  ​
  public class Demo2 {
      public void test(){
          System.out.println("test success!");
      }
  }
  ​
  // 不通类下的非静态方法调用，需要现实例化该对象
  public class Demo01 {
      public static  void main(String[] args){
          Demo2 demo2 = new Demo2(); *******************************************看这里
          demo2.test();
      }
  }
  ​
  public class Demo2 {
      public void test(){
          System.out.println("test success!");
      }
  }
  ​

Java中是值传递
 // 如果像这样，修改值，单个数据类型的话，其值不会改变
 public static void change(String name){
     name = "sb";
 }
 ***但是如果是数组、集合等该方法修改值会生效
 Class A 想要去修改Class B中的变量值，需要 B.变量=...;

Person person = new Person();
// 其实这句话即调用了无参构造器，隐式地为Person类生成了一个显示的无参构造器,如下，可将生成的java文件反编译为class文件然后查看是否如此
Class Person(){
    public Person(){};
}
*****且如果一个类定义了有参构造，那么无参构造必须显式定义，否则Person person = new Person();这句话会报错

Alt+Insert 快速打开generate,可快速生成无参构造和toString,Override等

封装

• 特点 高内聚，低耦合-------高内聚：操作细节内部完成，不被外部干涉；低耦合：仅暴露少量的方法给外部使用

• 信息隐藏：禁止直接访问对象中的数据，通过操作接口访问

• 属相私有，set/get

继承

• 如果父类子类都是static静态的方法

  Class A{
      public static void person(){
          System.out.println("A success!");
      }
  }
  Class B extends A{
      public static void person(){
          System.out.println("B success!");
      }
  }
  Class C{
      public static void main(){
          A a = new A();
          B b = new A();
          a.person();
          b.person();
      }
  }
  ​
  // 虽然都是new A(),但是其输出结果取决于前面的定义是A还是B,
  输出结果是：
  A success!
  B success!
  但是这种情况只是静态时的情况，如果子类重写了父类的方法，无论怎么实例化，其输出结果都取决于子类的重写方法的输出语句

• extends 关键字

• Java只有单继承，没有多继承（一个儿子只能有一个父亲，但是一个父亲可以有多个儿子）

• super----this,super:实现父类的所有操作；this：代指当前类

• 方法重写----Override

  1）重写是方法的重写，与属性无关

  2）方法名必须相同

  3）参数列表必须相同

  4）修饰符范围可以扩大但不能缩小（子类权限大于父类），public>protect>default>private

  5）抛出的异常：范围可以 被缩小，但不能扩大（子类小于父类）

• Ctrl + h ，打开结构树

• Object类：在Java中，所有的类都默认直接或者间接继承Object类

  ***private ----私有的东西无法被继承

• super注意点：

  1)且子类的无参构造会默认执行super();然后去执行父类的无参构造;

  2)且显示使用super();时必须在子类构造器的第一行写super();

  3)且若父类写了有参构造而没写无参构造的情况下，子类是无法写无参构造和super();的,super的使用必须加上父类的参数；

  4）super自能出现在子类的方法或者构造方法中

  5）super和this不能同时调用构造方法