Java基础语法
数据类型
注意 : Java语言是强制类型语言. 任何的数据,都是进行严格分类的
方便管理数据,Java语言将数据分成了两大类别.
-
基本数据类型 (四类八种)
-
整型
-
字节型 (关键字 byte)
字节型在内存中,占用1个字节(8个二进制位)
字节型的数据的取值范围 -128 ~ 127
-
短整型(关键字 short)
短整型在内存中,占用2个字节(16个二进制位)
短整型的数据的取值范围 -32768 ~ 32767
-
整型(关键字 int) Java的默认类型
整型在内存中,占用4个字节(32个二进制位)
整型的数据的取值范围 -2147483648~ 2147483647
-
长整型(关键字 long)
长整型在内存中,占用8个字节(64个二进制位)
长整型的数据的取值范围 -9223372036854775808~ 9223372036854775807
-
-
浮点
-
单精度(关键字 float)
单精度浮点在内存中,占用4个字节
单精度浮点的数据的取值范围 1.4E-45~ 3.4028235E38
-
双精度(关键字 double)Java的默认类型
双精度浮点在内存中,占用8个字节
双精度浮点的数据的取值范围 4.9E-324~ 1.7976931348623157E308
-
-
字符 (关键字 char)
- 类型每次只能存储1个字符
- 字符型在内存中,占用2个字节 (和short一致)
-
布尔 (关键字 boolean)
- 布尔类型只有true和false
- 内存中占1个字节
-
-
引用数据类型 (5种)
- 数组 (英语 Array)
- 类 (英语 class 也是关键字)
- 接口 (英语 interface 也是关键字)
- 枚举 (英语 enum 也是关键字)
- 注解 (英语 Annotation)
变量
变量 : 常量是固定不变化, 变量的数据是可以随时改变的, 变量方便进行运算
变量的定义三要素 :
- 明确数据类型
- 变量的名字
- 变量的值
变量定义的格式 :
数据类型 变量名字 = 值
public static void main(String[] args) {
/*
* 定义出所有的基本数据类型变量
* 4类8种
* 定义格式:
* 数据类型 变量名字 = 值
*/
//定义字节型,关键字 byte
byte b = 100;
System.out.println(b);
//定义短整型,关键字 short
short s = 10000;
System.out.println(s);
//定义整型,关键字 int 最常用的类型
int i = 999999;
System.out.println(i);
//定义长整型,关键字 long
//注意 : Java语言,任何整数默认都是int类型
//将整数变成long类型, 数字后面写字母L (不分大小写,建议大写)
long l = 1234567890123L;
System.out.println(l);
//定义浮点数据,单精度 关键字float
//Java中浮点数据,默认是double
//浮点数变成float类型,数字后面写字母F (不分大小写,建议大写)
float f = 3.14F;
System.out.println(f);
//定义浮点数据,双精度 关键字 double
double d = 3.14;
System.out.println(d);
//定义字符类型, 关键字char
char c = '去';
System.out.println(c);
//定义布尔类型,关键字 boolean
boolean bool = true;
System.out.println(bool);
}
变量定义的注意事项
-
变量定义,但是没有赋值,不能使用
public static void main(String[] args) { int i ; System.out.println(i); }
-
可以先定义变量,再赋值
public static void main(String[] args) { int i ; i = 1; System.out.println(i); } -
在同一个大括号内,变量名不能相同
public static void main(String[] args) { int i ; i = 1; System.out.println(i); int i = 2; System.out.printl(i); } 作用范围,变量只能作用在定义的一对大括号内有效,出去大括号无效
变量定义格式补充
先声明变量,后赋值
public static void main(String[] args) {
int a;
a = 1;
//一次定义多个变量名字
int b,c,d,e;
//分别进行赋值
b=1;
c=2;
d=3;
e=4;
//比较恶心
int f = 1, m=2, n,g;
n=1;
g=2;
}
数据类型转换 (有点难)
Java语言是强制类型语言,要求在数据进行运算的时候,必须保证类型的一致性.
如果数据在运算的时候,类型不一致,发生类型转换现象.
所有的基本数据类型中,只有布尔类型不参与转换
自动类型转换
-
转换原则 : 数据类型取值范围小的会自动提升为取值范围大的类型
-
byte -> short -> int -> long -> float -> double
public static void main(String[] args) { /* * 字节byte和整型int 求和 * byte取值范围小的类型,int取值范围大 * 求和的时候,发生类型的转换!! */ byte b = 1; int i = 2; int j = b + i; // b+1 类型转换 b转成int System.out.println(j); } -
byte和short的计算,默认转成int
public static void main(String[] args) { //求和计算 //1 == Java默认int //1.1 == Java默认double //1 自动转换double 补: 1.0 double d = 1+1.1; //计算后的最终的类型结果是 double System.out.println(d); d = 1+0.0; System.out.println(d); /* * 求和计算,认真思考 */ byte b = 1; short s = 1; //b+s不能运算,数据类型不同,类型的转换,计算结果的数据类型int //Java规定 : byte short 进行运算,都会自动转成int!! int k = b+s; System.out.println(k); } -
char类型计算的时候,查询ASCII编码表,取出整数进行计算 (转成int类型)
public static void main(String[] args) { //char 字符类型,内存中占用2个字节 char c = 'a'; System.out.println(c); //char字符类型,也可以进行计算 //字符char类型计算的时候,转成int类型 //会到ASCII编码表中查询数字出来 System.out.println(c+1);// 98 }
-
字符编码表.jpg
-
char类型是否存在取值范围
在内存中,和short占用2个字节 0-65535
强制类型转换
强制 : 程序人员手动的参与转换
强制类型转换 : 取值范围大的类型,转成取值范围小的类型
尽量少做,出现数据精度丢失问题.
-
浮点数,转成整数
- 1.5 转成整数 结果是1,小数部分直接丢弃
-
转换的公式 :
被转换后的类型 变量名字 = (被转换后的类型)要转换的数据;public static void main(String[] args) { //浮点数据,转成整数 double d = 1.5; //d取值范围大的类型,转成int类型 (丢失精度) //被转换后的类型 变量名字 = (被转换后的类型)要转换的数据; int i = (int)d; System.out.println(i); } -
整数之间的类型转换
public static void main(String[] args) { byte b = 1; int i = 2; /* * b 1个字节 * i 4个字节 * b+i 的结果还是4个字节 * * 4个字节的结果,复制到1个字节的c中 * b + i 的结果,强制的转成byte类型 * * 被转换后的类型 变量名字 = (被转换后的类型)要转换的数据; */ byte c = (byte) (b + i); System.out.println(c); short s = 1 ; /* * s + 1 int类型,和short类不能计算 * s 提升为int类型,求和后变成int * 赋值回变量s ,需要类型的强制转换 * s + 1的结果,强制转换为short */ s = (short) (s + 1); System.out.println(s); }public static void main(String[] args) { /* * 1 是int类型 * int类型, 赋值到byte了呢 * * javac 编译器 : .java文件,编译为可以执行的class文件 * 编译的时候,检测1是否超过byte的范围 * 没有超过byte范围, javac帮你将int类型的1,转成byte类型 */ byte b = 1; System.out.println(b); byte b2 = (byte)300; //超过byte范围的300,强制转byte类型 System.out.println(b2); } 计算中,常量是已经确定计算结果,(固定不变)
-
变量,在计算中,不确定结果,运行完毕才可知
short s1 = 1; short s2 = 1; /* * s1 + s2 == > 变成int */ short s3 = (short) (s1 + s2); System.out.println(s3); /* * s4 = 1+1 是正确的 * 变量计算和常量计算的区别 * s1 + s2 是变量, 编译的时候javac, 编译器不确定的值是什么 * 求和的结果按照int计算 * * 1 + 1是常量,固定不变 javac编译,可以确定计算的结果 * 判断出结果没有超过short范围,不会报错 */ short s4 = 1 + 1; System.out.println(s4);
运算符
运算符在程序中作用是数据之间进行运算.运算符分类
算数运算符
-
+ - * / %- % 取模, 计算的结果要余数
赋值运算符
= 符号右边的数据,赋值到左边的变量
-
+= -= *= /= %= 不能分开
public static void main(String[] args) { int i = 1; /* * i+1的结果,再赋值变量i */ i = i + 1; System.out.println(i); /* * += 赋值运算符 * j+=1; 本质上理解为 j = j+1 */ int j = 1; j+=1; // 等价于 j = j + 1 System.out.println(j); /* * += 另一个问题 * s += 2; 等价于s = s + 2 * += 是一个符号,运算是一次完成 (javac自动的进行强制转换) */ short s = 1; s += 2; System.out.println(s); } -
++ 和 --
public static void main(String[] args) { //++ 符号,含义是变量自增1 -- 变量自减1 int i = 1; i++; System.out.println(i); /* * ++或者--符号,可以出现在变量的前面或者是后面 */ ++i; System.out.println(i); /* * ++在前在后的区别 */ int m = 1; //++在后面,后运算 //先将m的值,赋值变量n, m自己在增1 int n = m++; System.out.println(m); //2 System.out.println(n); //1 //++在前面,先运算 //m自己先增1, 增1后的结果,赋值到n n = ++m; System.out.println(m);//3 System.out.println(n);//3 }- ++ 和--的结论:
- 变量只有自己的时候 ++ 写在前还是后没有区别,自己都会增1
- 变量和其他变量做运算
- 写后面,是先将自己的值赋给其他变量,自己在增1
- 写前面,先自己增1,增1后赋值另一个变量
- ++ 和--的结论:
比较运算符
比较运算符,是数据之间做比较的,特点:比较运算符的执行结果只能是布尔类型
比较运算符的运算结果,要么是true,要么是false,不会出现其他的结果
- == 等等于 比较符号两边的数据是否相等,如果相等,计算结果是true
- != 不等于 比较符号两边的数据是否不相等,如果不等待,结算结果是true
-
>大于号比较符号左边的数是否大于右边的数,如果大于结果是true -
<小于号结果略 -
>=大于等于 <=小于等于结果略
逻辑运算符
逻辑的运算符,计算结果也是布尔类型,要么是true,要么是false
- & 逻辑与 &符号的两边 一边结果是false,整体运算结果是false,两边都是true,结果是true
- | 逻辑或 |符号的两边 一边结果是true,整体的运算结果是true,两边都是false,结果是false
- ! 逻辑非 ! 取反 true取反变false, false取反变true
- && 双与 提高运算效率,和单符号的计算结果无区别
- 高效处理 : 左边是false,右边不计算
- || 双或 提高运算效率,和单符号的计算结果无区别
- 高效处理 : 左边是true,右边不计算
public static void main(String[] args) {
//&符号的两边 一边结果是false,整体运算结果是false
System.out.println(2==2 & 2==1);
//System.out.println(false & true );
//|符号的两边 一边结果是true,整体的运算结果是true
System.out.println( 1==1 | 2==3);
//! 取反 true取反变false, false取反变true
System.out.println( !false );
int i = 1;
int j = 1;
System.out.println( i==2 && ++j==2);
System.out.println(j);
System.out.println(i==1 || j==3);
}
位运算符
位运算,数字的二进制位的运算
运算之前,先将数字转成二进制后,才能计算
-
& | ^ << >> >>>
- 计算过程中,二进制0表示false,1表示true
- 计算结果,和逻辑运算符一致
- ^ (异或)相同结果是false,不相同结果是true
- <<左移动 >>右移动 数字的二进制进行位置移动
-
>>>无符号右移动
public static void main(String[] args) { System.out.println( 6 & 7 ); System.out.println(6 | 7); // ^异或 计算结果,相同为false,不同为true System.out.println( 6 ^ 7); //2 向右移动1位 相当于原数字/2 System.out.println(2 >> 1); //2左移动2位 相当于原数字*2*2 System.out.println( 2 << 2); //无论数据的最高位是1还是0,移动后全部补0 System.out.println(-1 >>> 2); }
三元运算符
三元又称为三目运算
-
运算符格式 :
布尔表达式?结果1:结果2public static void main(String[] args) { //布尔表达式?结果1:结果2 //布尔表达式 : 怎么写都可以,运算结果是true,false即可 //三元运算符的计算结果 : 布尔表达式结果是true,执行结果1,否则执行结果2 int i = 2==2?100:200; System.out.println(i); System.out.println(1==2?"等于":"不等于"); //System.out.println(1==1?5:1.0); }
字符串数据的+计算
字符串和+一起计算, +变成连接作用,失去的求和的含义
计算的结果都是字符串类型.
public static void main(String[] args) {
//"5" 是字符串类型 ,5是int类型
//不计算,遇到字符串, + 变成连接作用
//计算的结果的类型,是字符串
System.out.println("5" + 5);
System.out.println(1+2+"3");
System.out.println(true+"1");
}
Scanner 键盘输入作用
在Java基础阶段 SE技术平台中,是有意义
Scanner是Java中,已经做好的一个类,拿来使用即可
注意 : 使用已经做好的类Scanner,我们自己创建类,类名不能是Scanner
//1: 导入该类所在的包
import java.util.Scanner;
public class ScannerDemo {
public static void main(String[] args) {
//2: 创建Scanner类的对象
Scanner sc = new Scanner(System.in);
//3: 创建好的对象,调用方法,实现键盘的输入 (整数,字符串)
int i = sc.nextInt();//接收键盘输入,整数
System.out.println(i+1);
}
}
Sacnner接收字符串类型
public static void main(String[] args) {
//Scanner键盘输入字符串
Scanner sc = new Scanner(System.in);
//接收字符串, Scanner类中方法 next()
//String s = sc.next(); //字符串中有空格,空格后面不接收
//接收字符串,Scanner类中方法 nextLine()
String s = sc.nextLine(); //接收一行
System.out.println(s+123);
}
Scanner反复接收数据的问题
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//输入int
int i = sc.nextInt(); // 123 回车
System.out.println(i);
//输入字符串
String s = sc.nextLine();
System.out.println(s);
}
流程控制语句
现在阶段,写的所有程序,都称为顺序解构.程序只能从上向下依次执行.
实现更加复杂的功能,使用流程控制语句
判断语句 if ,选择语句 switch ,循环语句 for while do while
if判断语句
只有一个关键字 if (如果)
格式 :
if(条件的判断){
if语句的执行体
}
条件的判断 : 这里的结果必须是布尔类型
if的语句体 : 如果条件判断的结果是true,执行该语句体,判断的结果是false,什么也不做
- if的语句实现
public static void main(String[] args) {
int i = 1;
//if的判断语句
if( i > 0) {
System.out.println("执行了大括号里面程序");
System.out.println("if的条件判断是true");
}
}
if语句注意事项
if语句是可以省略大括号的 : 0基础,新手,大括号一定要写
如果不写大括号, if判断语句只能控制距离他最近的一行程序!!
public static void main(String[] args) {
int i = 1 ;
if( i == 1)
System.out.println("你好");
System.out.println("我好");
}
if语句: (判断条件) 有一个写法,希望你用, 建议在判断里面,常量写在变量的前面.
public static void main(String[] args) {
//定义布尔类型的变量
boolean bool = false;
//System.out.println(false == false);
if(false == bool) {
System.out.println("if的判断条件是true");
}
}
if...else语句
if是如果,else是否则. 如果怎么样,就怎么样. else语句是不能单独出现,只能跟随if出现
语句格式 :
if(条件判断){
if语句的执行体
}else{
else语句的执行体
}
- 执行流程 :
- 程序先执行if中的条件判断语句,如果判断语句是true,那么就执行if的语句体
- 如果if中的条件判断结果是false,那么就会执行else的语句体
- if语句和else语句,永远不会同时执行,不会都不执行
- if和else每天鸡犬相闻,但是老死不相往来
- 适合于多个条件的判断
if...else if...else if...else
多分支语法格式:
if(条件判断){
} else if(条件判断){
} else if(条件判断){
} else {
}
适合与多条件的判断,但是 if else过多,会导致程序的阅读性下降
优势 : 高效的优势,只要有一个if的条件判断结果是true,整体的语句结构就结束了
public static void main(String[] args) {
int i = 99;
//if else if的多分支
if(i < 100) {
System.out.println("第一个if的条件是true");
}else if(i > 100){
System.out.println("第二个if的条件是true");
}else if (i == 100) {
System.out.println("第三个if的条件是true");
}else {
System.out.println("所有的条件都是false");
}
}
多分支语句的练习
需求 : 请你输入你的考试成绩,对成绩进行等级划分
90-100 : 优
80-89 : 良
70-79 : 中
60-69 : 差
<60 : 不及格
switch选择语句
程序也是进行选择的, switch语句中包含的关键字比较多
switch case default break
switch语句的格式 :
switch (变量){
case 常量1 :
要执行的语句1;
break;
case 常量2 :
要执行的语句2;
break;
case 常量3 :
要执行的语句3;
break;
default:
要执行的语句;
break;
}
-
语句流程详细解释
- switch中的变量,和case后面的常量,进行比较 (是否相同)
- 如果和 常量1相等,执行 : 语句1, 执行break,整体switch结束
- 如果和 常量2相等,执行 : 语句2, 执行break,整体switch结束
- switch中的变量,和任何一个case后面的常量都不相等,执行default后面的语句, 执行break,整体switch结束
-
switch语句中的变量的数据类型有限制
- byte short int char (JDK1.0-1.4)
- 添加数据类型 enum 枚举 (JDK1.5)
- 添加数据类型字符串 (JDK1.7)
- 使用的是JDK1.8 (支持的类型 byte short int char 枚举 字符串)
public static void main(String[] args) { int i = 5; switch (i) { case 1: System.out.println("case1"); break; case 2: System.out.println("case2"); break; case 3: System.out.println("case3"); break; default: System.out.println("所有case都不相等"); break; } }
选择语句的练习
需求 : 根据输入的月份,判断是哪个季节
春季 : 3,4,5 夏季 : 6,7,8 秋季 : 9 ,10 ,11 冬季 12 , 1, 2
采用if和switch分别完成
if(month < 1 || month > 12) {
System.out.println("输入的月份不存在");
}
//季节判断 春季 : 3,4,5
else if(month >=3 && month <=5) {
System.out.println("春季");
}
//季节判断 夏季 : 6,7,8
else if (month >= 6 && month <=8 ) {
System.out.println("夏季");
}
//季节判断 秋季 : 9 ,10 ,11
else if (month >= 9 && month <= 11) {
System.out.println("秋季");
}
//季节判断 冬季 12 , 1, 2
else {
System.out.println("冬季");
}
case穿透特性
在switch的语句中,不写break,出现case的穿透性
switch (变量){
case 常量1 :
要执行的语句1;
// break;
case 常量2 :
要执行的语句2;
// break;
case 常量3 :
要执行的语句3;
// break;
default:
要执行的语句;
// break;
}
case穿透.jpg
case穿透特性实现季节判断
public static void main(String[] args) {
//键盘输入,接收月份
Scanner sc = new Scanner(System.in);
int month = sc.nextInt(); // 4
//利用case穿透特性
switch(month) {
case 3:
case 4:
case 5:
System.out.println("春季");
break;
case 6:
case 7:
case 8:
System.out.println("夏季");
break;
case 9:
case 10:
case 11:
System.out.println("秋季");
break;
case 1:
case 2:
case 12:
System.out.println("冬季");
break;
default:
System.out.println("月份不存在");
}
}
循环语句
循环 : 程序中的语句(代码)多次的反复的执行
使用的频率非常的高
输出10次 "HelloWorld"
System.out.println("HelloWorld"); 语句复制10次,不行
while循环
语法格式 :
while(布尔类型的表达式){
//while的循环体
}
- while循环的执行流程
- 执行布尔表达式,如果是true
- 执行循环体中的程序
- 再次执行布尔表达式,如果还是true
- 再次执行循环体中的程序
- 再次执行布尔表达式,如果是false
- while循环就结束了
- 结论: 只要while中的布尔表达式结果是true,就执行循环体,直到布尔类型为false,循环结束
public static void main(String[] args) {
int i = 1;
while(i < 10) {
System.out.println("while的循环体 "+i);
//变量i 发生变化 ++
i++;
}
//打印10次HelloWorld
//j变化到10的时候,循环结束
int j = 0;
while(j < 10) {
System.out.println("HelloWorld");
j++;
}
}
while循环练习
-
输出10以内的所有偶数
public static void main(String[] args) { //定义变量,默认值是0, 变化到10 int i = 0; while(i <= 10) { //判断是不是偶数 if(i % 2 == 0) { System.out.println(i + "是偶数"); } i++; } }public static void main(String[] args) { //定义变量,默认值是0, 变化到10 int i = 0; //变量i在循环的时候,每次+2行不? 不需要判断了 while(i <= 10) { System.out.println(i + "是偶数"); //i=i+2; i+=2; } }
for循环
语法格式 :
for (初始化变量 ; 条件 ; 增量){
//for的循环主体
}
-
循环的三个部分解释
- 初始化变量 : 定义变量 数据类型 变量名 = 值
- 条件 : 条件必须是布尔类型结果 true 或者 false
- 增量 : 循环变量的变化
- 条件 : 控制循环是否执行,条件是true,循环,条件是false结束循环
public static void main(String[] args) { for(int i = 0 ; i < 5 ; i++) { System.out.println("这里是for循环的循环体 "+i); } } -
for循环的执行流程
- 执行初始化的变量. (只会执行一次)
- 执行条件的判断 (判断条件是false,循环直接结束), 判断条件是true
- 进入到for的循环体执行
- 执行变量的自增
- 执行条件的判断 (判断条件是false,循环直接结束), 判断条件是true
- 执行循环体
- 执行变量的自增
- 执行条件的判断 (判断条件是false,循环直接结束)
for循环实现练习
-
for循环实现0-10之间的偶数
public static void main(String[] args) { //利用for循环中的变量 for(int i = 0 ; i <= 10 ;i+=2) { System.out.println(i +"是偶数"); } } -
for实现求和计算 1 + 2 + 3 +......+ 100 = 5050 (高斯算法)
public static void main(String[] args) { //定义变量int类型,保存求和后的结果 int sum = 0; //进行1-100之间的循环 for(int i = 1 ; i <= 100 ;i++) { //求和计算, sum变量保存求和后的结果 sum = sum + i; } System.out.println(sum); }
do...while
格式 :
do{
//循环主体
}while(条件判断);
- 循环执行流程
- 判断while中的循环条件
- 如果条件是true,执行循环体
- 如果条件是false,结束循环
-
注意: do ... while 无条件先执行一次循环体
break和continue
-
break : 终止 作用就是终止循环, 在循环中遇到break,循环就结束,只能在循环中或者switch出现
public static void main(String[] args) { int i = 0; while(true) { i++; //判断变量的值,如果=10,执行break终止循环 if(i == 10) { break; } } for( ; ;) { break; } } -
continue : 终止本次循环,开始下一次循环
public static void main(String[] args) { for(int i = 0 ; i <=10 ;i++) { //判断,如果变量是偶数,执行下一次循环 if(i % 2 == 0) { continue; } System.out.println(i); } }
嵌套循环
引出 : 上体育课迟到20分钟,处罚
操场跑圈 : 跑5圈, 再跑5圈, 再跑5圈, 再跑5圈
跑了4组,每组跑了5圈, 一共跑了多少圈 20 组数*每组圈数
理解 : 第一组5圈...... 我的第一次循环 5圈 我的第二次循环 5圈 (围绕操场循环了5次)
一次大的循环,包含5次小的循环 : 程序 嵌套循环, 总的循环次数 = 大循环次数*小循环次数
嵌套for
两个for循环在一起,形成嵌套形式, 双循环
一个for是另一个for的循环体
格式 :
for(初始化变量 ; 条件 ; 增量){ //外循环
for(初始化变量 ; 条件 ; 增量){ //内循环
}
}
//内循环是外键循环的循环体
public static void main(String[] args) {
//外循环,循环5次
for(int i = 0 ; i < 5 ;i++) {
//内循环,循环3次
for(int j = 0; j < 3 ; j++) {
System.out.println("内循环");
}
System.out.println("外循环");
}
}
forfor循环的执行流程.JPG
嵌套for循环练习
-
外循环一次,内循环多次
- 结论 : 外循环控制行数 ,内循环控制每行的个数
public static void main(String[] args) { //外循环5次 for(int i = 0 ; i < 5 ;i++) { //内循环5次 for(int j = 0 ; j < 5 ;j++) { //内循环输出星号 System.out.print("*"); } //外循环输出空的换行 System.out.println(); } } -
尖向下的直角三角形
public static void main(String[] args) { // 有几个行 5行 外循环5次 for(int i = 0 ; i < 5; i++) { /* * 每个行有几个星号 第一行是5个,逐行递减 * 变量j 0 1 2 3 4 * * 外循环第一行的时候,内循环5个 * 外循环第二行的时候,内循环4个 * j变化 : 每次执行内循环的时候,变量j的初始化都+1 * * 外循环的i 变量 0 1 2 3 4 */ for(int j = i ; j < 5 ;j++) { System.out.print("*"); } System.out.println(); } } -
尖向上的直角三角形
public static void main(String[] args) { // 有几个行 5行 外循环5次 for(int i = 0 ; i < 5 ;i++) { /* * 内循环 : 循环次数不固定 每行递增效果 * 第一行 : 内循环1次 * 第二行 : 内循环2次 * 内循环的变量 j * * 第一行 : 内循环1次 j<1 * 第二行 : 内循环1次 j<2 * 内 : 变量j每次都从0开始,但是条件在改变 */ for(int j = 0 ; j <= i ;j++) { System.out.print("*"); } System.out.println(); } } -
乘法表
public static void main(String[] args) { //i 1-9 for(int i = 1 ; i <= 9 ;i++) { // 第一次循环1 ,第二次循环 1 2 for(int j = 1; j<=i ;j++) { /* * 替换为乘法计算即可 */ System.out.print(j+"*"+i+"="+j*i+"\t"); } System.out.println(); } }