学习视频：Java零基础学习视频通俗易懂
Java注释
单行注释
//
多行注释
/**/
文档注释：
/**
*
*/
有趣的代码注释
/***
* _ooOoo_
* o8888888o
* 88" . "88
* (| -_- |)
* O\ = /O
* ____/`---'\____
* . ' \\| |// `.
* / \\||| : |||// \
* / _||||| -:- |||||- \
* | | \\\ - /// | |
* | \_| ''\---/'' | |
* \ .-\__ `-` ___/-. /
* ___`. .' /--.--\ `. . __
* ."" '< `.___\_<|>_/___.' >'"".
* | | : `- \`.;`\ _ /`;.`/ - ` : | |
* \ \ `-. \_ __\ /__ _/ .-` / /
* ======`-.____`-.___\_____/___.-`____.-'======
* `=---='
*
* .............................................
* 佛祖保佑 永无BUG
*/
/**
* .--, .--,
* ( ( \.---./ ) )
* '.__/o o\__.'
* {= ^ =}
* > - <
* / \
* // \\
* //| . |\\
* "'\ /'"_.-~^`'-.
* \ _ /--' `
* ___)( )(___
* (((__) (__))) 高山仰止,景行行止.虽不能至,心向往之。
*/
/***
* ┌───┐ ┌───┬───┬───┬───┐ ┌───┬───┬───┬───┐ ┌───┬───┬───┬───┐ ┌───┬───┬───┐
* │Esc│ │ F1│ F2│ F3│ F4│ │ F5│ F6│ F7│ F8│ │ F9│F10│F11│F12│ │P/S│S L│P/B│ ┌┐ ┌┐ ┌┐
* └───┘ └───┴───┴───┴───┘ └───┴───┴───┴───┘ └───┴───┴───┴───┘ └───┴───┴───┘ └┘ └┘ └┘
* ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┐ ┌───┬───┬───┐ ┌───┬───┬───┬───┐
* │~ `│! 1│@ 2│# 3│$ 4│% 5│^ 6│& 7│* 8│( 9│) 0│_ -│+ =│ BacSp │ │Ins│Hom│PUp│ │N L│ / │ * │ - │
* ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ ├───┼───┼───┤ ├───┼───┼───┼───┤
* │ Tab │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │{ [│} ]│ | \ │ │Del│End│PDn│ │ 7 │ 8 │ 9 │ │
* ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ └───┴───┴───┘ ├───┼───┼───┤ + │
* │ Caps │ A │ S │ D │ F │ G │ H │ J │ K │ L │: ;│" '│ Enter │ │ 4 │ 5 │ 6 │ │
* ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ ┌───┐ ├───┼───┼───┼───┤
* │ Shift │ Z │ X │ C │ V │ B │ N │ M │< ,│> .│? /│ Shift │ │ ↑ │ │ 1 │ 2 │ 3 │ │
* ├─────┬──┴─┬─┴──┬┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ ┌───┼───┼───┐ ├───┴───┼───┤ E││
* │ Ctrl│ │Alt │ Space │ Alt│ │ │Ctrl│ │ ← │ ↓ │ → │ │ 0 │ . │←─┘│
* └─────┴────┴────┴───────────────────────┴────┴────┴────┴────┘ └───┴───┴───┘ └───────┴───┴───┘
*/
/***
* .::::.
* .::::::::.
* ::::::::::: FUCK YOU
* ..:::::::::::'
* '::::::::::::'
* .::::::::::
* '::::::::::::::..
* ..::::::::::::.
* ``::::::::::::::::
* ::::``:::::::::' .:::.
* ::::' ':::::' .::::::::.
* .::::' :::: .:::::::'::::.
* .:::' ::::: .:::::::::' ':::::.
* .::' :::::.:::::::::' ':::::.
* .::' ::::::::::::::' ``::::.
* ...::: ::::::::::::' ``::.
* ```` ':. ':::::::::' ::::..
* '.:::::' ':'````..
*/
关键字
Java 所有的组成部分都需要名字。类名，变量名以及方法名都被称为标识符。
- 所有的标识符都应该以字母（A-Z或a-z），美元符（$)，或者下划线（_）开头。
- 首字符之后可以是字母（A-Z或a-z），美元符（$)，者下划线（_）或数字的任何字符组成。
- 不能使用关键字作为变量名或方法名。
- 标识符是大小敏感的
- 合法标识符举例：age，$salay，_value，__1_value
- 非法标识符举例：123abc，-salary，#abc
- 可以是哦那个中文命名，但是一般不建议这样去使用，也不建议使用拼音，很low。
数据类型
- 强类型语言
- 要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用。
- Java的数据类型分为两大类
- 基本类型
- 引用类型
字节
- 位（bit）：是计算机内部数据存储的最小单位，11001100是一个八位二进制数。
- 字节（byte）：是计算机中数据处理的基本单位，习惯上用大写B来表示。
- 1B（byte，字节） = 8bit(位)
- 字符：是计算机中使用的字母，数字，字和符号
1bit表示1位
1Byte表示一个字节 1B=8b
1024B = 1KB
1024KB = 1M
1024M = 1G
基本数据类型
//整数
int num1 = 10;
byte num2 = 20;
short num3 = 30;
long num4 = 40L; //long类型要在数字后面加个L，整数默认类型为int。
//小数：浮点数
float num5 = 3.4F; //float类型要在数字后面加个F，小数默认类型为duoble。
double num6 = 3.1415926;
//字符
char name = '国'；
String name_ = "张三"; //字符串，String不是关键字，是类。
//布尔值：是非
boolean flag = true;
类型转换
- 由于Java是强类型语言，所以要进行有些运算的时候需要用到类型转换。
低----------------------------------------->高
byte,shrot,char-->int-->long-->float-->double - 运算中，不同类型的数据转化为同一类型，然后进行运算。
- 不能对布尔值进行转换
- 不能把对象类型转换为不相干的类型
- 在把高容量转换到低容量的时候，强制转换(int)(3.1425)。
- 转换的时候可能存在内存溢出或者精度问题。
变量
- 变量是什么：就是可以变化的量！
- Java是一种强类型语言，每个变量都必须声明其类型。
- Java变量是程序最基本的存储单元，其要素包括变量名，变量类型何作用域。
type varName [=value][{,varName[=value]}];
//数据类型 变量名 = 值；可以使用逗号隔开来声明多个同类型变量。
注意事项：
- 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
- 变量名必须是合法的标识符。
- 变量声明是一条完整的语句，因此每一个声明都必须以分号结束。
变量作用域
- 类变量
- 实例变量
- 局部变量
public class Variable{
static int allClicks = 0; //类变量
String str = "hello world"; //实例变量，从属于对象。
public void method(){
int i = 0; //局部变量
}
}
常量
- 常量（Constant）：初始化（initialize）后不能再改变值！不会变动的值。
- 所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许额被改变。
final 常量类型 常量名 = 值；
final double PI = 3.14;
- 常量名一般使用大写字符。
变量的命名规范
- 所有变量：方法，类名，见名知意。
- 类成员变量：首字母小写和驼峰原则，除了第一个单词小写其他单词首字母大写：monthSalay。
- 局部变量：首字母小写和驼峰原则。
- 常量：大写字母和下划线：MAX_VALUE。
- 类名：首字母大写和驼峰原则：Man,GoodMan。
- 方法名：首字母小写和驼峰原则：run(),runRun()。
运算符
- Java语言支持如下运算符：优先级（）
- 算术运算符：+, -, *, /, %, ++, --
- 赋值运算符： =
- 关系运算符：>, <, >=, <=, ==, !=, instanceof
- 逻辑运算符：&&, ||, ！
- 位运算符： &, |, ^, ~, >>, <<, >>>
- 条件运算符：?, ：
- 拓展赋值运算： +=, -=, *=, /=
包机制
- 为了更好地组织类，Java提供的包机制，用于区别类名的命名空间。
- 包语句的语法格式为：
package pkg1[.pkg2[.pkg3……]]; - 一般利用公司域名倒置作为包名。
- 为了能够使用某一个包的成员，我们需要在Java程序中明确导入改包。使用"import"语句完成此功能。
import package1[.package2……].(classname|*);
Java流程控制
用户交互Scanner
- 基本语法中我们并没有实现程序和人的交互，但是Java给我们提供了这样一个工具类，我们可以获取用户的输入。java.util.Scanner是Java5的新特性，我们可以通过Scanner类来获取用户的输入。
- 基本语法：
Scanner s = new Scanner(System.in); - 通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。
- next():
- 一定要读取到有效字符后才可以结束输入。
- 对输入有效字符之前遇到的空白，next()方法会自动将其去掉。
- 只有输入有效字符后才将其后面输入的空白作为分割符或者结束符。
- next()不能得到带有空格的字符串。
- nextLine():
- 以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符。
- 可以获得空白。
顺序结构
- Java的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。
- 顺序结构是最简单的算法结构。
- 语句与语句之间，框与框之间是按从上导线的顺序进行的，它是由若干个以此执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。
选择结构
- if单选择结构
- 语法：
if (布尔表达式){ //如果布尔表达式为true将执行的语句 } - if双选择结构
- 语法：
if (布尔表达式){ //如果布尔表达式的值为true }else { //如果布尔表达式的值为false } - if多选择结构
- 语法：
if (布尔表达式){ //如果布尔表达式的值为true }else if (布尔表达式){ //如果布尔表达式的值为true }else if (布尔表达式){ //如果布尔表达式的值为true }else { //如果布尔表达式的值为false } - 嵌套的if结构
- 语法：
if (布尔表达式 1){ //如果布尔表达式1的值为true执行代码 if (布尔表达式 2){ //如果布尔表达式2的值为true执行代码 } } - switch多选择结构
- switch case 语句判断一个变量与一系列中某个值是否相等，每个值称为一个分支。
- swithc 语句中的变量类型可以式：
- byte,short,int或者char。
- 从Java SE7开始，switch支持字符串String类型了
- 同时case标签必须为字符串常量或字面量。
- 语法：
swithc (expression){ case value: //语句 break; case value: //语句 break; default: //可选 //语句 }
循环结构
- while循环
- while是最基本的循环，他的结构为：
while (布尔表达式){ //循环内容 }- 只要表达式为true，循环就会一直执行下去。
- 我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环。
- 少部分情况需要循环一直执行下去，比如服务器的请求响应监听等。
- 循环条件一直为true就会造成无限循环【死循环】，业务编程中尽量避免死循环不然会影响程序性能或者造成程序卡死崩溃！
- do……while循环
- 对于while语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
- do……while循环while循环相似，不同的是，do……while循环至少会执行一次。
- 语句：
do { //代码语句 }while (布尔表达式);- while和do……while的区别：
- while先判断后执行，do……while是先执行后判断。
- do……while总是保证循环体会被至少执行一次，这是他们的主要区别。
- for循环
- 虽然所有循环都可以用while或者do……while表示，但是Java提供了另一种语句——for循环，使一些循环结构变得更加简单。
- for循环语句是支持迭代的一种通用结构，是最有效，最灵活的循环结构。
- for循环执行的次数是在执行前就确定的。语法格式如下：
for (初始化;布尔表达式;更新){ //代码语句 } - 在Java5中引入了一种主要用于数组的增强型for循环。
break & continue
- break在任何循环语句的主体部分，均可用break控制循环的流程，break用于强行退出循环，不执行循环中剩下的语句。（break语句也在switch语句中使用）
- continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环中尚未执行的语句，接着进行下一次是否执行循环的判定。
Java的方法
何谓方法
- Java方式式语句的集合，它们在一起执行一个功能。
- 方法式解决一类问题的步骤的有序集合。
- 方法包含于类或对象中。
- 方法在程序中被创建，在其他地方被引用。
- 设计方法的原则：方法的本意式功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成一个功能，这样利于我们后期的拓展。
方法的定义
- Java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含一下语法：
- 方法包含一个方法头和一个方法体
- 修饰符：修饰符是可选的，告诉编译器如何调用该方法，定义了该方法的访问类型。
- 返回值类型：方法可能会返回只。return ValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，return ValueType是关键字void.
- 方法名：是方法的实际名称，方法名和参数表共同构成方法签名。
- 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被成为实参或变量。参数列表是指方法的参数类型，顺序和参数的个数，参数是可选的，方法可以不包含任何参数。
- 形式参数： 在方法被调用于接收外界输入的数据。
- 实参：调用方法时实际传给方法的数据。
- 方法体：方法体包含具体的语句，定义该方法的功能。
- 语法：
修饰符 返回值类型 方法名(参数类型 参数名){ …… 方法体 …… return 返回值; }
方法调用
- 调用方法：对象名.方法名(实参列表)
- java支持两种调用方法的方式，根据方法时否返回值来选择。
- 当方法返回一个值的时候，方法调用通常被当作一个值。例如：
int larger = max(30, 40);
- 如果方法返回值是void，方法调用一定是一条语句。
System.out.println("Hello,world!");
方法重载
- 重载就是在一个类中，有相同的函数名称，但形参不同的函数。
- 方法的重载的规则：
- 方法名必须相同。
- 参数列表必须不同（个数不同或类型不同或参数排列顺序不同等）。
- 方法的返回类型可以相同也可以不同。
- 仅仅返回类型不同不足以成为方法的重载。
- 实现理论：
- 方法名称相同时，编译器会根据调用方法的参数个数，参数类型等去逐个匹配对应的方法，如果匹配失败，则编译器报错。
命令行传参
- 就是通过命令行执行*.java并传入相关的参数（利用的ma是in方法进行传参）。
可变参数
- JDK1.5开始，Java支持传递同类型的可变参数给一个方法。
- 在方法声明中，在指定参数类型后加一个省略号（...）。
- 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
递归
- 递归就是：A方法调用A方法，就是自己调用自己。
- 利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大的减少了程序的代码量，递归的能力在于用有限的语句来定义对象的无限集合。
- 递归结构包括两个部分：
- 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
- 递归体：什么时候需要调用自身方法。
pbulic static int f(int n){ if (n == 1){ return 1; }else { return n * f(n-1); } }
数组
数组概述
- 数组的定义
- 数组是相同类型数据的有序集合
- 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
- 其中每一个数据称作一个数组元素，每一个数组元素可以通过一个下标来访问它们。
数组声明创建
- 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：
dataType[] arrayRefVar; //首选的方法 或 dataType arrayRefVar[]; //效果相同，但是不是首选方法 - Java语言使用new操作符来创建数组，语法如下：
dataType[] arrayRefVar = new dataType[arraySize]; - 数组的元素是通过索引访问的，数组索引从0开始。
- 获取数组长度：arrays.length
- 其长度是确定的，数组一旦被创建，他的大小就是不可以改变的。
- 其元素必需是相同类型，不允许出现混合类型。
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
- 数组变量属于应用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量，数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。
- 内存分析
- 三种初始化
- 静态初始化
int[] a = {1,2,3}; Man[] mans = {new Man(1,1),new Man(2,2)};- 动态初始化
int[] a = new int[2]; a[0] = 1; a[1] = 2;- 数组的默认初始化
- 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素被按照实例变量同样的方式被隐式初始化。
数组使用
- 普通for循环
- For-Each循环
- 数组方法入参
- 数组放回值
多维数组
- 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
- 二维数组
int a[] = new int[2][5] - 解析：以上二维数组a可以看成一个两行五列的数组。
Arrays类
- 数组的工具类java.util.Arrays
- 由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。
- Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”对象来调用（注意是“不用”而不是“不能”）。
- 具有一下常用功能：
- 给数组赋值：通过fill方法。
- 对数组排序：通过sort方法，按升序。
- 比较数组：通过equals方法比较数组中元素是否相等。
- 查找数组元素：通过binarySearch方法能对排序号的数组进行二分查找法操作。
- 冒泡排序：
import java.util.Arrays; public class ForDemo03 { public static void main(String[] args) { int[] a = {1, 2, 3, 3, 5, 3, 7, 4, 6, 9, 0}; int[] arrays = arrays(a); System.out.println(Arrays.toString(arrays)); } public static int[] arrays(int[] arrays) { int temp = 0; boolean flag = false; for (int i = 0; i < arrays.length - 1; i++) { for (int j = 0; j < arrays.length - 1 - i; j++) { if (arrays[j + 1] < arrays[j]) { temp = arrays[j]; arrays[j] = arrays[j + 1]; arrays[j+1] = temp; flag = true; } } } if (flag == false){ return arrays; } return arrays; } }
稀疏数组
- 当一个数组中大部分元素为0，或者为同一个值得数组时，可以使用稀疏数组来保存该数组。
- 稀疏数值得处理方式是：
- 记录数组一共有几行几列，有多少个不同值。
- 把具有不同值得元素和行列及记录在一个小规模得数组中，从而缩小程序得规模。
- 如下图：左边是原始数组，右边是稀疏数组。
public class ForDemo04 { public static void main(String[] args) { int[][] array1 = new int[11][11]; array1[1][2] = 1; array1[2][3] = 2; System.out.println("========原数组========"); for (int i = 0; i < array1.length; i++) { for (int j = 0; j < array1.length; j++) { System.out.print(array1[i][j] + "\t"); } System.out.println(); } System.out.println("=======稀疏数组========="); int num = 0; for (int[] ints : array1) { for (int anInt : ints) { if (anInt != 0) { num++; } } } int[][] array2 = new int[num + 1][3]; array2[0][0] = 11; array2[0][1] = 11; array2[0][2] = num; int count = 0; for (int i = 0; i < array1.length; i++) { for (int j = 0; j < array1[i].length; j++) { if (array1[i][j] != 0) { count++; array2[count][0] = i; array2[count][1] = j; array2[count][2] = array1[i][j]; } } } for (int[] ints : array2) { for (int anInt : ints) { System.out.print(anInt + "\t"); } System.out.println(); } }
面向对象
- 面向对象编程（OOP）。
- 面向对象编程得本质就是：以类得方式组织代码，以对象得组织（封装）数据。
- 三大类：
- 封装
- 继承
- 多态
- 从认识论角度考虑是先有对象后又类，对象是具体得事物。类是抽象得，是对对象得抽象。
- 从代码运行角度考虑是先有类后有对象。类是对象得模板。
- 创建与初始化对象
- 使用new关键字创建对象
- 使用new关键字创建的时候，除了分配空间之外，还会给创建好的对象进行默认的初始化以及对象中构造器的调用。
- 类中的构造器也称为构造方法，是在进行创建对象的时候必须调用的。并且构造器有一下两个特点：
- 必须和类的名字相同。
- 必须没有返回类型也不能写void。
封装
- 该露的露，该藏的藏，"高内聚，低耦合"。属性私有。
继承
- 继承的本质是对某一类的抽象，从而实现对现实世界更好的建模。
- extend的意思是"拓展"，子类是父类的拓展。
- Java中类只有单继承，没有多继承。
- 继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、汇聚等。
- 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
- 子类和父类之间，从意义上讲应该具有"is a"的关系。
- object类、super 、 方法重写。
多态
- 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
- 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多种。
- 多态存在多的条件
- 有继承关系
- 子类重写父类方法。
- 父类引用指向子类对象。
- 注意：多态是方法的多态，属性没有多态性。
- 父类引用指向子类的对象
- 把子类转换为父类，向上转型
- 把父类转换为子类，向下转型（强制转换，可能会丢失一下方法）。
- 方便方法的调用，减少重复的代码。