资源描述
<p><span id="_baidu_bookmark_start_0" style="display: none; line-height: 0px;"></span>
Java学习笔记
目 录
一、 Java技术基础
1.1编程语言
1.2 Java的特点
1.3 Java开发环境
1.4 Java开发环境配置
1.5 Linux命令与相关知识
1.6 Eclipse/Myeclipse程序结构
二、 Java语言基础
2.1基础语言要素
2.2八种基本数据类型
2.3常量和变量
2.4运算符与表达式
2.5编程风格
2.6流程控制语句
2.7数组
2.8字符串
2.9方法三要素
2.10插入排序
2.11冒泡排序
2.12冒泡排序：轻气泡上浮的方式
2.13二分法查找
2.14 Java系统API方法调用
2.15二进制基础
2.16 Java基础其他注意事项
三、 面向对象
3.1类
3.2对象
3.3包
3.4方法及其调用
3.5引用
3.6访问控制（封装）
3.7构造器
3.8 super()、super．和 this()、this．
3.9重载和重写
3.10继承
3.11 static
3.12 final
3.13多态
3.14抽象类
3.15接口
3.16内部类
3.17匿名类
3.18二维数组和对象数组
3.19其他注意事项
四、 Java SE核心I
4.1 Object类
4.2 String类
4.3 StringUtils类
4.4 StringBuilder类
4.5正则表达式
4.6 Date类
4.7 Calendar类
4.8 SimpleDateFormat类
4.9 DateFormat类
4.10包装类
4.11 BigDecimal类
4.12 BigInteger类
4.13 Collection集合框架
4.14 List集合的实现类ArrayList和LinkedList
4.15 Iterator迭代器
4.16泛型
4.17增强型for循环
4.18 List高级－数据结构：Queue队列
4.19 List高级－数据结构：Deque栈
4.20 Set集合的实现类HashSet
4.21 Map集合的实现类HashMap
4.22单例模式和模版方法模式
五、 Java SE核心II
5.1 Java异常处理机制
5.2 File文件类
5.3 RandomAccessFile类
5.4基本流：FIS和FOS
5.5缓冲字节高级流：BIS和BOS
5.6基本数据类型高级流：DIS和DOS
5.7字符高级流：ISR和OSW
5.8缓冲字符高级流：BR和BW
5.9文件字符高级流：FR和FW
5.10 PrintWriter
5.11对象序列化
5.12 Thread线程类及多线程
5.13 Socket网络编程
5.14线程池
5.15双缓冲队列
Java技术基础
1.1编程语言
机器语言：0 1 在硬件直接执行
汇编语言：助记符
高级语言： （Java运行比C/C++慢）
1）面向过程的高级语言：程序设计的基本单位为函数，如：C/C++语言。
2）面向对象的高级语言：程序设计的基本单位为类，如：Java、C#。
1.2 Java的特点
平台无关性、简单性、面向对象、健壮性、多线程、自动内存管理。
平台无关性：指Java语言平台无关，而Java的虚拟机却不是，需要下载对应平台JVM虚拟机的。
自动内存管理：对临时存储的数据自动进行回收，释放内存。如：引用类型的变量没有指向时，被回收；程序执行完后，局部变量被回收。
1.3 Java开发环境
Java Developement Kit——Java开发工具包，简称JDK，是由Sun公司提供的一个免费的Java开发工具，编程人员和最终用户可以利用这个工具来编译、运行Java程序。目前版本有JDK1.0、JDK1.1、JDK1.2、JDK1.3、JDK1.4、JDK1.5（J2SE5.0）、JDK1.6（J2SE6.0）、JDK1.7（J2SE7.0）。
JDK结构：JDK
|--开发工具（Tools）命令：java、javac、jar、rmic ...
|-- JRE（Java基本运行环境）
|--系统API库，系统类库
| 系统带来的标准程序库，标准API
|-- J VM java虚拟机
java 语言的执行环境
1.4 Java开发环境配置
安装完JDK之后，不能立刻使用，需要设置环境变量：
1）设置PATH：D:\Java\jdk1.6.0\bin（指向JDK中bin文件夹，有各种编译命令）。
2）CLASSPATH：告诉Java程序去哪里查找第三方和自定义类，如果 .class文件和类源文件在同一文件夹内，则不需要配置classpath，后续有包，则需要。
A．Windows：在命令行执行
set CLASSPATH=E:\workspace\1304\bin （临时环境配置）
java day02.Demo1
u 注意事项：
v E：\ set classpath = c:\ （不加分号就不找当前路径）
= . ; c:\ ; d:\ ;（先找classpath，若无，再找当前路径）
v C、D两盘有同名 . class 文件，classpath设置为D盘，而命令行窗口当前盘符为C盘，则JVM现找classpath路径，后找当前路径。
B．Linux：在控制台执行
①设置CLASSPATH环境变量，指向package所在的目录，一般是项目文件夹中的bin目录。
②执行java package.ClassName （包名必须写）。
export CLASSPATH=/home/soft01/workspace/1304/bin （临时环境配置）
java day01.HelloWorld
java -cp /home/soft01/workspace/1304/bin day01.HelloWorld（二合一）
u 注意事项：
v Windows根目录是反斜线：\
v Linux根目录是斜线：/
1.5 Linux命令与相关知识
1）Linux无盘符，只有一个根目录（root）
2）终端 == 控制台 == 命令行窗口
3）pwd：打印当前工作目录，显示当前工作目录的位置
4）ls：列表显示目录内容，默认显示当前目录内容
5）cd：改变当前工作目录；cd后不加参数=返回home文件夹；cd ~：返回home；
cd /：切换到根目录；cd .. ：返回上一层目录（相对的）；
6）mkdir：创建文件夹（目录） 注意：目录 == 文件夹
7）rm：删除文件；rm xx xx：可删多个文件；
rm –rf xx：-为减号，r表递归，f表强制
8）cat xx：显示文本文件内容
9）启动Java开发工具：cd/opt/eclipse à ./eclipse . 表当前目录下
10）绝对路径： /home （以 / 开始为绝对路径，相对于根目录）
相对路径：home （相对于当前工作目录）
11）home（用户主目录，用户的家）：/home/username 如：/home/soft01
12）主目录（home）：有最大访问权限：什么都能干，增删改查、建目录等
其他地方：一般只能查看，不能增删改查、创建目录等
1.6 Eclipse/Myeclipse程序结构
Project项目文件
|-- src源文件
| |-- Package包
| |-- .java源文件
|-- bin
|-- Package包
|-- .class字节码程序
u 注意事项：
v Myeclipse5.5消耗少，Myeclipse6.5最稳定
Java语言基础
2.1基础语言要素
1）标识符：给类、方法、变量起的名字
A．必须以字母或下划线或 $ 符号开始，其余字符可以是字母、数字、$ 符号和下划线。
B．只能包含两个特殊字符，即下划线 _ 和美元符号 $ 。不允许有任何其他特殊字符。
C．标识符不能包含空格。
D．区分大小写。
2）关键字：只有系统才能用的标识符
u 注意事项：
v true、false、null不是关键字！是字面量。
v main不是关键字！但是是一个特殊单词，可以被JVM识别，主函数是固定格式，作为程序的入口。
3） 注释：单行注释：// 多行注释：/* ……*/ 文档注释：/**……*/
u 注意事项：开发中类前、属性前、方法前，必须有文档注视。
2.2八种基本数据类型
1）四种整数类型(byte、short、int、long)：
byte：8位，用于表示最小数据单位，如文件中数据，-128~127
short：16位，很少用，-32768 ~ 32767
int：32位、最常用，-2^31-1~2^31 （21亿）
long：64位、次常用
u 注意事项：
v int i=5; // 5叫直接量（或字面量），即直接写出的常数。
v 整数字面量默认都为int类型，所以在定义的long型数据后面加L或l。
v 小于32位数的变量，都按int结果计算。
v 强转符比数学运算符优先级高。见常量与变量中的例子。
2）两种浮点数类型(float、double)：
float：32位，后缀F或f，1位符号位，8位指数，23位有效尾数。
double：64位，最常用，后缀D或d，1位符号位，11位指数，52位有效尾数。
u 注意事项：
v 二进制浮点数：1010100010=101010001.0*2=10101000.10*2^10(2次方)=1010100.010*2^11(3次方)= . 1010100010*2^1010(10次方)
v 尾数： . 1010100010 指数：1010 基数：2
v 浮点数字面量默认都为double类型，所以在定义的float型数据后面加F或f；double类型可不写后缀，但在小数计算中一定要写D或X.X。
v float 的精度没有long高，有效位数（尾数）短。
v float 的范围大于long 指数可以很大。
v 浮点数是不精确的，不能对浮点数进行精确比较。
3）一种字符类型(char)：
char：16位，是整数类型，用单引号括起来的1个字符（可以是一个中文字符），使用Unicode码代表字符，0~2^16-1（65535）。
u 注意事项：
v 不能为0个字符。
v 转义字符：\n 换行 \r 回车 \t Tab字符 \" 双引号 \\ 表示一个\
v 两字符char中间用“+”连接，内部先把字符转成int类型，再进行加法运算，char本质就是个数！二进制的，显示的时候，经过“处理”显示为字符。
4）一种布尔类型(boolean)：true真 和false假。
5）类型转换： char-->
自动转换：byte-->short-->int-->long-->float-->double
强制转换：①会损失精度，产生误差，小数点以后的数字全部舍弃。
②容易超过取值范围。
2.3常量和变量
变量：内存中一块存储空间，可保存当前数据。在程序运行过程中，其值是可以改变的量。
1）必须声明并且初始化以后使用（在同一个作用域中不能重复声明变量）！
2）变量必须有明确类型（Java是强类型语言）。
3）变量有作用域（变量在声明的地方开始，到块｛｝结束）。变量作用域越小越好。
4）局部变量在使用前一定要初始化！成员变量在对象被创建后有默认值，可直接用。
5）在方法中定义的局部变量在该方法被加载时创建。
常量：在程序运行过程中，其值不可以改变的量。
u 注意事项：
v 字面量、常量和变量的运算机制不同，字面量、常量由编译器计算，变量由运算器处理，目的是为了提高效率。
eg：小于32位数的字面量处理
byte b1 = 1; byte b2 = 3;
//byte b3 = b1+b2;//编译错误，按照int结果，需要强制转换
byte b3 = (byte)(b1+b2);
//byte b3 = (byte)b1+(byte)b2;//编译错误！两个byte、short、char相加还是按int算
System.out.println(b3); //选择结果：A编译错误B运行异常 C 4 D b3
byte b4 = 1+3;//字面量运算，编译期间替换为4，字面量4
//byte b4 = 4; 不超过byte就可以赋值
v 不管是常量还是变量，必须先定义，才能够使用。即先在内存中开辟存储空间，才能够往里面放入数据。
v 不管是常量还是变量，其存储空间是有数据类型的差别的，即有些变量的存储空间用于存储整数，有些变量的存储空间用于存储小数。
2.4运算符与表达式
1）数学运算：+ - * / % ++ --
u 注意事项：
v + - * / 两端的变量必须是同种类型，并返回同种类型。
v % 取余运算，负数的余数符号与被模数符号相同， - 1 % 5 = - 1，1 % - 5 = 1；Num % n，n>0，结果范围[0,n)，是周期函数。
v 注意整除问题：1 / 2 = 0（整数的除法是整除）1.0 / 2 = 0.5 1D / 2 = 0.5
v 单独的前、后自增或自减是没区别的，有了赋值语句或返回值，则值不同！
eg1：自增自减
int a = 1; a = a++; System.out.println("a的值："+a);
第1步：后++，先确定表达式a++的值（当前a的值） a++ ---->1
第2步：++，给a加1 a ---->2
第3步：最后赋值运算,把a++整个表达式的值赋值给a a ---->1
a被赋值两次，第1次a = 2，第2次把1赋值给1
eg2：自增自减
x，y，z分别为5，6，7 计算z + = -- y * z++ ；// x = 5，y = 5，z = 42
z = z + -- y * z++ à 42 = 7 + 5 * 7 从左到右入栈，入的是值
eg3：取出数字的每一位
d = num%10;//获取num的最后一位数 num/=10; //消除num的最后一位
2） 位运算：& | ~（取反） ^（异或）>> <<>>>
u 注意事项：
v 一个数异或同一个数两次，结果还是那个数。
v |：上下对齐，有1个1则为1；&：上下对齐，有1个0则为0；（都为二进制）
v &相当于乘法，| 相当于加法；&：有0则为0，| ：有1则为1，^：两数相同为0，不同为1。
3）关系运算符：> < >= <= 0="" 1="" 2="" 3="" int="" x="”+x+”,y=”+y+”,z=”+z);//" x--="=1" -="*=" flag="" u="" v="" a=""> b ? a : i > j ? i : j 相当于 a > b ? a : ( i > j ? i : j )
v 三目运算符中：第二个表达式和第三个表达式中如果都为基本数据类型，整个表达式的运算结果由容量高的决定。如：int x = 4; x > 4 ? 99.9 : 9;
99.9是double类型，而9是int类型，double容量高，所以最后结果为9.9。
7） 运算符优先级：括号 > 自增自减 > ~ ! > 算数运算符 > 位移运算 > 关系运算 > 逻辑运算 > 条件运算 > 赋值运算
2.5编程风格
MyEclipse/Eclipse中出现的红色叉叉：编译错误
编译错误：java编译器在将Java源代码编译为class文件的过程出现的错误，一般是语法使用错误！当有编译错误时候，是没有class文件产生，也就不能运行程序。
Java 程序结构：
2.6流程控制语句
1）选择控制语句
if语句：if 、if-else、if-else-if：可以处理一切分支判断。
格式：if(判断){…}、if(判断){…}else{…}、if(判断){…}else if(判断){…}
switch语句：switch(必须整数类型){case 常量1：…; case 常量2：… ; ….}
u 注意事项：
v int类型指：byte、short、int，只能写long类型，要写也必须强转成int类型；而byte、short为自动转换成int。
v swtich-case：若case中无符合的数，并且default写在最前（无break时）， 则为顺序执行，有break或 } 则退出。
v swtich-case：若case中无符合的数，并且default写在最后，则执行default。
v swtich-case：若case中有符合的数，并且default写在最后，并且default前面的case没有break时，default也会执行。
2）循环控制语句
①for：最常用，用在与次数有关的循环处理，甚至只用for可以解决任何循环问题。
u 注意事项：for中定义的用于控制次数的循环变量，只在for中有效，for结束则循环变量被释放（回收）。
②while：很常用，用在循环时候要先检查循环条件再处理循环体，用在与次数无关的情况。如果不能明确结束条件的时候，先使用while(true)，在适当条件使用if语句加break结束循环。
③do-while：在循环最后判断是否结束的循环。如：使用while(true) 实现循环的时候，结束条件break在while循环体的最后，就可以使用 do-while 。do-while 的结束条件经常是“否定逻辑条件”，不便于思考业务逻辑，使用的时候需要注意。可以利用while（true）+ break 替换。
④循环三要素：A．循环变量初值 B．循环条件 C．循环变量增量（是循环趋于结束的表达式）
⑤for和while循环体中仅一条语句，也要补全{ }，当有多条语句，且不写{ }时，它们只执行紧跟着的第一条语句。
⑥循环的替换：
while(布尔表达式){} 等价 for(;布尔表达式;){}
while(true){} 等价 for(;;)
while(true){} + break 替换 do{}while(布尔表达式);
for(;;) + break 替换 do{}while(布尔表达式);
3）跳转控制语句
continue：退出本次循环，直接执行下一次循环
break：退出所有循环
2.7数组
类型一致的一组数据，相当于集合概念，在软件中解决一组，一堆XX数据时候使用数组。
1）数组变量：是引用类型变量（不是基本变量）引用变量通过数组的内存地址位置引用了一个数组（数组对象），即栓到数组对象的绳子。
eg：数组变量的赋值
int[] ary = new int[3];// ary----->{0,0,0}<----ary1
int[] ary1 = ary;// ary 的地址赋值给ary1，ary 与 ary1 绑定了同一个数组
//ary[1] 与 ary1[1] 是同一个元素，数组变量不是数组（数组对象）
2）数组（数组对象）有3种创建（初始化）方式：①new int[10000] 给元素数量，适合不知道具体元素，或元素数量较多时 ②new int[]{3,4,5} 不需要给出数量，直接初始化具体元素适合知道数组的元素。③ {2,3,4} 静态初始化，是②简化版，只能用在声明数组变量的时候直接初始化，不能用于赋值等情况。
eg：数组初始化
int[] ary1 = new int[]{2,3,4};//创建数组时候直接初始化元素
int[] ary2 = {2,3,4};//数组静态初始化，只能在声明变量的同时直接赋值
//ary2 = {4,5,6};//编译错误，不能用于赋值等情况
ary2 = new int[]{4,5,6};
3）数组元素的访问：①数组长度：长度使用属性访问，ary.length 获取数组下标。②数组下标：范围：0 ~ length-1就是[0,length)，超范围访问会出现下标越界异常。③使用[index] 访问数组元素：ary[2]。④迭代（遍历）：就是将数组元素逐一处理一遍的方法。
4）数组默认初始化值：根据数组类型的不同，默认初始化值为：0（整数）、0.0（浮点数）、false（布尔类型）、\u0000（char字符类型，显示无效果，相当于空格，编码为0的字符，是控制字符，强转为int时显示0）、null（string类型，什么都没有，空值的意思）。
5）数组的复制：数组变量的赋值，是并不会复制数组对象，是两个变量引用了同一个数组对象。数组复制的本质是创建了新数组，将原数组的内容复制过来。
6）数组的扩容：创建新数组，新数组容量大于原数组，将原数组内容复制到新数组，并且丢弃原数组，简单说：就是更换更大的数组对象。System.arraycopy() 用于复制数组内容，简化版的数组复制方法：Arrays.copyOf()方法，但需JKD1.5+。
2.8字符串
字符串(string)：永远用“”双引号（英文状态下），用字符串连接任何数据（整数），都会默认的转化为字符串类型。
字符串与基本数据类型链接的问题：如果第一个是字符串那么后续就都按字符串处理，如System.out.println("(Result)"+6 + 6 );那么结果就是(Result)66，如果第一个和第二个…第n个都是基本数据，第n+1是字符串类型，那么前n个都按加法计算出结果在与字符串连接。如下例中的System.out.println(1+2+”java”+3+4);结果为3java34。
eg：字符串前后的“+”都是连接符！不是加法运算符！
System.out.println("A"+'B');//AB
System.out.println('A'+'B');//131
System.out.println(1+2+”java”+3+4);//3java34
u 注意事项：比较字符串是否相等必须使用equals方法！不能使用==。"1".equals(cmd) 比cmd.equals("1") 要好。
2.9方法三要素
方法：method（函数function = 功能） y=f(x)
1）方法的主要三要素：方法名、参数列表、返回值。
2）什么是方法：一个算法逻辑功能的封装，是一般完成一个业务功能，如：登录系统，创建联系人，简单说：方法是动作，是动词。
3）方法名：一般按照方法实现的功能定名，一般使用动词定义，一般使用小写字母开头，第二个单词开始，单词首字母大写。如：createContact() 。
4）参数列表：是方法的前提条件，是方法执行依据，是数据。如：
login(String id, String pwd) ，参数的传递看定义的类型及顺序，不看参数名。
5）方法返回值：功能执行的结果，方法必须定义返回值，并且方法中必须使用return语句返回数据；如果无返回值则定义为void，此时return语句可写可不写；返回结果只能有一个，若返回多个结果，要用数组返回（返回多个值）。
u 注意事项：递归调用：方法中调用了方法本身，用递归解决问题比较简练，只需考虑一层逻辑即可！但是需要有经验。一定要有结束条件！如：f(1)=1; 递归层次不能太深。总之：慎用递归！
2.10插入排序
将数组中每个元素与第一个元素比较，如果这个元素小于第一个元素，则交换这两个元素循环第1条规则，找出最小元素，放于第1个位置经过n-1轮比较完成排序。
for(int i = 1; i < arr.length; i++) {
int k = arr[i];// 取出待插入元素
int j;// 找到插入位置
for (j = i - 1; j >= 0 && k < arr[j]; j--) {
arr[j + 1] = arr[j];// 移动元素
}
arr[j + 1] = k;// 插入元素
System.out.println(Arrays.toString(arr));
}
2.11冒泡排序
比较相邻的元素，将小的放到前面。
for(int i = 0; i < arr.length - 1; i++) {
boolean isSwap = false;
for (int j = 0; j < arr.length - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int t = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = t;
isSwap = true;
}
}
if (!isSwap){ break; }
System.out.println(Arrays.toString(arr));
}
2.12冒泡排序：轻气泡上浮的方式
冒泡排序法可以使用大气泡沉底的方式，也可以使用轻气泡上浮的方式实现。如下为使用轻气泡上浮的方式实现冒泡排序算法。
for (int i = 0; i < arr.length - 1; i++) {
boolean isSwap = false;
for (int j = arr.length - 1; j > i; j--) {
if (arr[j] < arr[j - 1]) {
int t = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = t;
sSwap = true;
}
}
if (!isSwap){ break; }
System.out.println(Arrays.toString(arr));
}
2.13二分法查找
intlow = 0; inthigh = arr.length - 1; intmid = -1;
while(low <= high) {
mid = (low + high) / 2;
if (arr[mid] < value){ low = mid + 1; }
else if (arr[mid] > value){ high = mid - 1; }
else{ break;}
}
if (low <= index=" + mid + " else=""> k，在前半段中继续进行二分查找；
若arr[mid] < k，则在后半段中继续进行二分查找。
假如有一组数为3、12、24、36、55、68、75、88要查给定的值k=24。可设三个变量low、mid、high分别指向数据的上界，中间和下界，mid=（low+high）/2.
1）开始令low=0（指向3），high=7（指向88），则mid=3（指向36）。因为k</p><mid，故应在前半段中查找。 high="mid-1=2（指向24），而low=0（指向3）不变，则新的mid=1（指向12）。此时k">mid，故确定应在后半段中查找。
3）令新的low=mid+1=2（指向24），而high=2（指向24）不变，则新的mid=2，此时k=arr[mid]，查找成功。
如果要查找的数不是数列中的数，例如k=25，当第四次判断时，k>mid[2]，在后边半段查找，令low=mid+1，即low=3(指向36)，high=2（指向24）出现low>high的情况，表示查找不成功。
2.14 Java系统API方法调用
Arrays类，是数组的工具类，包含很多数组有关的工具方法。如：
1）toString() 连接数组元素为字符串，方便数组内容输出。
2）equals 比较两个数组序列是否相等。
3）sort() 对数组进行排序，小到大排序。
4）binarySearch(names, "Tom") 二分查找，必须在有序序列上使用。
2.15二进制基础
1）计算机中一切数据都是2进制的! 基本类型，对象，音频，视频。
2）10进制是人类习惯，计算按照人类习惯利用算法输入输出。
"10" -算法转化-> 1010(2) 1010 -算法转化-> "10"
3）16进制是2进制的简写，16进制就是2进制！
4）计算机硬件不支持正负号，为了解决符号问题，使用补码算法，补码规定高位为1则为负数，每位都为1则为-1，如1111 1111 = -1 = 0xff
5）二进制数右移>>：相当于数学 / 2(基数)，且正数高位补0，负数高位补1；二进制字左移<<：相当于数学>>>：相当于数学 / 2(基数)，且不论正负，高位都补0。
6）注意掩码运算：把扩展后前面为1的情况除去，与0xff做与运算。
eg1：二进制计算
int max = 0x7fffffff; long l = max + max + 2; System.out.println( l );// 0
eg2：二进制运算（拼接与拆分）
int b1 = 192; int b2 = 168; int b3 = 1; int b4 = 10; int color = 0xD87455;
int ip = (b1<<24) + (b2<<16) + (b3<<8) + b4; // 或者ip = (b1<<24) | (b2<<16) | (b3<<8) 85="" int="" b="color&0xff;" g="(color">>> 8)&0xff; // 116 int r = (color >>> 16)&0xff;// 216
2.16 Java基础其他注意事项
v Java程序严格区分大小写。
v 类名，每个单词首字母必须大写（公司规范！）。
v 一个Java应用程序，有且只有一个main方法，作为程序的入口点。
v 每一条Java语句必须以分号结束。
v 类定义关键字class前面可以有修饰符（如public），如果前面的修饰符是public，该类的类名必须要与这个类所在的源文件名称相同。
v 注意程序的缩进。
v double a[] = new double[2]; //语法可以，但企业中一定不要这么写，Java中[]建议放前面。
v Java中所有范围参数都是包含0，不包含结束，如int n = random.nextInt(26); //生成0到26范围内的随机数，不包括26。
v 任何数据在内存中都是2进制的数据，内存中没有10进制16进制。
v int n = Integer.parseInt(str);//将字符串--> int 整数。
v System.out.println(Long.toBinaryString(maxL)); Long类型用Long.XXXX 。
v 程序：数据+算法 数据即为变量，算法为数据的操作步骤，如：顺序、选择、循环。
v 字符串按编码大小排序。
面向对象
Object：对象，东西，一切皆对象 = = 啥都是东西
面向对象核心：封装、继承、多态。
3.1类
1） 是同类型东西的概念，是对现实生活中事物的描述，映射到Java中描述就是class定义的类。类是对象的模板、图纸，是对象的数据结构定义。简单说就是“名词”。
2） 其实定义类，就是在描述事物，就是在定义属性（变量）和方法（函数）。
3） 类中可以声明：属性，方法，构造器；属性（变量）分为：实例变量，局部变量；实例变量：用于声明对象的结构的，在创建对象时候分配内存，每个对象有一份！实例变量（对象属性）在堆中分配，并作用于整个类中，实例变量有默认值，不初始化也能参与运算；局部变量在栈中分配，作用于方法或语句中，必须初始化，有值才能运算。
4） 类与类之间的关系：①关联：一个类作为另一个类的成员变量：需要另一个类来共同完成。class A { pulic B b } class B {} ②继承：class B extends A {} class A {} ③依赖：个别方法和另一个类相关。class A { public void f(B b) {}//参数里有B public B g() {}//返回值里有B } class B {}
5）null与空指针异常：引用类型变量用于存放对象的地址，可以给引用类型赋值为null，表示不指向任何对象。当某个引用类型变量为null时无法对对象实施访问（因为它没有指向任何对象）。此时，如果通过引用访问成员变量或调用方法，会产生NullPointerException空指针异常。
u 注意事项：除了8中基本类型，其他都是引用类型变量（也叫句柄）。
3.2对象
是这类事物实实在在存在的个体！利用类做为模板创建的个体实例，本质是数据。
匿名对<!--<8)--><!--<：相当于数学--></mid，故应在前半段中查找。><!--=--><!--=--><!--<-->
展开阅读全文
浙ICP备2021020529号-1 | 浙B2-20240490 
