Java基础阶段：基础语法
一、注释、标识符、关键字
注释
Java的注释分为三种：单行注释、多行注释、文档注释
//单行注释
/*
多行注释
*/
/**文档注释
* @author：作者。
* ·@version：版本。
* ·@docroot：表示产生文档的根路径。
* ·@deprecated：不推荐使用的方法。
* ·@param：方法的参数类型。
* ·@return：方法的返回类型。
* ·@see：用于指定参考的内容。
* ·@exception：抛出的异常。
* ·@throws：抛出的异常，和exception同义
*/
有趣的代码注释
/***
* .::::.
* .::::::::.
* ::::::::::: FUCK YOU
* ..:::::::::::'
* '::::::::::::'
* .::::::::::
* '::::::::::::::..
* ..::::::::::::.
* ``::::::::::::::::
* ::::``:::::::::' .:::.
* ::::' ':::::' .::::::::.
* .::::' :::: .:::::::'::::.
* .:::' ::::: .:::::::::' ':::::.
* .::' :::::.:::::::::' ':::::.
* .::' ::::::::::::::' ``::::.
* ...::: ::::::::::::' ``::.
* ````':. ':::::::::' ::::..
* '.:::::' ':'````..
*/
标识符
Java所有的组成部分都需要名字。类名、变量名以及方法名都称为标识符。
标识符注意点
- 所有的表示符都应该以字母（A-Z或者a-z）、美元符（$）、或者下划线（_）开始
- 首字符之后可以都是字母（A-Z或者a-z）、美元符（$）、下划线（_）或数字的任何字符组合
- 不能使用关键字作为变量名和方法名
- 标识符是大小写敏感的
- 可以中文，但是不建议
关键字
二、数据类型
强类型语言
要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用
弱类型语言
Java的数据类型分为两大类型
基本类型、引用类型
三、类型转换
什么是字节
位（bit）：是计算机内部数据储存的最小单位，11001100是一个八位数二进制
字节（byte）：是计算机中数据处理的基本单位，习惯上用大写B来表示
1B（byte，字节）= 8bit（位）
字符：是指计算机中使用的字母、数字、字符和符号
思考：电脑的32位和64位的区别是什么呢？
由于Java是强类型语言，所有要进行有些运算的时候，需要用到类型转换
运算中，不同类型的数据先转化为同一类型，然后进行运算
八大基本类型
整数型：int、byte、short、long
浮点型：float、double
字符型：char
布尔值：boolean
int num1 = 10; //最常用
byte num2 = 20;
short num3 = 30;
long num4 = 40L;//Long类型要在数字后面加L
//小数 ：浮点数
float num5 = 100.2F;//float类型要在数字后面加个F
double num6 = 100.3;
//字符类型
char name = 'A';
//布尔值
boolean flag = true;
boolean flag1 = false;
强制转换类型
//强行转换类型 (类型)变量名 高到低
自动转换类型
//自动转换类型 低到高
注意事项
/*
注意点：
1.不能对布尔值进行转换
2.不能把对象类型转换为不相干的类型
3.在把高容量转换到低容量的时候，强制转换
4.在把低容量转换到高容量的时候，自动转换
5.转换的时候可能存在内存溢出，或者精度问题
*/
小数的优先级一定大于整数
四、变量、常量
变量
变量是什么：就是可以变化的量
Java是一种强类型语言，每个变量都必须声明其类型
Java变量是程序中最基本的储存单元，其要素包括变量名，变量类型和作用域
注意事项:
- 每个变量都有类型，类型可以是基本类型，也可以是引用类型
- 变量名必须是合法的标识符
- 变量声明是一条完整的语句，因此每一个声明都必须以分号结束
变量的命名规范
- 所有变量、方法、类名：见名知意
- 类成员变量、局部变量和方法名：首字母小写和驼峰原则
- 类名：首字母大写和驼峰原则
- 常量：大写字母和下划线
常量
常量：初始化后不能在改变值！不会变动的值
所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变
常量名一般使用大写字符
变量作用域
- 类变量
- 实例变量
- 局部变量
五、运算符
Java语言支持如下运算符：
//算术运算符：也称二元运算符
int a = 10;
int b = 20;
int c = 25;
int d = 30;
System.out.println(a+b);
System.out.println(b-a);
System.out.println(a*b);
System.out.println(a/b);
//% 取余 也叫模运算
System.out.println(c % a); // c/a 25/10 = 2...5
// ++ -- 自增 自减 一元运算符
int a = 3;
int b = a++; //执行完这行代码后，先给b赋值，再自增
// a++ a = a + 1;
System.out.println(a);
// a++ a = a + 1;
int c = ++a; //执行完这行代码后，先自增，再给b赋值
System.out.println(a);
System.out.println(b);
System.out.println(c);
//幂运算 2^3 2*2*2 = 8 很多运算，我们会使用一些工具类来操作！
double pow = Math.pow(2, 3);
System.out.println(pow);
//与（and） 或（or） 非（取反）
boolean a = true;
boolean b = false;
System.out.println("a&&b:" + (a && b)); //逻辑与运算：两个变量都为真，结果才为true
System.out.println("a||b:" + (a && b)); //逻辑与运算：两个变量有一个为真，则结果才为true
System.out.println("!(a&&b):" + !(a && b));//如果是真，则变为假，如果是假则变为真
//位运算
/*
A = 0011 1100
B = 0000 1101
**********************************
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~B = 1111 0010
2*8 = 16 2*2*2*2
效率极高！
<< *2
>> /2
0000 0000 0
0000 0001 1
0000 0010 2
0000 0011 3
0000 0100 4
0000 1000 8
0001 0000 16
*/
//扩展赋值运算符
int a = 10;
int b = 20;
a+=b; //a = a+b
a-=b; //a = a-b
System.out.println(a);
System.out.println("************************");
//条件运算符：也称三元运算符
//x ? y : z
//如果x==true，则结果为y，否则结果为z
int score = 80;
String type = score < 60 ? "不及格" : "及格"; //必须掌握
// if来判断
System.out.println(type);
重点：
算术运算符 a++ a–、逻辑运算、位运算、优先级（）
六、包机制、JavaDoc
包机制
为了更好地组织类，Java提供了包机制，用于区别类名的命名空间
包语句的语法格式为：
一般利用公司域名倒置作为包名;
为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用import语句可以完成此功能
JavaDoc
javaDoc命令手册是用来生成自己API文档的
阿里巴巴开发手册
JDK帮助文档 https://docs.oracle.com/javase/8/docs/api/
Java基础阶段：流程控制
一、用户交互Scanner
Scanner对象、
java.util.Scanner是java5的新特性，我们可以通过Scanner类来获取用户的输入。
基本语法：
//System.in 接收用户的输入
Scanner scanner = new Scanner(System.in);
通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还输入的数据。
next（）:
- 一定要读取到有效字符后才可以结束输入
- 对输入有效字之前遇到的空白，next()方法会自动将其去掉
- 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
- next()不能得到带有空格的字符串
//判断用户有没有输入字符串
if (scanner.hasNext() == true) {
//使用next方式接收
String str = scanner.next();
System.out.println("输出的内容为:" + str);
}
nextLine()：
- 以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符
- 可以获得空白
//判断是否还有输入
if (scanner.hasNextLine() == true) {
String str = scanner.nextLine();
System.out.println("输出的内容为:" + str);
}
二、顺序结构
Java的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。
顺序结构是最简单的算法结构
public static void main(String[] args) {
System.out.println("hello1");
System.out.println("hello2");
System.out.println("hello3");
System.out.println("hello4");
System.out.println("hello5");
System.out.println("hello6");
}
语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何算法都离不开的一种基本算法结构
三、选择结构
- if单选择结构
需要判断一个东西是否可行，然后我们才去执行，这样一个过程在程序中用if语句来表示
//equals：判断字符串是否相等
if (s.equals("Hello")) {
System.out.println(s);
}
- if双选择结构
若需要两个判断，需要一个双选择结构，所以就有if-else结构
if (score > 60) {
System.out.println("及格");
} else {
System.out.println("不及格");
}
- if多选择结构
在生活中我们许多时候的选择也不仅仅只有两个，所以我们需要一个多选择结构来处理这类问题！
/*
if语句至多有一个else语句，else语句在所有的else if语句之后。
if语句可以有若干个else if语句，它必须在else语句之前。
一旦其中一个else if语句检测为true，其他的else if以及else语句都将跳过执行
*/
if (score == 100) {
System.out.println("满分");
} else if (score < 100 && score >= 90) {
System.out.println("A");
} else if (score < 90 && score >= 80) {
System.out.println("B");
} else if (score < 80 && score >= 70) {
System.out.println("C");
} else if (score < 70 && score >= 60) {
System.out.println("D");
} else if (score < 60 && score >= 0) {
System.out.println("不及格");
} else {
System.out.println("成绩不合法");
}
- 嵌套的if结构
使用嵌套的if…else语句是合法的。也就是说你可以在另一个if或者else if语句中使用if或者else if语句。你可以像if语句一样嵌套else if…else。
- switch多选择结构
多选择结构还有一个实现方式就是switch case语句
switch case语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支
//switch多选择结构
public class SwitchDemo05 {
public static void main(String[] args) {
//case穿透
char grade = 'B';
//switch 匹配一个具体的值
switch (grade){
case 'A':
System.out.println("优秀");
break; //可选
case 'B':
System.out.println("良好");
break; //可选
case 'C':
System.out.println("普通");
break; //可选
case 'D':
System.out.println("差");
break; //可选
case 'E':
System.out.println("极差");
break; //可选
default:
System.out.println("未知");
}
}
}
四、循环结构
- while循环
- do…while循环
- for循环
在Java5中引入了一种主要用于数组的增强型for循环。
while循环
- while是最基本的循环，它的结构为：
while(布尔表达式){
//循环内容
}
public static void main(String[] args) {
//输出1-100
int i = 0;
while (i < 100) {
i++;
System.out.println(i);
}
}
-
只要布尔表达式为true，循环就会一直执行下去
-
大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环
-
少部分情况需要循环一直执行，比如服务器的请求响应监听等
-
循环条件一直为true就会造成无限循环（死循环），我们正常的业务编程中应该尽量避免死循环。会影响程序性或者程序卡死崩溃！
-
*思考：计算 1+2+3+…+100=？
do…while循环
- 对于while语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
- do…while循环和while循环相似，不同的是，do…while循环至少会执行一次。
do{
//代码语句
}while(布尔表达式);
public static void main(String[] args) {
int i = 0;
int sum = 0;
do {
sum = sum + i;
i++;
} while (i <= 100);
System.out.println(sum);
}
- while和do…while的区别：
- while先判断后执行。do…while是先执行后判断！
- do…while总是保证循环体会被至少执行一次！这是他们的主要差别。
public static void main(String[] args) {
//do while与while的区别
int a = 0;
while (a < 0) {
System.out.println(a);
a++;
}
System.out.println("****************");
do {
System.out.println(a);
a++;
} while (a < 0);
}
for循环
- 所有循环结构都可以用while或者do…while表示，但Java提供了另一种语句—for循环，使一些循环结构变得更加简单。
- for循环语句是支持迭代的一种通用结构，最有效、最灵活的循环结构。
- for循环执行的次数是在执行前就确定的。语法格式如下：
for(初始化；布尔表达式；更新){
//代码语句
}
- 练习1：计算0到100之间的奇数和偶数的和
public static void main(String[] args) {
//练习1：计算0到100之间的奇数和偶数的和
//奇数
int oddSum = 0;
//偶数
int evenSum = 0;
for (int i = 0; i <= 100; i++) {
if (i % 2 != 0) {
oddSum += i;
} else {
evenSum += i;
}
}
System.out.println("奇数的和" + oddSum);
System.out.println("偶数的和" + evenSum);
}
- 练习2：用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个
public static void main(String[] args) {
//练习：用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个
for (int i = 0; i < 1000; i++) {
if (i % 5 == 0) {
System.out.print(i + "\t");
}
if (i % (5 * 3) == 0) { //每行
System.out.println();
System.out.print("\n");
}
}
//println 输出完全换行
//print 输出完不会换行
}
- 练习3：打印九九乘法表
public static void main(String[] args) {
//练习3：打印九九乘法表
//拆分
//1.我们先打印第一列
//2.我们把固定的1再用一个虚循环包起来
//3.去掉重复项，i <= j
//4.调整样式
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(i + "*" + j + "=" + (i * j) + "\t");
}
System.out.println();
}
System.out.println("*****************************************");
for (int j = 1; j <= 9; j++) {
for (int i = 1; i <= j; i++) {
System.out.print(j + "*" + i + "=" + (j * i) + "\t");
}
System.out.println();
}
}
增强for循环
- 作为了解，在数组重点使用
- Java5引入了一种主要用于数组或集合增强型for循环
- Java增强for循环语法格式如下：
for(声明语句:表达式){
//代码句子
}
- 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
- 表达式：表达式是访问的数组名，或者是返回值为数组的方法。
public static void main(String[] args) {
int[] numbers = {10, 20, 30, 40, 50}; //定义了一个数组
for (int i = 0; i < 5; i++) {
System.out.println(numbers[i]);
}
System.out.println("*************************************");
//遍历数组的元素
for (int x : numbers) {
System.out.println(x);
}
}
break & continue
- break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。（break语句也在switch语句中使用）
public static void main(String[] args) {
int i = 0;
while (i<100){
i++;
System.out.println(i);
if (i == 30){
break; //跳出循环
}
}
System.out.println("1000");
}
- continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。
public static void main(String[] args) {
int i =0;
while (i<100){
i++;
if (i%10 == 0){
System.out.println();
continue;
}
System.out.print(i);
}
/*
break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。（break语句也switch语句中使用）
continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。
*/
}
- 关于goto关键字
- goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的一个保留字，但并未在语言中得到正式使用；Java没有goto。然而，在break和continue这两个关键字的身上，我们仍然能看出一些goto的影子—带标签的break和continue。
- “标签”是指后面跟一个冒号的标识符，例如：label:
- 对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。
public static void main(String[] args) {
int count = 0;
//不建议使用 了解即可
outer:
for (int i = 101; i < 150; i++) {
for (int j = 2; j < i / 2; j++) {
if (i % j == 0) {
continue outer;
}
}
System.out.print(i + " ");
}
}
Java基础阶段：方法详解
一、何谓方法
- System.out.println()，是什么呢？
- Java方法是语句的集合，它们在一起执行一个功能
- 方法是解决一类问题的步骤的有序组合
- 方法包含于类或对象中
- 方法在程序中被创建，在其他地方被引用
- 设计方法的原则：方法的本意是功能块，就是实现某一功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成一个功能，这样利于我们后期的扩展。
- 回归：方法的命名规则？
二、方法的定义及调用
方法的定义
- Java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法：
- 方法包含一个方法头和一个方法体。下面是一个方法的所有部分:
- 修饰符： 修饰符，这是可逆的，告诉编译器如何调用该方法。定义了该方法的访问类型。
- 返回值类型：方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType是关键字void。
- 方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
- 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可逆的，方法可以不包含任何参数。
- 形式参数：在方法被调用时用于接收外界输入的数据。
- 实参：调用方法时实际传给方法的数据。
- 方法体：方法体包含具体的语句，定义该方法的功能。
修饰符 返回值类型 方法名(参数类型 参数名){
...
方法体
...
return 返回值;
}
方法调用
- 调用方法：对象名.方法名(实参列表)
- Java支持两种调用方法的方式，根据方法是否返回值来选择。
- 当方法返回一个值的时候，方法调用通常被当做一个值。例如：
int larget = max(30,40);
- 如果方法返回值是void，方法调用一定是一条语句。
System.out.println("Hello ，胖崽");
- 拓展了解：值传递和引用传递
public static void main(String[] args) {
//实际参数：实际调用传递给他的参数
int sum = add(1, 2);
System.out.println(sum);
}
//加法
//修饰符 返回值类型
//形式参数，用来定义作用的
public static int add(int a,int b){
return a+b;
}
三、方法重载
- 重载就是在一个类中，有相同的函数名称，但形参不同函数。
- 方法的重载的规则：
- 方法名称必须相同
- 参数列表必须不同（个数不同、或类型不同、参数排序顺序不同等）
- 方法的返回类型可以相同也可以不相同
- 仅仅返回类型不同不足以成为方法的重载
- 实现理论：
- 方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择的对应的方法，如果匹配失败，则编译器报错。
public static int add(int a,int b){
return a+b;
}
public static int add(int a,int b,int c){
return a+b+c;
}
四、命令行参数
public static void main(String[] args) {
//args.length 数组长度
for (int i = 0; i < args.length; i++) {
System.out.println("args[" + i + "]:" + args[i]);
}
}
回车 进入Dos命令
五、可变参数
- JDK1.5开始，Java支持传递同类型的可变参数给一个方法
- 在方法声明中，在指定参数类型后加一个省略号(…)
- 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
public static void main(String[] args) {
//调用可变参数的方法
printMax(23,55,12,854,32,65);
printMax(new double[]{1,2,3});
}
public static void printMax(double... numbers){
if (numbers.length == 0) {
System.out.println("No argument passed");
return;
}
double result = numbers[0];
//排序
for (int i = 0; i < numbers.length; i++) {
if (numbers[i] >result){
result = numbers[i];
}
}
System.out.println("The max value is" +result);
}
六、递归
- 递归就是：A方法调用A方法！就是自己调用自己
- 利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。
- 递归结构包括两个部分：
- 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
- 递归体：什么时候需要调用自身方法。
//递归思想
public static void main(String[] args) {
System.out.println(f(5));
}
public static int f(int i){
if (i == 1){
return 1;
}else {
return i*f(i-1);
}
}
14万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
