java基本语法

1.标识符

标识符的使用：

凡是自己可以起名字的地方都叫标识符。

比如：类名、变量名、方法名、接口名、包名....

标识符的命名规则：

• 由26个英文字母大小写，0-9，_或者$组成

• 数字不可以开头

• 不可以使用关键字和保留字，但能包含关键字和保留字

• java中严格区分大小写，长度无限制

• 标识符不能包含空格

java中的名称命名规范

• 包名：多单词组成时，所有字母都小写：xxxyyyzzz

• 类名、接口名：多单词组成时，所有单词的首字母有大写：XxxYyyZzz

• 变量名、方法名：多单词组成时，第一个字母首字母小写第二个单词开始每个单词首字母大写：xxxYyyZzz

• 常量名：所有字母都大写，多个单词组成时每个单词用下划线连接：XXX_YYY_ZZZ

2.变量

变量的使用：

1. java定义变量的格式：数据类型 变量名 =变量值；

   //变量的定义
   int age=12;
   //变量的声明
   int number;
   //变量的赋值
   number=200;

2. 说明：

   • 变量必须先声明，再使用

   • 变量都定义在其作用域内，超出作用域变量失效

   • 同一个作用域内，不可以声明两个同名的变量

3.基本数据类型

一、按照数据类型划分

基本数据类型：

整型：byte \ short \ int \ long

浮点型：float \ double

字符型：char

布尔型：boolean

引用数据类型：

类（class）

接口（interface）

数组（array）

二、按照在类中声明的位置划分

成员变量 \ 局部变量

1.整型：byte（1字节=8bit） \ short（2字节） \ int（4字节） \ long（8字节）

• byte范围：-128 ~ 127

  byte b1=12;
  byte b2=-128;
  b2=128;//编译不通过

• 声明long型变量，必须以“l”或“L”结尾

• 通常，定义整型变量时使用int型

  short s1=128;
  int i1=1234;
  long l1=283938474940l;

  2.浮点型：float（4字节） \ double（8字节）

• 浮点型，表示带小数点的数值

• float表示数值的范围比long大

• 定义float类型变量时，变量要以“f”或“F”结尾

• 通常，定义浮点型变量时，使用double型

  double d1=123.1;
  float f1=12.3f;

  3.字符型：char(1字符=2字节)

• 定义char类型变量，通常使用一对' '，内部只能写一个字符

  char c1='a';
  char c2='ab';//编译不通过
  char c3='1';
  char c4='中';

• 表示方式：1.声明一个字符 2.转义字符 3.直接使用unicode值来表示字符型常量

  char c5='\n';//换行符
  char c6='\t';//制表符
  System.out.print("hello"+c5);
  System.out.print("world"+c5);
  /**输出效果
    hello
    world*/
  char c7='\u0043';//使用unicode值
  //输出结果  C

  

  4.布尔型：boolean

• 只能取两个值之一：1.true 2.false

  boolean bb1=true;

• 常常在条件判断、循环结构中使用

  boolean isMarried=true;
  if(isMarried){
    System.out.println("你就不能参加单身party了，很遗憾！");
  }else{
    System.out.println("你可以多谈谈女朋友！");
  }

  三、基本数据类型之间的运算规则

  前提：布尔型：boolean不包含在内。

  1.自动类型提升：

  结论：当容量小的数据类型变量与容量大的数据类型变量做运算时，结果自动提升为容量大的数据类型。

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

  注意：当byte、char、short做运算时，结果是int型

  byte b1=2;
  int i1=129;
  //编译不通过
  //byte b2=b1+i1;
  int i2=b1+i1;
  long l1=b1+i1;
  System.out.println(i2);//131
  
  float f=b1+i1;
  System.out.println(f);//131.0
  
  short s1=123;
  double d1=s1;
  System.out.println(d1);//123.0
  *************************************
  char c1='a';//97
  int i3=10;
  int i4=c1+i3;
  System.out.println(i4);//107
  
  short s2=10;
  //char c2=c1+s2;//编译不通过
  
  byte b2=10;
  //char c3=b2+c1;//编译不通过
  
  //short s4=b1+b2;//编译不通过

  2.强制类型转换：自动类型提升运算的逆运算。

• 需要使用强转符：（）

• 注意点：强制类型转换，可能导致精度损失。

  double d1=12.9;
  //精度损失举例1
  int i1=(int)d1;//截断操作
  System.out.println(i1);//12
  
  //没有精度损失
  long l1=123;
  short s2=(short)l1;
  //精度损失举例2
  int i2=128；
  byte b=(byte)i2;
  System.out.println(b);//-128

  四、String类型变量的使用

  1.String属于引用数据类型，翻译为：字符串

  2.声明String类型变量时，使用一对“ ”

  3.String可以和8中数据类型变量做运算，且运算只能是连接运算：+

  4.运算结果仍然是String类型

  String s1="a";
  String s1=" ";
  ****************************
  int number=12;
  String str="学号：";
  String info=number+str;//+：连接运算
  System.out.println(info);//学号：12
  boolean b1=true;
  String info1=info+b1;//+：连接运算

  练习题1：

  char c='a';
  int num=10;
  String str="hello";
  System.out.println(c+num+str);//107hello
  System.out.println(c+str+num);//ahello10
  System.out.println(c+(num+str));//a10hello
  System.out.println((c+num)+str);//107hello
  System.out.println(str+num+c);//hello10a  

  练习题2：

  //输出*  *
  System.out.println("*  *");
  System.out.println('*'+'\t' +'*');//93
  System.out.println('*'+"\t" +'*');
  System.out.println('*'+'\t' +"*");//51*
  System.out.println('*'+('\t' +"*"));

  4.运算符

  一、算数运算符

  +、-、*、/、%（前）++、（后）++、（前）--、（后）--

• 取余运算：结果的符号与模数符号相同

• 开发中，经常使用%来判断能否被除尽的情况

• (前)++:先自增1，然后再运算

• (后)++：先运算，后自增1

• (前)--：先自减1，然后再运算

• (后)--：先运算，后自减1

  // /:除法运算
  int num1=12;
  int num2=5;
  int result=num1/num2;
  System.out.println(result);//2
  
  int result2=num1/num2*num2;
  System.out.println(result2);//10
  
  double result3=num1/num2;
  System.out.println(result3);//2.0
  
  double result4=num1/num2+0.0;//2.0
  double result5=num1/(num2+0.0);//2.4
  double result6=(double)num1/mum2;//2.4
  double result7=(double)(num1/num2);//2.0
  
  ****************************************
    
   //%:取余运算
  int m1=12;
  int n1=5;
  System.out.println(m1%n1);
  
  int m1=-12;
  int n1=5;
  System.out.println(m1%n1);
  
  int m1=12;
  int n1=-5;
  System.out.println(m1%n1);
  
  int m1=-12;
  int n1=-5;
  System.out.println(m1%n1);
  
  *********************************
    
   //(前)++
   //(后)++
  int a1=10;
  int b1=++a1;
  System.out.println(a1 b1);//a1=11,b1=11
  
  int a2=10;
  int b2=a2++;
  System.out.println(a2 b2);//a2=11,b2=10
  
  int a3=10;
  ++a3;
  int b3=a3;//a3=11,b3=11
  
  //注意点：
  short s1=10;
  //s1=s1+1;//编译失败，1为int型
  //s1=(short)(s1+1);//编译成功
  s1++;//自增1不会改变变量本身的数据类型
  
  *****************************************
   
   //(前)--
   //(后)--
  int a4=10;
  int b4=--a4;
  System.out.println(a4 b4); // a4=9,b4=9
  
  int a4=10;
  int b4=a4--;
  System.out.println(a4 b4); // a4=9,b4=10

  练习题：随意给出一个三位数整数，打印显示它的个位数，十位数，百位数的值。

  例如：数字153的情况下：

  个位数：3

  十位数：5

  百位数：1

  int num=153;
  int bai=num/100;
  int shi=num%100/10;//int shi=num/10%10;
  int ge=num%10;
  System.out.println("百位为："+bai);
  System.out.println("十位为："+shi);
  System.out.println("个位为："+ge);

  二、赋值运算符

  =、+=、-=、*=、/=、%=

  //赋值符号：=
  int j1=10;
  int i1=10;
  
  int i2,j2;
  //连续赋值
  i2=j2=10;
  int i3=10,j3=20;
  
  ************************
    
  int num1=10;
  num1+=2;//num1=num1+2;
  System.out.println(num1);//12
  
  int num2=12;
  num2%=5;//num2=num2%5;
  System.out.println(num2);//2
  
  short s1=10;
  s1+=2;//不会改变变量本身的数据类型
  System.out.println(s1);//12

• 开发中，如果希望实现+2操作，有几种方法？(前提：int num=10;)

  //方式一：num=num+2;
  //方式二：num+=2;

• 开发中，如果希望实现+1操作，有几种方法？(前提：int num=10;)

  //方式一：num=num+1;
  //方式二：num+=1;
  //方式三：num++;

  练习1：

  int i=1;
  i*=0.1;
  System.out.println(i);//0
  i++;
  System.out.println(i);//1

  练习2：

  int m=2;
  int n=3;
  n*=m++;//n=n*m++;
  System.out.println(m);//3
  System.out.println(n);//6

  练习3：

  int n=10;
  n+=(n++)+(++n);//n=n+(n++)+(++n);
  System.out.println(n);//32

  三、比较运算符

  ==、！=、<、>、<=、>=、instanceof

• 比较运算符的结果是boolean类型

  int i=10;
  int j=20;
  System.out.println(i==j);//false
  System.out.println(i=j);//20
  
  boolean b1=true;
  boolean b2=false;
  System.out.println(b1==b2);//false
  System.out.println(b2=b1);//true

  四、逻辑运算符

  &、|、！、&&、||、^

  

• 逻辑运算符操作的都是boolean型变量

• 区分&与&&

  boolean b1=false;
  int num1=10;
  if(b1&(num1++>0)){
    System.out.println("我现在在北京");
  }else{
     System.out.println("我现在在南京");
  }
   System.out.println(num1);//11
  
  boolean b2=false;
  int num2=10;
  if(b2&&(num2++>0)){
    System.out.println("我现在在北京");
  }else{
     System.out.println("我现在在南京");
  }
   System.out.println(num2);//10

  相同点：1.&与&&的运算结果相同

  2.当符号左边为true时，二者都会执行符号右边的运算

  不同点：当符号左边为false时，&会继续执行符号右边的运算，&&不再执行符号右边的运算

  开发中，推荐使用&&

• 区分|与||

  boolean b3=true;
  int num3=10;
  if(b3|(num3++>0)){
    System.out.println("我现在在北京");
  }else{
     System.out.println("我现在在南京");
  }
   System.out.println(num3);//11
  
  boolean b4=true;
  int num4=10;
  if(b4||(num4++>0)){
    System.out.println("我现在在北京");
  }else{
     System.out.println("我现在在南京");
  }
   System.out.println(num4);//10

  相同点：1.|与||的运算结果相同

  2.当符号左边为false时，二者都会执行符号右边的运算

  不同点：当符号左边为true时，|会继续执行符号右边的运算，||不再执行符号右边的运算

  开发中，推荐使用||

  五、位运算符

  <<、>>、>>>、&、|、^、~

  

• 位运算符操作的都是整型数据

• <<：在一定范围内，每向左移1位，相当于*2；>>:在一定范围内，每向右移1位，相当于/2

面试题：最高效方式的计算2*8？

2<<3或8<<1

练习：交换两个变量的值

int num1=10;
int num2=20;
//方式一：定义临时变量的方式
int temp=num1;
num1=num2;
num1=temp;
//方式二：
num1=num1+num2;
num2=num1-num2;
num1=num1-num2;
//方式三：使用位运算符
num1=num1^num2;
num2=num1^num2;
num1=num1^num2;

六、三元运算符

• 结构：（条件表达式）？表达式1：表达式2

• 条件表达式的结果为boolean类型

• 根据条件表达式真或假，决定执行表达式1，还是表达式2

• 如果表达式为true，执行表达式1

• 如果表达式为false，执行表达式2

• 表达式1和表达式2要求是一致的

• 三元运算符可以嵌套使用

• 凡是可以使用三元运算符的地方，都可以改写为if-else，反之不成立

• 如果程序既可以使用三元运算符，又可以使用if-else，那么选择三元运算符。

//获取两个整数的较大值
int m=12;
int n=5;
int max=(m>n)?m:n;
 System.out.println(max);

double num=(m>n)?2:1.0;
//(m>n)?2:"n大";//编译错误

******************************
  
 String maxStr=(m>n)?"m大":"n大";
 System.out.println( maxStr);

*******************************
  
 //获取三个数的最大值
int n1=12;
int n2=30;
int n3=-31;
int max1=(n1>n2)?n1:n2;
int max2=(max1>n3)?max1:n3;
 System.out.println( max2);
int max3=(((n1>n2)?n1:n2)>n3)?((n1>n2)?n1:n2):n3;
 System.out.println( max3);

5.程序流程控制

• 顺序结构

• 分支结构

• 循环结构

一、分支结构

1.if-else结构

if-else三种结构：

• 第一种：

  if（条件表达式）{

  执行表达式

  }

int age=14;
if(age>18){
  System.out.println("你可以喝酒了");
}
System.out.println("你还太小，不能喝酒");

• 第二种：

if（条件表达式）{

执行表达式1

}else{

执行表达式2

}

int age=14;
if(age>18){
  System.out.println("你可以看成人电影了");
}else{
  System.out.println("你只能看动画片");
}

• 第三种：

  if（条件表达式）{

  执行表达式1

  }else{

  执行表达式2

  }else{

  执行表达式3

}

.......

else{

执行表达式n

}

if(age<0){
  System.out.println("你输入的数据非法");
}else if(age<18){
  System.out.println("青少年时期");
}else if(age<35){
  System.out.println("青壮年时期");
}else if(age<60){
  System.out.println("中年时期");
}else{
  System.out.println("老年时期");
}

如何从键盘获取不同类型的变量：需要使用Scanner类

具体实现步骤：

1.导包：import java.util.Scanner；

2.Scanner的实例化：Scanner scan=new Scanner(System.in)；

3.调用Scanner类的相关方法，来获取指定类型的变量

Scanner scan=new Scanner(System.in);
int num=scan.nextInt();
System.out.println(num);

Scanner scan=new Scanner(System.in);
String name=scan.next();
System.out.println(name);

练习1：

小黑打算买车： 如果他有500万就卖劳斯莱斯 如果他有200万就买马萨拉蒂；如果他有100万就买宝马；如果他有50万卡迪拉克；如果他有10万就买比亚迪； 如果他有5万就买五菱宏光；否则就扫个共享单车

• 说明：else结构是可选的

• 针对于条件表达式：

  • 如果多个条件表达式之间是“互斥”关系（或没有交集的关系），哪个判断和执行语句声明在上面还是下面，无所谓

  • 如果多个条件表达式之间有交集关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面

  • 如果多个条件表达式之间有包含关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会执行了

import java.util.Scanner;

public class Text2 {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        System.out.println("请输入你的钱数");
        int num=input.nextInt();
        if (num>=500){
            System.out.println("劳斯莱斯一辆");
        }else if (num>=200){
            System.out.println("玛莎拉蒂一辆");
        }else if (num>=100){
            System.out.println("宝马一辆");
        }else if (num>=50){
            System.out.println("凯迪拉克一辆");
        }else if (num>=10){
            System.out.println("比亚迪一辆");
        }else if (num>=5){
            System.out.println("五菱宏光一辆");
        }else {
            System.out.println("扫个共享单车");
        }
    }
}

练习2：

我家狗5岁了，5岁的狗相当于人类多大呢？其实，狗的前两年每一年相当于人类的10.5岁，之后每增加一年就增加四岁。那么5岁的狗相当于人类多少岁？10.5+10.5+4+4+4=33

int age=5;
if(age>=0&& age<=2){
  System.out.println("相当于人的年龄"+age*10.5);
}else if(age>2){
  System.out.println("相当于人的年龄"+(2*10.5+(age-2)*4));
}

练习3：如何获取一个随机数：10-99

• 公式L[a,b] : ( int )( Math.random() * (b - a + 1 ) + a )

int value=(int)(Math.random()*90+10);

2.switch-case结构

格式：

switch(表达式){

case 常量1：

执行语句1；

//break；

case 常量2：

执行语句2；

//break；

.......

default;

执行语句n；

//break；

}

• 说明

  • 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。当调用完执行语句后，仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构末尾结束为止。

  • break，可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构

  • switch结构中的表达式，只能是如下的6种数据类型之一：byte、short、int、char、枚举类型（JDK5.0新增）、String类型（JDK7.0新增）

  • case之后只声明常量，不能声明范围

  • break关键字是可选的

  • dafault：相当于if-else结构中的else，default结构之可选的，而且位置是灵活的。

• 凡是可以使用switch-case的结构，都可以转换为if-else，反之，不成立。

• 我们写分支结构时，当发现既可以使用switch-case，（同时switch中表达式的取值情况不太多），又可以使用if-else时，我们优先选择使用switch-case。原因：switch-case执行效率稍高。

int num=2;
switch(num){
  case 0:
    System.out.println("zero");
    break;
   case 1:
    System.out.println("one");
     break;
   case 2:
    System.out.println("two");
     break;
  default:
     System.out.println("other");
}

练习1：

使用switch实现输出学生的评分等级，A：100，B:99-90,C:89-80,D:79-70,E:69-60,F:60以下

import java.util.Scanner;

public class Text4 {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        System.out.println("请输入你的成绩");
        int score=input.nextInt();
        switch (score/10){
            case 10:
                System.out.println("A");
                break;
            case 9:
                System.out.println("B");
                break;
            case 8:
                System.out.println("C");
                break;
            case 7:
                System.out.println("D");
                break;
            case 6:
                System.out.println("E");
                break;
            default:
                System.out.println("F");
                break;
        }
    }
}

练习2：

从键盘输入2019年的“momth”和“day“，要求通过程序输出输入的日期为2019年的第几天

Scanner input=new Scanner(System.in);
 System.out.println("请输入2019年的month");
int month=input.nextInt();
 System.out.println("请输入2019年的day");
int day=input.nextInt();
int sumDays=0;
switch(month){
  case 12:
     sumDays+=30;
  case 11:
     sumDays+=31;
  case 10:
     sumDays+=30;
  case 9:
     sumDays+=31;
  case 8:
     sumDays+=31;
  case 7:
     sumDays+=30;
  case 6:
     sumDays+=31;
  case 5:
     sumDays+=30;
  case 4:
     sumDays+=31;
  case 3:
     sumDays+=28;
  case 2:
     sumDays+=31;
  case 1:
    sumDays+=day;
}

练习3：

从键盘输入年、月、日，判断这一天是当年的第几天

注：判断一年是否是闰年的标准：

1）可以被4整除，但不可以被100整除

或

2）可以被400整除

Scanner input=new Scanner(System.in);
System.out.println("请输入year");
int year=input.nextInt();
 System.out.println("请输入month");
int month=input.nextInt();
 System.out.println("请输入day");
int day=input.nextInt();
int sumDays=0;
switch(month){
  case 12:
     sumDays+=30;
  case 11:
     sumDays+=31;
  case 10:
     sumDays+=30;
  case 9:
     sumDays+=31;
  case 8:
     sumDays+=31;
  case 7:
     sumDays+=30;
  case 6:
     sumDays+=31;
  case 5:
     sumDays+=30;
  case 4:
     sumDays+=31;
  case 3:
 if((year%4==0 &&year %100!=0)||year%400==0){
       sumDays+=29;
    }else{
       sumDays+=28;
       }
  case 2:
     sumDays+=31;
  case 1:
    sumDays+=day;
}

二、循环结构

1.for循环

• 循环结构的4个要素

①初始化条件

②循环条件 ------>是boolean类型

③循环体

④迭代条件

• for循环的结构

for(①；②；④){

③

}

• 执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ② - ③ - ④ - ...... -②

for(int i=1;i<=5;i++){
   System.out.println("hello");
}

 练习：

int num=1;
for(System.out.print('a');num<=3;System.out.print('c'),num++){
  System.out.print('b');
}
//输出结果：abcbcbc

练习2：遍历100以内的偶数,输出所有偶数的和,输出偶数的个数

int sum=0;
int count=0;
for(i=1;i<=100,i++){
  if(i%2==0){
    System.out.println(i);
    sum+=i;
    count++;
  }
}
System.out.println(sum);//2550
System.out.println(count);//50

练习2：编写程序1-150，并在每一行打印一个值，另外在每个3的倍数行上打印”foo“，在每个5的倍数行上打印”biz”，在每个7的倍数行上打印“baz”

for(i=1,i<=150;i++){
  System.out.print(i+" ");
  if(i%3==0){
    System.out.print("foo ");
  }
  if(i%5==0){
    System.out.print("biz ")
  }
  if(i%7==0){
    System.out.print("baz ")
  }
   System.out.println();//换行
}

练习3：输入两个正整数m和n，求其最大公约数和最小公倍数。

Scanner input=new Scanner(System.in);
 System.out.println("请输入第一个正整数：");
int m=input.nextInt();
System.out.println("请输入第二个正整数：");
int n=input.nextInt();
//获取最大公约数
int min=(m<=n)?m:n;
//遍历
for(i=min;i>=1;i--){
  if(m%i==0 && n%i==0){
    System.out.println("最大公约数为："+i);
    break;
  }
}
//获取最小公倍数
int max=(m>n)?m:n;
for(int i=max;i<=m*n;i++){
  if(i%m==0 && i%n==0){
    System.out.println("最小公倍数为："+i);
    break;
  }
}

2.while循环

• 循环结构的4个要素

①初始化条件

②循环条件 ------>是boolean类型

③循环体

④迭代条件

• while循环的结构

  ①

  while（②）{

  ③；

  ④；

  }

• 执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ..... -②

说明：

1.写while循环前往小心不要丢了迭代条件。一旦丢了，就可能导致死循环。

2.我们写程序要避免出现死循环。

3.for循环和while循环可以相互转换。

区别：for循环和while循环初始化条件作用范围不一样

//遍历100以内的所有偶数
int i=1;
while(i<=100){
  if(i%2==0){
     System.out.println(i);
	}
  i++;`
}

3.do-while循环

• 循环结构的4个要素

①初始化条件

②循环条件 ------>是boolean类型

③循环体

④迭代条件

• do-while循环结构：

①

do{

③；

④；

}while（②）；

• 执行过程：① - ③ - ④ - ② - ③ - ④ - ② - .... -②

说明：

1.do-while循环至少会执行一次循环体

2.开发中，while和for使用较多，do-while循环使用较少

//遍历100以内的偶数,输出所有偶数的和,输出偶数的个数
int i=1;
int sum=0;
int count=0;
do{
  if(i%2==0){
    System.out.println(i);
    sum+=i;
    count++;
  }
  i++;
}while(i<=100);
 System.out.println(sum);
 System.out.println(count);

练习：从键盘输入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。

说明：

1.不在循环条件部分限制次数的结构：for( ; ; )或while(true)

2.结束循环有几种方式？

方式一：循环条件部分返回false

方式二：在循环体中，执行break

Scanner input=new Scanner(System.in);
int zs=0;
int fs=0;
for( ; ; )//while(true){
  int number=input.nextInt();
  if(number>0){
    zs++;
  }else if(number<0){
    fs++;
  }else{
    break;
  }
}
 System.out.println("输入的正数个数"+zs);
System.out.println("输入的负数个数"+fs);

4.嵌套循环

• 嵌套循环：将一个循环结构声明在另一个循环结构的循环体中，就构成了嵌套循环

• 外层循环：循环结构B

• 内层循环：循环结构A

说明：

①内层循环遍历一遍，只相当于外层循环循环体执行了一次

②假设外层循环需要执行m次，内层循环需要执行n次，此时内层循环的循环体一共执行了m*n次

技巧：外层循环控制行数，内层循环控制列数

//输出******
for(int i=1;i<=6;i++){
  System.out.print("*");
}

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

/*     i(行数)   j(*的个数) 规律：i=j
*        1          1   
**       2          2
***      3          3
****     4          4
*****    5          5
*/
for(int i=1;i<=5;i++){
  for(int j=i;j<=i;j++){
    System.out.print("*");
  }
   System.out.println();
}

/*      i(行数)   j(*的个数) 规律：i+j=5  j=5-i;
****       1        4
***        2        3
**         3        2
*          4        1
*/
for(int i=1;i<=4;i++){
  for(int j=1;j<=5-i;j++){
      System.out.print("*");
  }
  System.out.println();
}

/*
*
**
***
****
*****
****      
***       
**         
*
*/

练习1：九九乘法表

for(i=1;i<=9;i++){
  for(j=1,j<=i,j++){
     System.out.print(i+"*"+j+"="+i*j+"\t");
  }
  System.out.println();
}

练习2：100以内的所有质数

质数：素数，只能被1和他本身整除的自然数

从2开始，到这个数-1结束为止，都不能被这个数本身整除

boolean isFlag=true;//表示i是否被j除尽过，一旦除尽，修改其值
for(int i=2;i<=100,i++){//遍历100以内的自然数
  for(int j=2;j<i;j++){//j:被i去除
    if(i%j==0){
       isFlag=false;
    }
  }
 if(isFlag==true) {
   System.out.println(i);
 }
  //重置isFlag
  isFlag=true;
}

优化代码

boolean isFlag=true;//表示i是否被j除尽过，一旦除尽，修改其值
//获取当前时间距离1970-01-01 00:00:00的毫秒数
long start=System.currentTimeMillis();
for(int i=2;i<=100,i++){//遍历100以内的自然数
  //优化二：对本身是质数的自然数是有效的
  for(int j=2;j<=Math.sqrt(i);j++){//j:被i去除
    if(i%j==0){
       isFlag=false;
      break;//优化一：只对本身非质数的自然数是有效的
    }
  }
 if(isFlag==true) {
   System.out.println(i);
 }
  //重置isFlag
  isFlag=true;
}
//获取当前时间距离1970-01-01 00:00:00的毫秒数
long end =System.currentTimeMillis();
 System.out.println("所花费的时间为"+(end-start));

练习3：一个数如果恰好等于它的因子之和，这个数就成为“完数”。例如6=1+2+3。

编程：找出1000以内的所有完数。（因子：除去这个数本身的其他约数）

//int factor=0;
for(int i=1;i<=1000;i++){
  int factor=0;
  for(int j=1;j<i;j++){
    if(i%j==0){
      factor+=j;
    }
  }
  if(i==factor){
    System.out.println(i);
  }
  //重置factor
  //factor=0;
}

5.特殊关键字的使用

break和continue关键字的使用

1、适用范围

break：switch-case循环中使用，结束当前循环

continue：循环结构中使用，结束当次循环

相同点：关键字后不能声明执行语句

for(int i=1;i<=10;i++){
  if(i%4==0){
    //break;//123
    continue;//123567910
  }
  System.out.print(i);
}

练习1：

label:for(int i=1;i<=4;i++){
  for(int j=1;j<=10;j++){
    if(j%4==0){
   //break;//默认跳出包裹此关键字最近的一层循环123
     // continue;//123567910
     //break label;//结束指定标识的一层循环结构
continue label;//结束指定标识的一层循环结构当次循环
    }
     System.out.print(i);
  }
   System.out.println();
}