01-Java学习笔记

Posted 2020-06-26 shindo

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了01-Java学习笔记相关的知识，希望对你有一定的参考价值。

本系列笔记由常彦博整理，请知悉

一、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注意事项：

vE：\ set classpath = c:\ （不加分号就不找当前路径）

= . ; c:\ ; d:\ ;（先找classpath，若无，再找当前路径）

vC、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注意事项：

vWindows根目录是反斜线：\

vLinux根目录是斜线：/

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注意事项：

vMyeclipse5.5消耗少，Myeclipse6.5最稳定

二、Java语言基础

2.1基础语言要素

1）标识符：给类、方法、变量起的名字

A．必须以字母或下划线或 $ 符号开始，其余字符可以是字母、数字、$ 符号和下划线。

B．只能包含两个特殊字符，即下划线 _ 和美元符号 $ 。不允许有任何其他特殊字符。

C．标识符不能包含空格。

D．区分大小写。

2）关键字：只有系统才能用的标识符

u注意事项：

vtrue、false、null不是关键字！是字面量。

vmain不是关键字！但是是一个特殊单词，可以被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注意事项：

vint 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。

vfloat 的精度没有long高，有效位数（尾数）短。

vfloat 的范围大于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）关系运算符：> < >= <= == !=

4）逻辑运算符：&& ||（短路） ! & |

eg：短路运算：&&：前为flase，则后面不计算；|| ：前为true，则后面不计算

int x=1,y=1,z=1;

if(x--==1 && y++==1 || z++==1) // || 短路运算后面的不执行了！

System.out.println(“x=”+x+”,y=”+y+”,z=”+z);// 0 , 2, 1

5）赋值运算符：= += -= *= /= %=

eg：正负1交替

int flag= -1; System.out.println(flag *= -1); ……

6）条件（三目）运算符：表达式1 ？表达式2 ：表达式3

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(必须为int类型){case 常量1：…; case 常量2：… ; ….}

u注意事项：

vint类型指：byte、short、int，不能写long类型，要写也必须强转成int类型；而byte、short为自动转换成int。

vswtich-case：若case中无符合的数，并且default写在最前（无break时），则为顺序执行，有break或 } 则退出。

vswtich-case：若case中无符合的数，并且default写在最后，则执行default。

vswtich-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）参数列表：是方法的前提条件，是方法执行依据，是数据。如：

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 <= high) { System.out.println("可以找到：index = " + mid + "。");

} else { System.out.println("无法找到！"); }

二分法思想是取中，比较：

1）求有序序列arr的中间位置mid。 2）k为要查找的数字。

若arr[mid] == k，查找成功；

若arr[mid] > 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<mid，故应在前半段中查找。

2）令新的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；二进制数无符号右移>>>：相当于数学 / 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) | b4;

int b = color&0xff; // 85 int g = (color >>> 8)&0xff; // 116 int r = (color >>> 16)&0xff;// 216

2.16 Java基础其他注意事项

vJava程序严格区分大小写。

v类名，每个单词首字母必须大写（公司规范！）。

v一个Java应用程序，有且只有一个main方法，作为程序的入口点。

v每一条Java语句必须以分号结束。

v类定义关键字class前面可以有修饰符（如public），如果前面的修饰符是public，该类的类名必须要与这个类所在的源文件名称相同。

v注意程序的缩进。

vdouble a[] = new double[2]; //语法可以，但企业中一定不要这么写，Java中[]建议放前面。

vJava中所有范围参数都是包含0，不包含结束，如int n = random.nextInt(26); //生成0到26范围内的随机数，不包括26。

v任何数据在内存中都是2进制的数据，内存中没有10进制16进制。

vint n = Integer.parseInt(str);//将字符串--> int 整数。

vSystem.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对象

是这类事物实实在在存在的个体！利用类做为模板创建的个体实例，本质是数据。

匿名对象：使用方式一：当对对象的方法只调用一次时，可用匿名对象来完成，这样比较简化。如果对一个对象进行多个成员调用，则必须给这个对象起个名字。

使用方式二：可以将匿名对象作为实际参数进行传递。

3.3包

1）包名必须是小写，多个单词用“．”隔开。在同一个包中，不能有同名的类！

2）只要在同一个包中，则可直接用extends（类型互知道在哪），若不在同一个包中，则用import导入。

3.4方法及其调用

是用于对当前对象数据进行算法计算，实现业务功能。方法是对象的功能，对象的动作，对象的行为。总之是动词！方法名没有规定，建议首单词为小写动词，其他单词首字母大写。必须定义返回值！可有无参数方法。方法调用只有两种方式：①对象引用调用②类名调用（即静态类时）。

3.5引用

是对个体的标识名称。

1）是代词，是对象的引用，就像拴着对象的绳子。

2）引用本身不是对象！引用指代了对象！

3）引用的值是对象的地址值（或叫句柄），通过地址值引用了对象。

4）引用的值不是对象！

u注意事项：“．”叫取成员运算，可以理解为“的”。

3.6访问控制（封装）

封装：将数据封装到类的内部，将算法封装到方法中。

1）封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问，通常有两种访问方式：set 设置，get 获取。

2）封装结果：存在但是不可见。

3）public：任何位置可见，可以修饰：类、成员属性、成员方法、内部类、跨包访问类（需要使用import语句导入），成员属性 = = 成员变量。

4）protected：当前包中可见，子类中可见。可以修饰：成员属性、成员方法、内部类（只能在类体中使用，不能修饰类）。

5）默认的：当前包内部可见，就是没有任何修饰词，可以修饰：类、成员属性、成员方法、内部类，但在实际项目中很少使用。默认类（包内类）的访问范围：当前包内部可见，不能在其他包中访问类，访问受限！main方法若定在默认类中JVM将找不到，无法执行，因此必定在public类中。

6）private：仅仅在类内部可见。可以修饰：成员属性、成员方法、内部类（只能在类体中使用，不能修饰类）。私有的方法不能继承，也不能重写。

u注意事项：在企业项目中建议：所有类都是公用类。封装的类使用内部类！

3.7构造器

用于创建对象并初始化对象属性的方法，叫“构造方法”，也叫“构造器”；构造器在类中定义。

1）构造器的名称必须与类名同名，包括大小写。

2）构造器没有返回值，但也不能写void，也不能写return。

3）构造器的参数：一般是初始化对象的前提条件。

4）用new调用！且对象一建立，构造器就运行且仅运行一次。一般方法可被调用多次。

5）类一定有构造器！这是真的，不需要质疑！

6）如果类没有声明（定义）任何的构造器，Java编译器会自动插入默认构造器！

7）默认构造是无参数，方法体是空的构造器，且默认构造器的访问权限随着所属类的访问权限变化而变化。如，若类被public修饰，则默认构造器也带public修饰符。

8）默认构造器是看不到的，一旦自己写上构造器则默认构造器就没有了，自己写的叫自定义构造器，即便自己写的是空参数的构造器，也是自定义构造器，而不是默认构造器。

9）如果类声明了构造器，Java编译器将不再提供默认构造器。若没手动写出无参构造器，但却调用了无参构造器，将会报错！

eg：默认构造器

public class Demo { public static void main(String[] args) {

Foo foo = new Foo();//调用了javac自动添加的默认构造器！

//Koo koo = new Koo();//编译错误，没有Koo()构造器

Koo koo = new Koo(8); } }

class Foo { } //Foo有构造器，有无参数的默认构造器！

class Koo { public Koo(int a) { //声明了有参数构造器

System.out.println("Call Koo(int)"); }}

10）构造器是可以重载的，重载的目的是为了使用方便，重载规则与方法重载规则相同。

11）构造器是不能继承的！虽说是叫构造方法，但实际上它不是常说的一般方法。

12）子类继承父类，那么子类型构造器默认调用父类型的无参数构造器。

13）子类构造器一定要调用父类构造器，如果父类没有无参数构造器，则必须使用super(有参数的)，来调用父类有参的构造器。那么，为什么子类一定要访问父类的构造器？

因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的，所以子类在对象初始化时，要先访问一下父类中的构造器。

总之，子类中至少会有一个构造器会访问父类中的构造器，且子类中每一个构造函数内的第一行都有一句隐式super()。

3.8 super()、super．和 this()、this．

1）this：在运行期间，哪个对象在调用this所在的方法，this就代表哪个对象，隐含绑定到当前“这个对象”。

2）super()：调用父类无参构造器，一定在子类构造器第一行使用！如果没有则是默认存在super()的！这是Java默认添加的super()。

3）super．是访问父类对象，父类对象的引用，与this．用法一致

4）this()：调用本类的其他构造器，按照参数调用构造器，必须在构造器中使用，必须在第一行使用，this() 与 super() 互斥，不能同时存在

5）this．是访问当前对象，本类对象的引用，在能区别实例变量和局部变量时，this可省略，否则一定不能省！

6）如果子父类中出现非私有的同名成员变量时，子类要访问本类中的变量用this．；子类要访问父类中的同名变量用super．。

eg1：方法参数传递原理与 this关键字

技术分享

eg2：this. 和 this()

Cell c = new Cell(); System.out.println(c.x + ","+c.y);

class Cell { int x; int y;

public Cell() { this(1,1);//调用本类的其他构造器 }

public Cell( int x, int y) { this.x = x ; this.y = y; } }

eg3：super()

class Xoo{ public Xoo(int s) { System.out.println("Call Xoo(int)"); }} //super()用于在子类构造器中调用父类的构造器

class Yoo extends Xoo{

//public Yoo() {}//编译错误，子类调用不到父类型无参数构造器 public Yoo(){//super();//编译错误，子类调用不到父类型无参数构造器

super(100);//super(100) 调用了父类 Xoo(int) 构造器 } }

3.9重载和重写

1）重写：通过类的继承关系，由于父类中的方法不能满足新的要求，因此需要在子类中修改从父类中继承的方法叫重写（覆盖）。

①方法名、参数列表、返回值类型与父类的一模一样，但方法的实现不同。若方法名、参数列表相同，但返回值类型不同会有变异错误！若方法名、返回值类型相同，参数列表不同，则不叫重写了。

②子类若继承了抽象类或实现了接口，则必须重写全部的抽象方法。若没有全部实现抽象方法，则子类仍是一个抽象类！

③子类重写抽象类中的抽象方法或接口的方法时，访问权限修饰符一定要大于或等于被重写的抽象方法的访问权限修饰符！

④静态方法只能重写静态方法！

2）重载：方法名一样，参数列表不同的方法构成重载的方法（多态的一种形式）。

①调用方法：根据参数列表和方法名调用不同方法。

②与返回值类型无关。

③重载遵循所谓“编译期绑定”，即在编译时根据参数变量的类型判断应调用哪个方法。 eg：重载

int[] ary1 = {‘A‘,‘B‘,‘C‘}; char[] ary2 = {‘A‘, ‘B‘, ‘C‘};

System.out.println(ary1);//println(Object)

//按对象调用，结果为地址值，没有println(int[])

System.out.println(ary2);//println(char[]) ABC

System.out.println(‘中‘);//println(char) 中

System.out.println((int)‘中‘);//println(int) 20013

3.10继承

父子概念的继承：圆继承于图形，圆是子概念（子类型 Sub class）图形是父类型（Super Class也叫超类），继承在语法方面的好处：子类共享了父类的属性和方法的定义，子类复用了父类的属性和方法，节省了代码。

1）继承是is a ：“是”我中的一种，一种所属关系。

2）子类型对象可以赋值给父类型变量（多态的一种形式），变量是代词，父类型代词可以引用子类型东西。

3）继承只能是单继承，即直接继承，而非间接继承。因为多继承容易带来安全隐患，当多个父类中定义了相同功能，当功能内容不同时，子类无法确定要运行哪一个。

4）父类不能强转成子类，会造型异常！子类向父类转化是隐式的。

5）只有变量的类型定义的属性和方法才能被访问！见下例。

6）重写遵循所谓“运行期绑定”，即在运行的时候根据引用变量指向的实际对象类型调用方法。

eg：Shape s，s只能访问Shape上声明的属性和方法

Circle c = new Circle(3,4,5);

Shape s = c;//父类型变量s引用了子类型实例

//s 和 c引用了同一个对象new Circle(3,4,5)

s.up(); System.out.println(c.r);

System.out.println(c.area());

//System.out.println(s.area());//编译错误

//System.out.println(s.r);//在Shape上没有定义r属性！

7）引用类型变量的类型转换 instanceof

public static void main(String[] args) {

Circle c = new Circle(3,4,5); Rect r = new Rect(3,4,5,6);

Shape s = c; Shape s1 = r;

//Circle x = s;//编译错误，父类型变量不能赋值给子类型

Circle x = (Circle)s;//正常执行

//Circle y = (Circle)s1;//运行异常,类型转换异常

//instaceof instace：实例 of:的

//instaceof 运算检查变量引用的对象的类型是否兼容

//s引用的是圆对象，s instanceof Circle 检查s引用的对象是否是Circle类型的实例！

System.out.println(s instanceof Circle);//true

System.out.println(s1 instanceof Circle);//false

test(c); test(r); }

public static void test(Shape s){//多态的参数

//if(s instanceof Circle)保护了(Circle)s不会出现异常

if(s instanceof Circle){//实现了安全的类

以上是关于01-Java学习笔记的主要内容，如果未能解决你的问题，请参考以下文章

01-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继承

目录