数组是用来存放多个元素的，是有序的元素序列。
java中的数组通过length属性来获得数组的长度。
通过下标索引来获得数组中的元素。
数组有两种声明方式
- 第一种是动态初始化数组，确定数组大小，默认所有元素为0。（这里的0的含义有多种，int就代表数字0，char就代表‘0’，boolean就代表false，引用类型代表null。）
- 第二种是静态初始化数组，数组中的值在声明时就确定了。
public class HelloWorld {
public static void main(String[] args) {
int[] a = new int[10];
int[] b = new int[]{1,2,3,4};
}
}
3. 数组的优势与局限
优势：
- 数组通过索引查询速度很快
- 数组结构简单，易于理解，占用的资源也很少
局限：
- 数组删除元素或者在中间添加元素很麻烦，会导致数组一部分的移动。
- 数组的大小在初始化时就固定了，不能动态改变。
- 数组所需要的空间是连续的，分配空间会导致堆中出现较多的空隙。
- java中普通数组并没有封装方法，使用起来不是很便利。
动态初始化数组会确定数组大小，且默认所有元素为0。（这里的0的含义有多种，int就代表数字0，char就代表‘0’，boolean就代表false，引用类型代表null。）
- 第二种是静态初始化数组，数组中的值在声明时就确定了。
public class HelloWorld {
public static void main(String[] args) {
int[] a = new int[10];
int[] b = new int[]{1,2,3,4};
}
}
5. 数组的存储特点（堆和栈）
- 基本数据类型的数组，存储在栈内存中，占用一块内存，是方法中内部的局部变量，数据量比较小，一种临时的使用。
- 引用类型的数组，存储在堆内存上，栈内存引用堆内存上的地址，占用两块内存，不仅仅是当前方法使用的，范围更大的数据，数据量比较大，一种持久性的存储。
普通循环就是通过索引来获得每一个数组元素，适合基本数据类型的数组使用。
增强for循环每次获得一个元素，适合引用数据类型的数组使用。
package com.peng.selling.coding;
public class Array_Demo {
public static void main(String[] args) {
int[] b = new int[]{1,2,3,4};
for (int i = 0; i < b.length; i++) {
System.out.print(b[i]+" ");
}
for (int i : b) {
System.out.println(i);
}
}
}
7. 数组元素的顺序查找
顺序查找其实就是通过循环遍历，然后和遍历到的元素进行比较查找。
package com.peng.selling.coding;
public class Array_Demo {
public static void main(String[] args) {
int[] b = new int[]{1,2,3,4};
for (int i = 0; i < b.length; i++) {
if(i==3){
System.out.println("找到3了");
return;
}
}
System.out.println("没有找到3");
}
}
8. Arrays工具类的使用
导包：java.util.Arrays
- Arrays.sort:排列数组
- Arrays.binarySearch:二分查找数组，要先将数组排序，否则结果会出错，返回负数代表没有找到要查询的元素，返回正数代表查询到的元素的索引。
- Arrays.toString：将数组转化为字符串，直接打印数组打印的其实是引用的堆地址。
- Arrays.equals:比较两个数组的元素是否一一对应相等。
- Arrays.copyOf:将一个数组的前n为copy得到一个新数组。
- Arrays.fill:将一个数组的所有元素设置为同一元素。
package com.peng.selling.coding;
import java.util.Arrays;
public class Array_Demo {
public static void main(String[] args) {
int[] a = new int[]{6,5,1,3,8,9,11,7};
System.out.println("直接打印数组："+a);
System.out.println("使用Arrays打印数组："+Arrays.toString(a));
Arrays.sort(a);
int i = Arrays.binarySearch(a, 5);
System.out.println("排列数组后，二分查找5的索引："+i);
System.out.println("打印排列后的数组："+Arrays.toString(a));
int[] b = {1,2,3};
int[] c = {1,2,3};
System.out.println("使用==比较数组"+(b==c));
System.out.println("使用Arrays.equals比较数组："+Arrays.equals(b,c));
int[] d = Arrays.copyOf(b,2);
System.out.println("使用Arrays.copyOf得到的d数组："+Arrays.toString(d));
Arrays.fill(a,10);
System.out.println("使用fill将数组a全部元素填为10："+Arrays.toString(a));
}
}
9. 二维数组的介绍
二维数组就是矩阵，具有n行m列。也可以理解为数组的数组。
10. 二维数组的声明与初始化和一维数组相似，二位数组作为数组的数组，最大区别就是数组的元素还是数组。
动态初始化时根据数组的列数和行数初始化一个元素全为0的二维数组。
静态初始化时需要自己声明数组中的元素。
package com.peng.selling.coding;
import java.util.Arrays;
public class Array_Demo {
public static void main(String[] args) {
int[][] a = new int[][]{{1,2,3,4},{5,6,7,8},{0,0,0,0}};
int[][] b = new int[3][3];
}
}
11. 二维数组的遍历
二维数组的遍历要使用双重循环遍历。
第一层循环遍历得到一行，第二层循环遍历每一行的元素。
遍历二维数组需要获得数组的行数和列数。
行数通过数组的length字段获得。
列数可以通过数组的第一个元素的length字段获得。
public class Array_Demo {
public static void main(String[] args) {
int[][] a = new int[][]{{1,2,3,4},{5,6,7,8},{0,0,0,0}};
int[][] b = new int[3][3];
int m = a.length;
int n = a[0].length;
for (int i = 0; i < m; i++) {
for (int i1 = 0; i1 < n; i1++) {
System.out.print(a[i][i1]);
}
System.out.println();
}
}
}
12. 二维数组的使用
目前我使用到二维数组的情况大多是在算法中用，特别是在动态规划中，dp数组经常会用二维数组来实现。
java面向对象 1. 面向对象设计思想面向对象就是将现实生活中的实体抽象成对象，封装其属性和行为。对于一类事物用一个对象来表示，可以使实现变得简单和清晰。
2. 面向对象的分析与设计面向对象的分析与设计强调的是通过观察系统的事物和情景找到
3. Java与面向对象java中和面向对象息息相关的就是类。一个类是具有相同特征和行为的对象的集合。通过类可以创建对象，初始化对象的属性。
4. 类中成员变量的定义与意义类的成员变量定义时涉及到一些关键字。
首先是作用域的关键字：public、private、protected。
描述静态的关键字：static。
描述常量的关键字：final。
变量的类型：可以是8的基本数据类型，也可以是引用类型。
对于常量必须在定义时初始化或者静态代码块中初始化
对于静态变量，可以通过类名字节调用，无需创建对象，且所有对象的静态对象的值是相同的
package com.peng.selling.coding;
public class OO_Demo {
private int a;
private static int b;
public int c=10;
protected double d;
public final int e=10;
public String s ="hello";
}
5. 构造方法的定义和调用
构造方法定义时只有类名+参数+方法体。没有返回值，构造方法是可以重载的。
一个类如果没有自己写构造方法，会有一个默认无参数的构造方法。当添加自定义构造方法后默认的无参构造方法就会失效。
- 使用默认无参构造
- 添加构造方法后在使用默认无参构造方法报错。
- 使用自定义有参构造
所谓封装就是将内部对数据的操作隐藏起来，仅保留一个接口和外界联系。
例如一个用户输入一组数据到系统中，系统会通过一系列复杂的操作然后输出一个结果。
对于数据的操作过程是隐藏的，因为用户并不需要知道这一过程。
对于结果是公开的，会返回给用户。
- 静态属性，使用static修饰，通过类名就可以使用
- 静态方法，static修饰，通过类名就可以使用，工厂方法就是典型的静态方法。
- 静态代码块，主要是对静态变量的初始化，只会在类加载时运行。所谓类的加载涉及到了JVM，如果一个对象是第一次创建，那么会进行一次类加载，在类加载的初始化过程中会将静态属性的赋值和静态代码块整合起来执行一次。在后续再进行该对象的创建时，会在缓存中读取该类的信息，不会执行类加载过程，当然也就不会执行静态代码块和静态变量的赋值。
public class OO_Demo {
public static int a=10;
static{
a++;
System.out.println("===");
}
public static void main(String[] args) {
OO_Demo o1 = new OO_Demo();
System.out.println(OO_Demo.a);
OO_Demo o2 = new OO_Demo();
System.out.println(OO_Demo.a);
}
}
创建两个对象但静态代码块只执行了一次。
java中类的继承是单继承，一个子类只能有一个父类。java中和继承相关的关键字是extends。子类可以继承使用父类的public、protected属性和方法，但是不能继承使用private和default属性和方法（default在同一包下是可以使用的）。
子类通过super调用父类的属性和方法，重写父类方法时可以加上@override注解。
public class Son extends Father {
@Override
public void method() {
super.method();
}
public static void main(String[] args) {
Son s = new Son();
System.out.println(s.a);
System.out.println(s.b);
}
}
9. 面向对象的多态特性
多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。
在Java的核心类库就大量用到了多态。一般情况多台指一个父类有多个子类，这些子类对父类的方法有不同的实现。其实多数情况更适用于接口。java类库中Link接口就有多个实现类。
public static void main(String[] args) {
List a;
a = new ArrayList<>();
a = new LinkedList<>();
a= new Vector<>();
}
10. 抽象方法与抽象类
- 抽象方法指的是方法只有声明，没有实现。
- 抽象类中可以包含有抽象方法，当然可以有非抽象方法。但非抽象类中不能有抽象方法。一个类继承一个抽象，要么重写所有抽想方法，要么它也是一个抽象类。
接口是对类的需求的描述，所以只包含有方法的声明，而没有方法的实现。一个类可以实现多个接口，并且重写接口中方法。接口使用interface声明。
public interface Serializer {
void Java_Ser();
void JSON_Ser();
}
暑期编程PK赛
得CSDN机械键盘等精美礼品！
