Java基础知识

Java基础

课程来源：狂神(kuangstudy)

01.注释

• 注释不会被执行！
• 书写注释是一个非常好的习惯！！！
• 平时写代码一定要注意规范！！

Java中的注释有三种：

• 单行注释
• 多行注释
• 文档注释

具体操作代码如下：

public class HelloWorld {
    public static void main (String[] args){
        //单行注释：只能注释一行文字
        //输出一个HelloWorld！
 
        //多行注释：可以注释一段文字  /*  注释内容  */
        /*
        多行注释
        多行注释
        多行注释
        */
 
        //JavaDoc：文档注释   /**   */
        /**
         * @Description HelloWorld
         * @Author 阿清
         */
 
        //有趣的代码注释（百度即可）
        /*
                                       _(\_/)
                                     ,((((^`\
                                    ((((  (6 \
                                  ,((((( ,    \
              ,,,_              ,(((((  /"._  ,`,
             ((((\\ ,...       ,((((   /    `-.-'
             )))  ;'    `"'"'""((((   (
            (((  /            (((      \
             )) |                      |
            ((  |        .       '     |
            ))  \     _ '      `t   ,.')
            (   |   y;- -,-""'"-.\   \/
            )   / ./  ) /         `\  \
               |./   ( (           / /'
               ||     \\          //'|
               ||      \\       _//'||
               ||       ))     |_/  ||
               \_\     |_/          ||
               `'"                  \_\
                                    `'"
        */
 
        /***
         * ░░░░░░░░░░░░░░░░░░░░░░░░▄░░
         * ░░░░░░░░░▐█░░░░░░░░░░░▄▀▒▌░
         * ░░░░░░░░▐▀▒█░░░░░░░░▄▀▒▒▒▐
         * ░░░░░░░▐▄▀▒▒▀▀▀▀▄▄▄▀▒▒▒▒▒▐
         * ░░░░░▄▄▀▒░▒▒▒▒▒▒▒▒▒█▒▒▄█▒▐
         * ░░░▄▀▒▒▒░░░▒▒▒░░░▒▒▒▀██▀▒▌
         * ░░▐▒▒▒▄▄▒▒▒▒░░░▒▒▒▒▒▒▒▀▄▒▒
         * ░░▌░░▌█▀▒▒▒▒▒▄▀█▄▒▒▒▒▒▒▒█▒▐
         * ░▐░░░▒▒▒▒▒▒▒▒▌██▀▒▒░░░▒▒▒▀▄
         * ░▌░▒▄██▄▒▒▒▒▒▒▒▒▒░░░░░░▒▒▒▒
         * ▀▒▀▐▄█▄█▌▄░▀▒▒░░░░░░░░░░▒▒▒
         * 单身狗就这样默默地看着你，一句话也不说。
         */
        
        System.out.println("HelloWorld!!");
    }
}
 

02.标识符和关键字

关键字

• Java 所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

标识符注意点

• 所有的标识符都应该以字母(A-Z或者a-z)、美元符($)或者下划线()开始。
• 首字母之后可以是字母(A-Z或者a-z)、美元符($)、下划线()或数字的任何字符组合。
• 不能使用关键字作为变量名或者方法名。
• 标识符是大小写敏感的。
• 合法标识符举例：age、$salary、_value、__1_value
• 非法标识符举例：123abc、-salary、#abc
• 可以使用中文命名，但一般不建议这样去使用，也不建议是用拼音，很Low。

public class Demo01 {
    public static void main(String[] args) {
 
        String 王者荣耀="百星王者";
        System.out.println(王者荣耀);
 
        //大小写十分敏感
        String Man="qingjiang";
        String man="qingjiang";
 
        String Ahello="qingjiang";
        String hhello="qingjiang";
        String $hello="qingjiang";
        String _hello="qingjiang";
 
        //String 1hello="qingjiang";
        //String #hello="qingjiang";
        //String *hello="qingjiang";
    }
}
 

03.数据类型讲解

强类型语言

强类型语言是一种强制类型定义的语言，一旦某一个变量被定义类型，如果不经过强制转换，则它永远就是该数据类型了，强类型语言包括Java、.net 、Python、C++等语言。
要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用。

弱类型语言

弱类型语言是一种弱类型定义的语言，某一个变量被定义类型，该变量可以根据环境变化自动进行转换，不需要经过显性强制转换。弱类型语言包括vb 、PHP、javascript等语言。 

Java的数据类型分为两大类

• 基本数据类型(primitive type)

• 引用数据类型(reference type)

//八大基本数据类型
 
//整数
int num1 = 10;//最常用的数据类型
byte num2 = 20;
short num3 = 30;
long num4 = 30L;//Long类型要在数字后面加个L，用于区分
 
//小数：浮点数
float num5 = 17.4F;//Float类型要在数字后面加个F，用于区分
double num6 = 3.141592653589793238462643;
 
//字符
char name = '清';
/*
字符串，String是类，不是关键字
String namea = "阿清";
*/
 
//布尔值
boolean flag = true;
boolean flaga = false;

拓展：什么是字节？

• 位（bit）：是计算机 内部数据 存储的最小单位，11001100是一个八位二进制数。
• 字节（byte）：是计算机中 数据处理 的最基本单位，习惯上用大写字母B来表示。
• 1B（byte，字节）= 8 bit（位）
• 字符：是指计算机中使用的字母、数字、字和符号。
• 1 bit 表示 1 位
• 1 byte 表示一个字节 1 B = 8 b
• 1024 B = 1 KB
• 1024 KB = 1 M
• 1024 M = 1 G
• 1024 G = 1 TB

04.数据类型扩展及面试题讲解

整数拓展

//整数拓展：	进制	二进制0b		十进制		八进制0		十六进制0x
int i1 = 10;// 10	
int i2 = 010;// 8	八进制0
int i3 = 0x10;// 16		十六进制0x	0~9	A~F

浮点数拓展

//浮点数拓展：银行业务怎么表示？钱
//BigDecimal 数学工具类
//float 有限 离散 舍入误差 大约 接近但不等于
//double
//最好完全使用浮点数进行比较
float f = 0.1f;//0.1
double d = 1.0/10;//0.1
System.out.println(f==d);//false
 
float f1 = 1231233123f;
float f2 = f1 + 1;
System.out.println(f1==f2);//true

字符拓展

//字符拓展
char c1 = 'a';
char c2 = '中';
 System.out.println(c1);//a
 System.out.println((int)c1);//97 强制转换
 System.out.println(c2);//中
 System.out.println((int)c2);//20013 强制转换
 
 //所有字符的本质还是数字
//编码 Unicode 表：（97 = a	65 = A） 2字节	0 ~ 65536	Excel 2的16次方 = 65536
// U0000 ~ UFFFF
char c3 = '\u0061';
System.out.println(c3);//a 

转义字符

//转义字符
//	\t	制表符
//	\n	换行
//	...

思考

String s1 = new String(original:"hello world");
String s2 = new String(original:"hello world");
System.out.println(s1==s2);//false
String s3 = "hello world";
String s4 = "hello world";
System.out.println(s3==s4);//true
//对象 从内存分析

布尔值拓展

//布尔值拓展
boolean flag = true;
if(flag==true){}//新手
if(flag){}//老手
//Less is More！ 代码要精简易读！

05.类型转换

• 由于 Java 是强类型语言，所以在进行有些运算的时候，需要用到类型转换。

• 低--------------------------------------------------->高

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

• 运算中，不同类型的数据先转换为同一类型，然后进行运算。

• 转换类型分为强制转换和自动转换。

强制转换和自动转换

//强制转换	(类型)变量名		高-->低
int i = 128;//输出结果为128
byte b = (byte)i;//输出结果为-128	内存溢出
 
//自动转换	低-->高
 
 
/*
注意点：
1.不能对布尔值进行转换
2.不能把对象类型转换为不相干的类型
3.在把高容量转换到低容量的时候，强制转换
4.转换的时候可能存在内存溢出，或者精度问题！
*/
System.out.println((int)23.7);//23
System.out.println((int)-45.89f);//-45
 
char c = 'a';
int d = c + 1;
System.out.println(d);//98
System.out.println((char)d);//b
 
 
//操作比较大的数的时候，注意溢出问题
//JDK7新特性，数字之间可以用下划线分割,下划线不会被输出
int money = 10_0000_0000;//1000000000
int years = 20;
int total1 = money*years;
System.out.println(total1);//-1474836480,计算的时候溢出了
long total2 = money*years;
System.out.println(total2);//-1474836480,默认是int转换之前已经存在问题了
long total3 = money*((long)years);
System.out.println(total3);//20000000000,先把一个数转换为long

06.变量、常量、作用域

变量

• 变量是什么：就是可以变化的量！
• Java 是一种强类型语言，每个变量都必须声明其类型。
• Java 变量是程序中最基础的存储单元，其要素包括变量名，变量类型和作用域。

type varName [=value] [{,varName[=value]}];
//数据类型	变量名 = 值;可以用逗号隔开来声明多个同类型变量。

例子：

//int a,b,c;
//int a = 1,b = 2,c = 3;//程序可读性
String name = "小徐";
char x = 'X';
double pi = 3.14;

• 注意事项:
  • 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
  • 变量名必须是合法的标识符。
  • 变量声明是一条完整的语句，因此每一个声明都必须以分号结束。

变量作用域

• 类变量
• 实例变量
• 局部变量

public class Demo{
	
	//类变量		static
	static double salary = 2500;
	//属性：变量
	
	//实例变量：从属于对象;
	//如果不自行初始化，这个类型的默认值为0 0.0 
	//布尔值：默认值是false
	//除了基本类型，其余的默认值都是null;
	String name;
	int age;
	// main方法
	public static void main(String[] args){
	
		//局部变量;必须声明和初始化值
		int i = 8;
		System.out.println(i);
		
		//变量类型	变量名字 = new 类名();
		Demo demo = new Demo();
		System.out.println(demo.name);//null
		System.out.println(demo.age);//0
 
		//类变量		static
		System.out.println(salary);
		}
}

常量

• 常量(Constant)：初始化(initialize)后不能在改变值！不会变动的值。

• 所谓常量可以理解为一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

// final 常量名 = 值;
final double PI = 3.14;
static final double PI = 3.14;//数据类型前面的关键字均为修饰符不存在先后顺序

• 常量名一般使用大写字符。

变量的命名规范

• 所有的变量、方法、类名：见名知意
• 类成员变量：首字母小写和驼峰原则(monthSalary 除了第一个单词外，后面的单词首字母大写)
• 局部变量：首字母小写和驼峰原则
• 常量：大写字母和下划线：MAX_VALUE
• 类名：首字母大写和驼峰原则：Man，GoodMan
• 方法名：首字母小写和驼峰原则：run(),runRun()

07.基本运算符

• Java语言支持如下运算符
  • 算数运算符：+ ， - ， * ， / ，% ，++ ，–
  • 赋值运算符：==
  • 关系运算符：> , < , >= , <= , == , != , instanceof
  • 逻辑运算符：&&，|| ，！
  • 位运算符：& ，| ，^ , ~ , >> , << , >>> (了解！！！)
  • 条件运算符： ？ ：
  • 扩展赋值运算符：+= ，-= ，*= ，/=

//二元运算符
int a = 10;
int b = 20;
System.out.println(a+b);//30
System.out.println(a-b);//10
System.out.println(a*b);//200
System.out.println(a/b);//0
System.out.println(a/(double)b);//0.5

long a = 123123123123123L;
int b =123;
short c = 10;
byte d = 8;
System.out.println(a+b+c+d);//123123123123264		Long
System.out.println(b+c+d);//141		Int
System.out.println(c+d);//18		Int

//关系运算符返回的结果： 正确，错误	布尔值
int a = 10;
int b = 21;
System.out.println(a>b);//false
System.out.println(a<b);//true
System.out.println(a==b);//false
System.out.println(a!=b);//true
 
//取余，模运算
System.out.println(b%a);// b/a  21 / 10 = 2 ... 1

08.自增自减运算符、初识Math类

自增自减运算符

// ++	--	自增	自减	一元运算
int a = 3;
int b = a++;//执行完这行代码后，先给b赋值，在自增
// a++ 	a = a + 1
System.out.println(a);//4
int c = ++a;//执行完这行代码前，先自增，再给c赋值
// ++a a = a + 1
System.out.println(a);//5
System.out.println(b);//3
System.out.println(c);//5
 
int a = 3;
int b = a--;//执行完这行代码后，先给b赋值，在自减
// a-- 	a = a - 1
System.out.println(a);//2
int c = --a;//执行完这行代码前，先自减，再给c赋值
// --a  a = a - 1
System.out.println(a);//1
System.out.println(b);//3
System.out.println(c);//1

Math类

//幂运算 2^3  2*2*2 = 8 很多运算，我们都会使用一些工具类来操作！
double pow = Math.pow(2,3);
System.out.println(pow);//8.0

09.逻辑运算符、位运算符

逻辑运算符

//逻辑运算符
//与（and）或（or）非（取反）
boolean a = true;
boolean b = false;
System.out.println("a && b : "+(a&&b));//输出结果为：a && b : false	逻辑与运算：两个变量都为真，结果才是true
System.out.println("a || b : "+(a||b));//输出结果为：a || b : true	逻辑或运算：两个变量有一个为真，则结果才是true
System.out.println("!(a && b) : "+!(a&&b));//输出结果为：!(a && b) : true	如果是真，则变为假，如果是假，则变为真
 
//短路运算
int c = 5;
boolean d = (c<4)&&(c++<4);
System.out.println(d);//false
System.out.println(c);//5

位运算符

/*
	A = 0011 1100
	B = 0000 1101
  A&B = 0000 1100 //相对应位有0，则结果为0，否则为1
  A|B = 0011 1101 // 相对应位有1，则结果为1，否则为0
  A^B = 0011 0001 //相同为0，不同为1
   ~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
*/
	System.out.println(2<<3);//16
 

10.三元运算符、扩展运算符

三元运算符

	//	x ? y : z
	//如果x==true，则结果为y，反之结果为z
	int score = 80;
	String type = score < 60 ? "不及格" : "及格";
	System.out.println(type);//及格

扩展赋值运算符

	int a = 10;
	int b = 20;
	/*
	a += b;// a = a + b
	a -= b;// a = a - b
	a *= b;// a = a * b
	a /= b;// a = a / b
	*/
	//字符串连接符	+	,	String
	System.out.println(""+a+b);//1020
	System.out.println(a+b+"");//30

11.包机制

• 为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。

• 包语句的语法格式为：

  package pkg1[.pkg2[.pkg3...]];

• 一般利用公司域名倒置作为包名

• 为了能够使用某一包的成员，我们需要在 Java 程序中明确导入该包。使用“ import ”语句可完成此功能。

  import package1[.package2...].(classname|*);

12.JavaDoc 生成文档

• JavaDoc 命令是用来生成自己的API文档的。
• 参数信息
  • @author 作者名
  • @version 版本号
  • @since 指明需要最早使用的 jdk 版本
  • @param 参数名
  • @return 返回值情况
  • @throws 异常跑出情况

package com.xiaoxu.base;
/**
*@auther xiaoxu
*@version 1.0
*@since 1.8
*/
public class Doc{
	String name;
	/**
	*@auther xiaoxu
	*@param name
	*@return
	*@throws Exception
	*/
	public String test(String name) throws Exception{
		return name;
	}
}

• 命令行 javadoc 参数 Java 文件
• 使用 IDEA 生成 JavaDoc 文档

Java流程控制

01.用户交互 Scanner

Scanner 对象

• Java 给我们提供了这样一个工具类，我们可以获取用户的输入。Java.util.Scanner 是 Java 5 的新特性，我们可以通过 Scanner 类来获取用户的输入。

• 基本语法：

  Scanner s = new Scanner(System.in);

• 通过 Scanner 类的 next() 与 nextLine() 方法获取输入的字符串，在读取前我们一般需要使用 hasNext() 与 hasNextLine() 判断是否还有输入的数据。

• next(); 和 nextLine(); 的区别：

  • next():
    • 一定要读取到有效字符后才可以结束输入。
    • 对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
    • 只有输入有效字符之后才将其后面输入的空白作为分隔符或者结束符。
    • next() 不能得到带有空格的字符串。
  • nextLine():
    • 以 Enter 为结束符，也就是说 nextLine() 方法返回的是输入回车之前的所有字符。
    • 可以获得空白。

next();

//创建一个扫描器对象，用于接收键盘数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用next方法接收：");
//判断用户是否输入字符串
if(scanner.hasNext()){
	//使用next方式接收
	String str = scanner.next();//程序会等待用户输入完毕
	System.out.println("输出的内容为："+str);
}
//凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉
scanner.close();

nextLine();

//创建一个扫描器对象，用于接收键盘数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用nextLine方法接收：");
//判断用户是否输入字符串
if(scanner.hasNextLine()){
	//使用next方式接收
	String str = scanner.nextLine();//程序会等待用户输入完毕
	System.out.println("输出的内容为："+str);
}
//凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉
scanner.close();

简：

//创建一个扫描器对象，用于接收键盘数据
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数据：");
//使用next方式接收
String str = scanner.nextLine();//程序会等待用户输入完毕
System.out.println("输出的内容为："+str);
//凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉
scanner.close();

02.Scanner 进阶使用

Scanner scanner = new Scanner(System.in);
//从键盘接收数据
int i = 0;
float f = 0.0f;
//如果...那么...
if(scanner.hasNextInt()){
	i = scanner.nextInt();
	System.out.println("整数数据："+ i);
}else{
	System.out.println("输入的不是整数数据！");
}
//如果...那么...
if(scanner.hasNextFloat()){
	f = scanner.nextFloat();
	System.out.println("小数数据："+ f);
}else{
	System.out.println("输入的不是小数数据！");
}
scanner.close();

实例：我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果

Scanner scanner = new Scanner(System.in);
System.out.println("请输入多个数据，每输入一个数字用回车确认：");
//和
double sum = 0;
//计算输入了多少个数字
int m = 0;
//通过循环判断是否还有输入，并在里面对每一次进行求和和统计
while(scanner.hasNextDouble()){
	double x = scanner.nextDouble();
	m = m + 1;//m++
	sum = sum + x;
	System.out.println("你输入了第"+m+"个数据，然后当前结果sum="+sum);
}
System.out.println("个数的和为" + sum);
System.out.println("个数的平均值是" + (sum /m));
scanner.close();

03.顺序结构

• JAVA 的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。
• 顺序结构是最简单的算法结构。
• 语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。

04.if 选择结构

if 单选择结构

• 判断一个东西是否可行，然后才去执行，这样的一个过程在程序中用 if 语句来表示。

• 语法：

if(布尔表达式){
	//如果布尔表达式为true将执行的语句
}

例子：

Scanner scanner = new Scanner(System.in);
System.out.println("请输入内容：");
String s = scanner.nextLine();
//equals：判断字符串是否相等
if (s.equals("Hello")){
	System.out.println(s);
}
System.out.println("End");
scanner.close();

if 双选择结构

• 需要有两个判断，需要 if - else 双选择结构。

• 语法：

if(布尔表达式){
	//如果布尔表达式的值为true将执行的语句
}else{
	//如果布尔表达式的值为false将执行的语句
}

例子：

//考试分数大于60就是及格，小于60就是不及格。
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩：");
int score = scanner.nextInt();
if (score>60){
	System.out.println("及格");
}else{
	System.out.println("不及格");
}
scanner.close();

if 多选择结构

• 存在区间多级判断，需要一个多选择结构来处理这类问题。

• 语法：

if(布尔表达式 1 ){
	//如果布尔表达式 1 的值为true执行代码
}else if(布尔表达式 2 ){
	//如果布尔表达式 2 的值为true执行代码
}else if(布尔表达式 3 ){
	//如果布尔表达式 3 的值为true执行代码
}else{
	//如果以上布尔表达式的值都不为true执行代码
}

实例：

Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩：");
int score = scanner.nextInt();
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("成绩不合法！");
}
scanner.close();

注意点：

• if 语句至多有一个 else 语句， else 语句在所有 else if 语句之后。
• if 语句可以有若干个 else if 语句，它们必须在 else 语句之前。
• 一旦其中一个 else if 语句检测为 true ，其他的 else if 以及 else 语句都将跳过执行。

嵌套的 if 结构

• 使用嵌套的 if … else 语句是合法的。也就是说你可以在另一个 if 或 else if 语句中使用 if 或者 else if 语句。你可以像 if 语句一样嵌套 else if … else。

• 语法：

if(布尔表达式 1){
	//如果布尔表达式 1 的值为 true 执行代码
	if(布尔表达式 2){
		//如果布尔表达式 2 的值为 true 执行代码
	}
}

05.switch选择结构

• 多选择结构还有一个实现方式就是 switch case 语句。
• switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
• 语法：

switch(expression){
	case value:
		//语句
		break;//可选
	case value:
		//语句
		break;//可选
	//你可以拥有任意数量的 case 语句
	default://可选
		//语句
}

• switch 语句中的变量类型可以是：
  • byte、short、int 或者 char。
  • 从 Java SE 7 开始。
  • switch 支持字符串 String 类型了。
  • 同时 case 标签必须为字符串常量或字面量。
    例子：

//case 穿透  //switch 匹配一个具体的值
char grade = 'C';
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("未知等级");
}

//JDK 7 的新特性，表达式结果可以是字符串！！！
//字符的本质还是数字
//反编译  java --- class（字节码文件）---反编译（IDEA）
String name = "小徐";
switch (name){
	case "小徐"：
		System.out.println("小徐");
		break;
	case "珊子"：
		System.out.println("珊子");
		break;
	default:
		System.out.println("识别失败！");
}

06.while循环

• while 是最基本的循环，它的结构为：

while(布尔表达式){
	//循环内容
}

• 只要布尔表达式为 true ，循环就会一直执行下去。
• 我们大多数情况是会让循环停下来的，我们需要一个让表达式失效的方式来结束循环。
• 少部分情况需要循环一直执行，比如服务器的请求响应监听等。
• 循环条件一直为 true 就会造成无限循环【死循环】，我们正常的业务编程中应该尽量避免死循环。死循环会影响程序性能或者造成程序卡死崩溃！

例子：计算1+2+3+…+100=？

int i = 0;
int sum = 0;
while(i<=100){
	sum = sum + i;
	i++;
}
System.out.println(sum);//5050

死循环

while(true){
	//等待客户端连接
	//定时检查
	//......
}

07. do while循环

• 对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。

• do … while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

do{
	//代码语句
}while(布尔表达式);

• while 和 do-while 的区别：
  • while 先判断后执行。do-while 先执行后判断！
  • do … while 总是保证循环体会被至少执行一次！这是他们的主要区别。

例子：

int i = 0;
int sum = 0;
do{
	sum = sum + i;
	i++;
}while(i<=100);
System.out.println(sum);//5050

int a = 0;
while (a<0){
	System.out.println(a);
	a++;
}
System.out.println("==============");
do{
	System.out.println(a);
	a++;
}while(a<0);
 
//输出结果
//==============
//0

08.for循环

• for 循环会使一些循环结构变得更加简单。

• for 循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。

• for 循环执行的次数是在执行前就确定的。

• 语法格式如下：

for(初始化;布尔表达式;更新){
	//代码语句
}

对比:

int a = 1;//初始化条件
while(a<=100){//条件判断
	System.out.println(a);//循环体
	a++;//迭代
}
System.out.println("while 循环结束！");
 
//初始化//条件判断//迭代
for(int i = 1;i<=100;i++){
	System.out.println(i);	
}
System.out.println("for 循环结束！");

死循环

for(;;){
	//等待客户端连接
	//定时检查
	//......
}

关于 for 循环有以下几点说明：

• 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
• 然后，检测布尔表达式的值。如果为 true ，循环体被执行；反之为 false ，循环终止，开始执行循环体后面的语句。
• 执行一次循环后，更新循环控制变量(迭代因子控制循环变量的增减)。
• 再次检测布尔表达式。循环执行上面的过程。

实例一：计算 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);

实例二：用 while 或 for 循环输出1-1000之间能被5整除的数，并且每行输出3个

for(int i = 0;i<=1000;i++){
	if(i%5==0){
		System.out.println(i+"\t");
	}
	if(i%(5*3)==0){
		System.out.println();
		//System.out.print("\n");
	}
	//println 输出完会换行
	//print 输出完不会换行
}

09.打印九九乘法表

//1.首先打印第一列
//2.把固定的1再用一个循环包起来
//3.去掉重复项，j<=i
//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();
}

10.增强for循环

• Java 5 引入了一种主要用于数组或集合的增强型 for 循环。

• Java 增强 for 循环语法格式如下：

for (声明语句:表达式){
	//代码语句
}

• 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环句块，其值与此时数组元素的值相等。
• 表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

例子：

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);
}
//输出结果
//10
//20
//30
//40
//50
//=================
//10
//20
//30
//40
//50

11.break、continue、goto

• break 在任何循环语句的主体部分，均可用 break 控制循环的流程。break 用于强行退出循环，不执行循环中剩余的语句。( break 语句也在 switch 语句中使用)
• continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。
• 关于 goto 关键字
  • goto 关键字在很早就在程序设计语言中出现。尽管 goto 仍是 Java 的一个保留字，但并未在语言中得到正式使用；Java没有 goto 。然而，在 break 和 continue 这两个关键字的身上，我们仍然能看出一些 goto 的影子—带标签的 break 和 continue 。
  • "标签"是指后面跟一个冒号的标识符，例如：label ：
  • 对 Java 来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于 break 和 continue 关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。

例子：打印101-150之间所有的质数

//不建议使用！！
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+" ");
	//101 103 107 109 113 127 131 137 139 149
}

12.打印三角形及Debug

实例一：打印三角形 五行

/*
	    *
	   ***
	  *****
	 *******
	********* 
*/
for(int i = 1; i <= 5;i++){
	for(int j = 5;j >= i;j--){
		System.out.print(" ");
	}
	for(int j = 1;j <= i;j++){
		System.out.print("*");
	}
	for(int j = 1;j < i;j++){
		System.out.print("*");
	}
	System.out.println();
}