数组的说明
数组（array）：可以理解为多个相同数据类型的变量的组合。
目的：为了便于在内存中对数据进行统一管理。
一维数组的声明与初始化
（1）静态初始化：数组的赋值和数组元素的赋值同时进行。
int[] ids1 = new int[]{1,2,3,4,5,6,7};
int[] ids2 = {1,2,3,4,5,6,7};（2）动态初始化：数组的赋值和数组元素的赋值分开进行。
String[] names = new String[3];一维数组的引用
通过下角标的方式进行调用（下角标从0开始，到数组长度-1结束）。
总结：不管是静态初始化还是动态初始化，一旦数组初始化完成，其长度就确定了，而且长度是不可变的。
数组的属性
数组的长度，即为数组中元素的个数，可以通过 length 属性来获取。
一维数组的遍历
规则
（1）由26个英文字母大小写，0-9，_或$组成；
（2）数字不可以开头；
（3）不可以使用关键字和保留字，但能包含关键字和保留字；
（4）Java中严格区分大小写，长度无限制；
（5）标识符不能包含空格。
规范
（1）包名：多单词组成时字母都是小写：xxxyyyzzz；
（2）类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz；
（3）变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz；
（4）常量名：所有字母大写，多单词组成时，单词之间用_连接：XXX_YYY_ZZZ。
注意
在起名字时，为了提高阅读性，要尽量“见名知意”。
内存中多个相同数据类型的存储“容器”：①数组 ②集合
对应的，数据的持久化：①数据库 ②文件（.txt,.jpg,...） ③xml文件
数组存储的特点
①一旦初始化，其长度就确定了；
②存储有序的、重复的数据；
③声明的类型，就决定了只能操作此类型的元素。
数组存储的弊端：
①一旦初始化，其长度就不可变；
②数组中涉及到数据的增删改查的方法比较少，不及集合；
③不能存放无序的、要求不可重复的数据。
集合存储的优点
（1）使用集合，可以不用考虑长度问题，直接添加即可；
（2）集合中提供了丰富的方法，便于数据的操作（CRUD）；
（3）操作的数据特点更丰富，可以存储无序的、不可重复的；有序的、可重复的；键值对特点。
数据结构研究的问题
（1）数据与数据之间的逻辑关系：一对一，一对多，多对多；
（2）数据的存储结构：①顺序存储（典型：一维数组）②链式存储。
// 单向链表
class A {
A next;
}
// 双向链表
class A {
A prev;
A next;
}
// 二叉树
class A {
A left;
A right;
}（一）java.lang.String 类
特点
String 的不可变性
体现：
①给现有的字符串添加一个新的字符串，不能在原有的字符串后面添加，而必须声明一个新的内存空间，存放新的字符串；
②给现有的字符串重新赋值，不能在原有的常量池对应的字符串的位置赋值，必须重新声明一个新的内存空间，存放新的字符串；
③现有的字符串调用 replace() 方法，仍然声明一个新的内存空间，存放修改以后的字符串。
内存的存储结构
String 声明的变量，我们称为字符串，本质上数据存放在字符串常量池中，字符串常量池存放在方法区中。
jdk 6：方法区（具体的实现就是永久代--->堆：新生代、老年代、永久代）；
jdk 7：方法区取消，统一归入堆；
jdk 8：元空间取代原的方法区
String 的实例化方式
方式一：通过字面量定义的方式；
方式二：通过new + 构造器的方式。
二者区别：
①字面量的方式：地址值对应的数据声明在方法区中的字符串常量池；
②new + 构造器的方式：地址值对应的数据声明在堆空间中（堆空间中对应的 String 对象里存的是对应声明在字符串常量池中的字符串（若有，则不用创建；若无，就创建）的地址值）。
// 方式一：通过字面量的方式
String s1 = "hello";
String s2 = "hello";
// 方式二：通过new + 构造器的方式
String s3 = new String("hello");
String s4 = new String("hello");
System.out.println(s1 == s2);// true
System.out.println(s1 == s3);// false
System.out.println(s3 == s4);// false
枚举类的理解
如果一个类中的对象的个数是有限可列的，那么我们说此类是一个枚举类。
--> 如何定义枚举类？
方法一：自定义枚举类；
方法二：jdk 5.0 新增了enum 的方式。
如何自定义枚举类？步骤
class Season {
// 1.提供类的对象的属性
private final String seasonName;
private final String seasonDesc;
// 2.提供构造器,私的
private Season(String seasonName,String seasonDesc) {
this.seasonName = seasonName;
this.seasonDesc = seasonDesc;
}
// 3.提供当前枚举类的对象
public static final Season SPRING = new Season("春天", "春暖花开");
public static final Season SUMMER = new Season("夏天", "夏日炎炎");
public static final Season AUTUMN = new Season("秋天", "秋高气爽");
public static final Season WINTER = new Season("冬天", "寒冬凛冽");
public String getSeasonName() {
return seasonName;
}
public String getSeasonDesc() {
return seasonDesc;
}
@Override
public String toString() {
return "Season [seasonName=" + seasonName + ", seasonDesc=" + seasonDesc + "]";
}
}在集合中使用泛型的例子
@Test
public void test1() {
List list = new ArrayList();
list.add(89);
list.add(76);
list.add(66);
list.add(54);
// 问题一：类型不安全
list.add("AA");
for(int i = 0;i < list.size();i++) {
Object obj = list.get(i);
// 问题二：需要强转，一方面繁琐，另一方面可能报ClassCastException
int score = (Integer) obj;
System.out.println(score);
}
}例子1：
@Test
public void test2() {
List<Integer> list = new ArrayList<Integer>();
list.add(67);
list.add(54);
list.add(87);
// list.add("MM");
Iterator<Integer> iterator = list.iterator();
while(iterator.hasNext()){
Integer score = iterator.next();
System.out.println(score);
}
// 不允许。
// List<int> list = new ArrayList<int>();
}例子2：
@Test
public void test3() {
HashMap<String,Integer> map = new HashMap<>(); // 类型推断：int[] arr = {1,2,3};
map.put("Tom", 12);
map.put("Lilei", 23);
map.put("HanMeimei", 33);
map.put("Jim", 14);
// map.put(12, "Jerry");
Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
Iterator<Map.Entry<String,Integer>> iterator =entrySet.iterator();
while(iterator.hasNext()){
Entry<String, Integer> entry = iterator.next();
System.out.println(entry.getKey() + "-->" + entry.getValue());
}
}总结
（1）泛型参数只能使用引用数据类型，不能使用基本数据类型；
（2）集合中，如果没有使用泛型，则默认使用 Object 类型；
如果集合中使用泛型，则集合的相关属性、方法中，凡是使用到类或接口泛型参数的地方，都要调整为具体的泛型类型。
（3）什么时候使用泛型呢？
首先，类或接口应该声明为泛型类、泛型接口；
其次，在实例化类时，就可以指明泛型参数的类型。
java.io.File 类的使用
（1）FIle 类的一个对象，代表着一个文件（.txt , .doc , .jpg , .avi等）或文件目录；
（2）本章涉及到的 File，流相关的类，都定义在 java.io 包下；
（3）File 类的对象，如果作为一个文件，就可以理解作为一个端点（起始点、目标点）被流所使用；
代码上的体现：常常将 File 类的对象，作为参数传递给流的构造器中。
（4）File 类中提供了文件或文件目录的创建、重命名、长度、删除等操作，但是并没涉及到文件内容的读写。如果涉及到文件内容的读写的话，就需要使用流。
File 类的实例化
程序（program）：是为完成特定任务、用某种语言编写的一组指令的集合，即指一段静态的代码，静态对象。
进程（process）：是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。——生命周期。
①如：运行中的QQ、运行中的QQ播放器；
②进程是动态的，程序是静态的；
③进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。
实现网络通信需要解决的两个问题
（1）如何准确地定位互联网上的一台或多台主机；
（2）如何实现可靠而高效的数据传输。
网络通信（就对应着上面的两个问题）
要素一：使用 IP 地址，定位网络中的主机；
要素二：遵循相关的网络通信协议。
针对要素一
（1）IP：一个 IP 地址，对应着网络中的一台主机。如“192.168.10.16”、“127.0.0.1” --- 本地回路地址。
使用 InetAddress 类来代表 IP，一个 InetAdress 类的对象，就代表着一个具体的 IP 地址。
（2）如何实现 InetAdress 类
①getByName(String hostName) ②getLocalHost()；
（3）两个方法的使用
getHostName() / getHostAddress()
（4）域名：www.baidu.com
域名解析：域名容易记忆，当在连接网络时，输入一个主机的域名之后，域名服务器（DNS）负责将域名转化为 IP 地址，这样才能和主机建立连接）。
端口号的使用
端口号标识正在计算机中运行的进程（程序）
注意：不同的进程对应不同的端口号
常见的端口号：http:80 tomcat:8080 mysql:3306 oracle:1521 等。
针对要素二
使用网络通信协议
TCP 与 UDP 协议的区别
TCP 协议：
（1）使用 TCP 协议前，须先建立 TCP 连接，形成传输数据通道；
（2）传输前，采用“三次握手”的方式，是可靠的；
（3）TCP 协议进行通信的两个应用进程：客户端、服务端；
（4）在连接中可进行大数据量的传输；
（5）传输完毕，需释放已建立的连接，效率低。
UDP 协议：
（1）将数据、源、目的封装成数据包，不需要建立连接；
（2）每个数据报的大小限制在 64k 内；
（3）因无需连接，故是不可靠的；
（4）发送数据结束时无需释放资源，速度快。
面向对象学习的三条主线
（1）类与类的成员：属性、方法、构造器、代码块、内部类
（2）面向对象的三大特征：封装性、继承性、多态性、（抽象性）
（3）关键字：this、package、import、super、final、abstract、interface等
面向对象与面向过程（理解）
面向过程：强调的是功能行为。
面向对象：将功能封装进对象，强调了具备功能的对象。
完成一个项目（或功能）的思路
（1）是否已经存在具有相关功能结构的对象，如果存在，直接调用；
（2）如果此对象不存在，则需要自己创建一个对象；
（3）如果发现创建此对象的类不存在，则需要创建一个具备相关功能的类。
面向对象中两个重要的概念
类（class）：对一类事物的描述，抽象的，概念的。
对象（object、instance）：实实在在存在的一个个体，是具体的，形象的。
二者的关系：对象，是由类派生的，创建的。
面向对象思想落地实现的规则
（1）创建一个类，并设计类的内部结构：属性、方法、构造器、代码块、内部类；
（2）创建类的对象（最主要的方法：new()）；
（3）通过“对象.方法”或“对象.属性”的方式，实现相关的功能的调用。