递归
-
递归头:不需要调用自身方法时退出递归循环,如果每有递归头/或者递归头逻辑出现错误,导致程序无法退出递归,陷入死循环,会导致栈溢出错误,即内存不够用
-
递归体:需要的时候调用自身方法
-
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不能同时调用构造方法