java学习

最新推荐文章于 2024-09-11 17:19:54 发布

huasha2022

最新推荐文章于 2024-09-11 17:19:54 发布

阅读量99

点赞数 3

文章标签： java 学习开发语言

本文链接：https://blog.csdn.net/huasha2022/article/details/139380651

版权

一，认识java

一，java的背景
1,java是什么

java一门高级语言。

（面向对象编程，接近人类的自然语言，易上手）

2,java是哪家公司研发？现在属于哪家公司？

sun公司(stanford university network) 1995年推出。

现在属于Oracle（甲骨文）公司，2009年收购。

3，java名字来历？

早期名称为Oak（橡树），因商标被注册，改名为java（印度生产咖啡的一个岛屿）。

4，java之父是谁？

詹姆斯 · 高斯林（James Gosling）

5，java能做什么？

桌面应用开发，企业级应用开发，移动应用开发，服务器系统，大数据开发，游戏开发等。

现在市面主要做企业级应用，互联网系统的开发。

6，java有哪些技术平台

java SE(java standard edition )：标准版，java技术的核心和基础

java EE(java enterprise edition)：企业版，企业级应用开发的一套解决方案

java ME(java micro edition)：小型版，针对移动设备应用的解决方案

市面主要用SE版兼EE版，ME版较少

二，java的学习

面向过程：

一、注释和标识符

1. 注释
Java 语言提供三种类型的注释：
单行注释：以// 开始，以换行符结束。
多行注释：以/* 开始，以*/结束，每行以开始。
文档注释：以/** 开始，以/ 结束，注释中的每行必须以*开始。采用javadoc命令可以从源代码中将信息取出，生成html格式的说明文档。

2. 字符集
ASCII字符集：美国信息互换标准编码，主要用于显示现代英语和其它西欧语言。
GB2312字符集：中国国家标准的简体中文字符集。
Unicode字符集：支持各种不同语言的书面文本的交换、处理及显示。javac -encoding utf-8 hello.java //编译克服乱码命令行
UTF-8（长度可变）
UTF-16（16位）
UTF-32（32位）

3. 标识符
在Java中标识符的命名规则：
标识符必须以字母或下划线()或 $ 符号开始。其余字符可以是字母、数字、$ 符号和下划线。
标识符只能包含两个特殊字符，即下划线 () 和美元符号 ($)。不允许有任何其他特殊字符。
标识符不能包含空格。
区分大小写。
不能使用Java关键字。

4. 关键字(略)

二、数据类型

1.基本类型
（1）基本数据类型的特点

Java 中的基本数据类型的长度是固定的，不依赖于硬件平台，因此具有良好的可移植性。（共8种）
整数类型 (byte、short、int、long)
浮点数类型 (float、double)
字符类型 (char)
布尔类型 (boolean)

Java 中的基本数据类型必须有初始值
成员变量：Java语法规则规定了初始值
局部变量：Java不提供初始值

（2）类型转换

java是强类型语言，在运算过程中需要进行类型转换
运算中，不同类型数据先转化同一类型，再进行计算
低------------------------------>高

byte->short->char->int->long->float->double

强制类型转换

由高到低, 必须进行转换
语法：(类型)值，如(byte)num

public class HelloWorld {


    public static void main(String[] args) {
            // 定义整型
            int num=100;
            // 将整型的值直接复制给byte类型是不可以，需要进行转换
            //byte a= num; 错误写法
            byte a=(byte)num;  
            System.out.println(num);
            System.out.println(a);
    }
}

注意

不能对布尔值进行转换
不能把对象转换为不不相干的类型
转换的时候可能存在内存溢出问题
高转低时，需要强制转，反之不需要

三、变量

变量是什么？是可以变化的量！！！
JAVA是强类型语言，每个变量都必须声明类型
要素包括：变量名、变量类型、作用域
不建议一行定义同类型多个值！！！如：int a,b,c

类变量

类变量，可以直接进行调用，不需要进行实例化
语法： static 类型变量名
学习过程中，变量都加上static方便调用

实例变量

实例变量从属于对象，所以使用前必须要进行实例化对象才可以进行调用
实例变量，从属于对象，即需要实例化对像Demo8这个类之后才能调用
实例变量没有定义值，会变成这个默认值
- int默认值: 0
- String默认值: null
- 布尔值默认: false

四、常量

初始化后不能变化的值，不会变动的值
常量是一种特殊的变量，它的值被设定后，在程序后续运行过程中不允许被改变
常量一般用大写！！！
语法
- final double 变量名 = 值

五、运算符

操作符

描述

例子

加法 - 相加运算符两侧的值

A + B 等于 30

减法 - 左操作数减去右操作数

A – B 等于 -10

乘法 - 相乘操作符两侧的值

A * B等于200

除法 - 左操作数除以右操作数

B / A等于2

％

取余 - 左操作数除以右操作数的余数

B%A等于0

称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。

（A && B）为假

| |

称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。

（A | | B）为真

！

称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。

！（A && B）为真。

自增/自减

代码调式的方法，可以看出代码运行过程
–的过运算过程和++一致

关系运算符

返回值为boolean，true或者false

逻辑运算符

& 、 | 运算与 && 、|| 运算是否相同？
A&B（A|B）需要先判断A的布尔值，再判断B的布尔值，最后再进行逻辑运算。
A&&B 先判断A的布尔值，当A为False时不再判断B的布尔值（将B短路），即A&&B的结果返回False。
A||B 先判断A的布尔值，当A为True时不再判断B的布尔值（将B短路），即A||B的结果返回True。

位运算符

Java的整型数据在内存中采用补码表示数字，补码的规定如下：
最高位为符号位，正数为0，负数为1。
对负数而言，其补码为其绝对值的反加1。

三位运算符

可以代替某些 if … else 语句

示例
int a = 10;
int b=20;
int c=(a>b)?1:-1;

instanceof运算符

用于判断一个对象是否为某个类的实例，返回true 或者false。

示例：
A a=new A();
B b=new B();
boolean x=a instanceof B;

六、流程控制语句

1、分支语句
if-else
switch

2、循环语句
while
do-while
for

3、转移语句
break
continue
return

break：
break 语句在循环中用于立即从当前循环终止控制。
遇到 break 语句时，将跳出当前循环。
continue：
continue 语句则是从其调用处跳至循环的开始处。
continue 语句之后的语句将不再执行。
return：
通常用在方法中，以便结束一个方法，有以下两种使用格式：
单独一个return关键字，则不返回任何值。
return关键字后面跟变量、常量或表达式。

七、数组

1.数组的语法

数组的声明主要是定义数组的名称及数组元素的数据类型,包含两种声明语句:
type arrayName[ ];
type[ ] arrayName;
其中，type为元素类型,arrayName为数组名称。
声明数组时不定义数组大小。

分配空间：

Java不支持变长数组,数组的大小一旦确定,就不可以改变。
数组采用new分配空间,其的语法为: type arrayName[]=new type[n];
示例: int a[]=new int[10];
为数组分配空间时，如果数组元素类型为基本类型，则自动对数组元素进行初始化。其值为此种类型的默认值。如：int默认为0，double默认为0.0。
对于基本数据类型的数组，可以不使用new创建（动态初始化），而采用直接给数组元素初值来实现，元素初值之间用逗号分隔（静态初始化）。
示例：int a[ ]={0，1，2，3，4}；

2.数组的应用

数组元素可以通过数组名和下标进行访问。下标的下界为0。
数组具有属性length，可以通过此属性得到数组的长度。
Java自动检查数组下标是否越界，如果下标小于0或大于等于length，则会发生错误，产生一个名为ArrayIndexOutOfBoundsException的异常。

3.数组的复制

方法一：可以通过循环实现数组元素的复制。

int a[]=new int[10];
int b[]=new int[a.length];
for(int i=0;i<a.length;i++)
{
  b[i]=a[i];
}

方法二：System类提供了arraycopy函数，可以实现数组的复制。函数原形为：

void arraycopy(Object src,int srcPos,Object dest,int destPos,int length);

 int a[]=new int[20];
 int b[]=new int[10];
 System.arraycopy(b,0,a,10,b.length);

4.数组的遍历（foreach）

使用foreach循环遍历数组和集合元素时，无需获得数组和集合长度，也无需根据索引来访问数组元素和集合元素，foreach循环自动遍历数组和集合的每个元素。
语法： for(数据类型变量名: 数组名)

public class ForeachDemo {
        public static void main(String[] args){
	int[] a = {5,7,20}
	System.out.println(“数组a中的元素是：”);
	for(int e:a){
		 System.out.println(e);
	}
        }
}

等于

for(int int i=0;i<a.length;i++){
		 System.out.println(a[i]);
	}

八、方法

1. 方法完整定义格式

解释

修饰符返回值类型方法名称(参数类型参数名称，...) { 方法体; return 返回值; }

修饰符: public static 目前固定
参数：进入方法的数据
返回值：从方法中出来的数据

2. 方法的三种调用格式：

【1】单独调用：方法名称(参数);
【2】打印调用：System.out.println(方法名称(参数));
【3】复制调用：数据类型变量名称 = 方法名称(参数);

TIPS：
返回值为void，只能进行单独调用

3. 有参数方法和无参数方法

小括号中有没有内容

4. 有返回值方法和无返回值方法

void为无返回值方法

TIPS：
【1】方法定义的先后无所谓
【2】方法定义不能产生嵌套包含关系
【3】想要执行方法，一定要调用方法
【4】如果方法有返回值，必须写 return 返回值；
【5】return后的返回值类型必须和方法的返回值类型一样
【6】对于一个没返回值的方法，return后不能有返回值，可以写return;且可以省略
【7】一个方法可以有多个return，但只有一个能被执行

5. 方法重载（overload）

多个方法有相同的名称，但参数列表不同
同一个方法名可以实现类似的多个功能

TIPS：
方法重载与下列因素有关:
【1】参数个数不同
【2】参数类型不同
【3】参数的多类型顺序不同

方法重载与下列因素无关:
【1】与参数名称无关
【2】与方法的返回值类型无关

九、java中的内存划分

基本结构

java的内存有五个部分：
【1】栈（stack）：存放的是方法中的局部变量，方法的运行一定要在栈中运行
局部变量：方法中的参数或{}中的内部变量
作用域：一旦超出作用域，立刻从栈中消失
【2】堆（heap）：凡是new出来的东西都在堆中
堆内存里的东西都有一个地址：16进制
堆内存里面的数据，都有默认值，规则：
A.整数类型：0
B.浮点类型：0.0
C.字符类型：’\u0000’
D.布尔类型：false
E.引用类型：null
【3】方法区（method area）：储存.class相关的信息，包含方法的信息
【4】本地方法栈（Native Method Stack）：与操作系统相关
【5】寄存器（pc register）：与cpu相关

面向对象

1.概述

面向过程：当实现一个功能时，每一个具体的步骤都要亲力亲为，处理每个细节
面向对象：当实现一个功能时，不关心具体步骤而是找具有该功能的人，帮忙处理

2.类和对象

【1】类：一组相关属性和行为的集合，可看作是一类事物的模版
属性：该事物的状态信息
行为：该事物能够做什么
【2】对象：一类事物的具体体现，对象是类的一个实例

类是抽象的对一类事物的描述
对象是体力的是一类事物的实例
类是对象的模版，对象是类的实体
3.类的定义

【1】格式

解释

public static ClassName { //成员变量 //成员方法 }

成员变量：对应事物的属性
成员方法：对应事物的行为（去掉static）

4.对象的创建和使用

【1】导包：指出需要使用的类在什么位置

import 包名称.类名称

对于和当前类属于同一个包的情况，可以省略导包语句
【2】创建

//格式
类名称 对象名 = new 类名称();

【3】使用
A.使用成员变量：对象名.成员对象名
B.使用成员方法：对象名.成员方法名(参数)

TIPS：
如果成员变量没有赋值，将会有一个默认值，规则和数组一样

5.成员变量和局部变量的区别

【1】定义的位置【重点】
局部变量：在方法的内部
成员变量：在方法的外部，直接写在类之中
【2】作用的范围不一样【重点】
局部变量：只有在方法中可以使用
成员变量：整个类都可以用
【3】默认值不一样【重点】
局部变量：没有默认值，必须手动赋值
成员变量：如果没有默认值，会像数组一样自动赋默认值
【4】内存的位置不一样【了解】
局部变量：栈内存
成员变量：堆内存
【5】生命周期不一样【了解】
局部变量：随着方法进栈而诞生，方法出栈而消失
成员变量：随着对象创建而诞生，对象被垃圾回收而消失

6.面向对象的三大特征之封装

【1】封装：把一些细节信息隐藏起来，对外界不可见
A.方法就是一种封装
B.关键字private也是一种封
【2】继承
【3】多态

7.private关键字的作用以及使用

【1】无法阻止不合理的数据被设置进来，用private来解决
【2】使用private后，本类中依然可以随意访问，但超出本类范围之外就不能直接访问了
【3】间接访问private变量，定义一对getter，setter方法
【4】setter/getter命名规则：
getter：不能有参数，返回值类型和成员变量对应
setter：不能有返回值，参数类型和成员变量对应

8._this关键字的作用

【1】当局部变量和类的成员变量重名时，根据“就近原则”，优先使用局部变量
【2】如果需要访问本类当中的成员变量，需要使用格式：

this.成员变量名

【3】通过谁调用的方法，谁就是this

9.构造方法

构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实是在调用构造方法
【1】格式：

public 类名称(参数类型 参数名称) {
  方法体
}

TIPS：
【1】构造方法的名称必须和类名称完全一样，就连大小写也要一样
【2】构造方法不要写返回值类型，连void都不写
【3】构造方法不能return一个具体的返回值
【4】如果没有任何构造方法，那么编译器会默认赠送一个构造方法，没有参数，方法体什么都不做
【5】一旦编写了至少一个构造方法，那么编译器将不再赠送
【6】构造方法也是可以进行重载的
重载：方法名称相同，参数列表不同

解释

//全参构造方法 public Student(String name, int age){ this.name = name; this.age = age; } Student stu = new Student(name:a, age:b);

10.标准的类

【1】所有成员变量都要使用private修饰
【2】为每一个成员变量编写一对getter/setter
【3】编写一个无参数的构造方法
【4】编写一个全参数的构造方法

这样的类也叫做java bean

快速创建方法：
【1】
【2】code->generate->getter and setter
【3】code->generate->constructor->select None
【4】code->generate->constructor->select all
快捷键：control+enter

继承

1.概述

【1】继承是多态的前提，如果没有继承，就没有多态
【2】继承主要解决的问题是共性抽取
【3】子类可以拥有父类的“内容”
【4】子类可以拥有自己的专属内容

2.格式

【1】关系：子类就是一个（is-a）父类
【2】格式：

解释

//父类格式：一个普通类的格式 public class 父类名称 {} //子类格式 public class 子类名称 extends 父类名称{}

3.成员变量的访问特点

在父子类的继承关系中，如果成员变量重名，则创建子类对象时，访问有两种方式：
【1】直接：通过子类对象访问成员变量：
等号左边是谁就优先用谁，没有则向上找(创建对象时的左边)
到处都没有时，编译报错
【2】间接：通过成员方法访问成员变量：
看方法属于谁就优先用谁，没有则向上找

4.区分子类方法中重名的三种变量

【1】局部变量：直接写成员变量名
【2】本类的成员变量： this.成员变量名
【3】父类的成员变量： super.成员变量名

5.继承中成员方法的访问特点

在父子类中有方法重名：创建的对象是谁，则优先用谁的方法

TIPS：
无论是成员变量还是方法，如果没有，一定是向上找父类的

6.方法的重写（override）

【1】概念：继承关系中，方法的名称和参数都一样
【2】重写和重载的区别
重写：名称一样，参数一样。覆盖，重写
重载：名称一样，参数不一样
【3】特点：创建的是子类对象则优先用子类方法

TIPS：
【1】安全检测

//注解：写在方法前面，用来检测是不是正确的有效覆盖
//注解可写可不写
@override

【2】子类方法返回值必须小于等于父类方法返回值范围
Object类是所有类的公共最高父类（祖宗类）
【3】子类方法的权限必须大于等于父类方法的权限修饰符
public>protected>(default)>private
default不是关键字而是什么都不写留空

设计原则：对于已经使用投入的类，尽量不要修改老的，推荐定义一个新的类，来重复利用其中共性内容，并且添加改动新内容（继承）

// 重写方法：使用重写的父类方法
super.方法名(参数);

7.继承中父子类构造方法的访问特点

【1】子类构造方法中有一个默认隐藏的"super()"的调用。所以一定是先调用父类构造，然后调用子类构造
【2】子类构造可以通过super关键字来调用父类重载构造
【3】super的父类构造调用必须是子类构造方法的第一句。不能一个子类构造调用多次super构造
（总结）：子类构造方法必须调用父类构造方法，不写则赠送super();写了则用写的指定的super调用，super只能有一个，还必须是第一个

8.继承的三个特点

【1】java是单继承：只能有一个父类
假设能够多继承，两个父类中都有method()方法，子类不知道调用哪个父类的method()方法
【2】java可以多级继承（有爷爷)：A也算是C的父类，但不能算是直接父类
【3】一个子类的直接父类是唯一的，但是一个父类可以拥有多个子类

super&this关键字总结

super关键字用来访问父类的内容
this关键字用来访问本类的内容

1.super关键字的三种用法

【1】子类成员方法中访问父类的成员变量
【2】子类成员方法中访问父类的成员方法
【3】子类构造方法中访问父类的构造方法

2.this关键字的三种用法

【1】本类成员方法中访问本类的成员变量
【2】本类成员方法中访问本类的另一个成员方法
【3】本类构造方法中访问本类的另一个构造方法
A.在第三种用法中要注意：this(…)调用也必须是构造方法的第一个语句
B.super和this两种构造调用不能同时使用

抽象

1.概述：

抽象方法：如果父类当中的方法不确定如何进行{}方法体实现，那么这是一个抽象的方法

2.格式：

解释

//抽象方法：加上abstract关键字，然后去掉大括号，直接分号结束 //抽象类：抽象方法所在的类必须是抽象类，在class前加上abstrac public abstract class Animal { public abstract void eat(); }

3.如何使用抽象类和抽象方法

【1】不能直接创建new抽象类对象
【2】必须用一个子类来继承抽象父类
子类必须覆盖重写（实现）父类当中所有的抽象方法
实现：去掉抽象方法的abstract，然后补上方法体大括号

解释

@overrid e public class Cat extends Animal{ public void eat() { sout(猫吃鱼); } }

4.创建子类对象进行使用

TIPS：
【1】不能直接创建对象
【2】抽象类可以有构造方法，提供子类创建对象时，初始化父类成员时使用的
【3】抽象类中，不一定有抽象方法，但有抽象方法的类一定是抽象类
【4】子类必须覆盖重写所有抽象方法，除非子类也是抽象类

接口

1.概述和生活例子

【1】电源插座中的电源接口：
接口是一种公共的规范标准，只要符合规范标准，大家都可以通用
【2】USB接口:
只要符合USB接口的规范，各种设备都能使用

2.基本定义格式

【1】接口是多个累的公共规范
【2】接口是一种引用数据类型，最重要的内容就是其中的抽象方法
【3】格式：

解释

public interface 接口名称{ //接口内容 } //备注：换成关键字interface之后还是.java->.class //接口中可以有的内容是： //java7 //1.常量 //2.抽象方法 //java8 //3.默认方法 //4.静态方法 //java9 //5.私有方法

3.抽象方法的定义

public abstract 返回值类型 方法名称(参数列表);

TIPS：
【1】接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
【2】这两个关键字修饰符，可以选择性地省略
【3】方法的三要素可以随意定义

4.抽象方法的使用

【1】接口不能直接使用，必须有一个“实现”类来“实现”接口

public class 实现类名称 implements 接口类名称{
  // ...
}

【2】接口的实现类必须覆盖重写（实现）接口中所有的抽象方法
【3】创建实现类的对象，进行使用

TIPS：
如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类

5.默认方法的定义

格式

解释

public default 返回值类型方法名称(参数列表){ 方法体 } //备注：接口中的默认方法，可以解决接口升级的问题

6.默认方法的使用

public default void methodDefault(){}

【1】接口的默认方法可以通过接口实现类对象直接调用
【2】接口的默认方法也可以通过接口实现类进行覆盖重写

7.静态方法的定义

格式：

public static 返回值类型 方法名称(参数列表) {
  //方法体
}

8.静态方法的使用

【1】不能通过接口实现类对象来调用接口中的静态方法
【2】应该通过接口名称直接调用其中的静态方法
【3】格式

接口名称.静态方法名称(参数列表) ;

多态(polymorphism)

1.概述

extends继承或implements实现，是多态性的前提
一个对象拥有多种形态就是对象的多态性

2.格式与使用

【1】父类引用指向子类对象
【2】格式：

解释

父类名称对象名 = new 子类名称(); 接口名称对象名 = new 实现类名称(); //左侧父类的引用，指向了右侧子类的对象 Fu obj = new Zi(); obj.method(); //子类方法

3.多态中成员变量的使用特点

【1】和继承没有区别
【2】访问有两种方式：
A. 直接：通过对象名称访问成员变量：
等号左边是谁就优先用谁，没有则向上找(创建对象时的左边)
到处都没有时，编译报错
B.间接：通过成员方法访问成员变量：
看方法属于谁就优先用谁，没有则向上找
子类没覆盖重写就是子
子类覆盖重写就是父
【3】编译看左边，运行还看左边

4.多态中成员方法的使用特点

【1】看new的是谁就优先用谁，没有则向上找
【2】编译看左边，运行看右边
编译看左边:左边是Fu，Fu当中没有methodZi方法，编译报错

5.多态的好处

在这里插入图片描述

6.对象的向上转型

【1】向上转型，就是对象的写法
【2】格式

父类名称 对象名 = new 子类名称();

【3】含义：右侧创建了一个子类对象，把它当作父类来看待

TIPS：
向上转型一定是安全的：从小范围转向大范围

7.对象的向下转型

【1】向上转型的弊端：
无法调用子类原本特有的方法
【2】解决方案：用对象的向下转型【还原的动作】
【3】格式：

子类名称 对象名 = (子类名称)父类对象;

【4】含义：将父类对象，还原成本来的子类对象

TIPS：
【1】保证对象创建的时候是什么，向下转型才能还原成什么
【2】如果对象创建时候是另一类，向下转型成这一类就会报错（ClassCastException）

8.Instanceof

【1】如何知道父类引用的对象是什么子类
【2】格式

//会得到一个boolean值结果
//也就是判断前面的对象能不能当作后面类型的实例
对象 instanceof 类型

API应用程序编程接口

1.概述

现成可直接使用的类

2.Scanner

【1】功能：使用户能从System.in中读取一个数
【2】步骤：
（1）导包：

import 包名.类名
import java.util.Scanner;

若需要使用的目标类和当前类在同一个包下，则不用import
只有java.lang下的包不需要import
（2）创建（构造方法）

类名称 对象名 = new 类名称();
Scanner sc = new Scanner(System.in);
//System.in代表从键盘输入

（3）使用

解释

对象名.成员方法名()； //从键盘获取一个int int num = sc.nextInt(); //从键盘获取一个string String sc = sc.next();

3.匿名对象

【1】创建对象的标准格式

类名称 对象名 = new 类名称;

【2】匿名对象只有右边的对象，没有左边的名字和赋值运算符

new 类名称;

TIPS：
匿名对象只能使用唯一的一次，下次再用不得不再创建一个新对象

new Person().name = a;
new Person().showName(); //结果：null

【3】匿名对象作为方法的参数和返回值

解释

//匿名对象来进行传参 methodParam(new Scanner(System.in)); public static void methodParam(Scannner sc){ int num = sc.nextInt(); } //匿名参数作为方法的返回值 public static Scanner(){ return new Scanner(System.in); } Scanner sc = methodReturn(); int num = sc.nextInt();

4.Random

【1】功能：用来生成随机数字
【2】步骤：
（1）导包：

import java.util.Random;

（2）创建

Random r = new Random();
//小括号中留空即可

（3）使用

解释

对象名.成员方法名()； //获取一个随机的int数字(范围所有int，有正负) int num = r.nextInt(); //获取一个随机的int数字(参数代表范围，左闭右开区间)[0,3)=0~2 int num = r.nextInt(3);

5.对象数组

【1】用来存储对象的数组
【2】储存的是对象的地址值
【3】缺点：一旦创建，长度不能改变

6.ArrayList集合

【1】区别：长度可以随意变化
【2】Class ArrayList
< E >：范型：装在集合中的所有元素都是统一的什么类型
范型只能是引用类型，不能是基本类型
【3】格式：

ArrayList<String> list=new ArrayList<>();

右侧 <> 中可以不写类型
【4】打印：

System.out.println(list); //[]

直接打印的不是地址值，而是内容[ ]
【5】常用方法

解释

//添加数据，参数类型为范型，返回值为添加是否成功 //对Arraylist来说，一定成功，但对其他集合不一定 public boolean add(E e); //获取元素，参数是索引编号，返回值是对应元素，索引值从0开始 public E get(int index); //删除元素，参数是索引编号，返回值是删掉的元素，索引值从0开始 public E remove(int index)； //获取尺寸长度，返回值是元素的个数 public int size();

【6】遍历集合
使用for循环