副本-第一次

JAVA黑马

、、、java​
​
public class hello {
public static void main(String[] args) {
// 字符串常量
System.out.println(“程序员”);
System.out.println(“hello world！”);
System.out.println("=");
//整数常量
System.out.println(123);
System.out.println(-123);
System.out.println("=");
//小数常量
System.out.println(12.12);
System.out.println(-12);
//字符常量
System.out.println(‘A’);
System.out.println(‘我’);
//布尔常量
System.out.println(true);
System.out.println(false);
//空常量
//空常量不能直接输出的
//System.out.println(null);
}
}

常量

xxxxxxxxxx

public class hello {
public static void main(String[] args) {
/*变量定义格式：数据类型 变量名=变量值
基本数据类型：
byte,short,int,long,float,double,char,boolean
变量的使用
取值格式：变量名
修改格式：变量名=变量值
*/
int a=20;
System.out.println(a);
a=20;
System.out.println(a);
}
}

变量
注意事项：
1、名字不能重复使用
2、变量未赋值，不能使用
3、long类型的变量定义的时候，为了防止整数过大（一般都认为是int类型），后面要加L
4、float类型的变量定义的时候，为了防止类型不兼容（一般都认为是double类型），后面要加F

标识符
标识符定义规则：

• 有数字、字母、下划线(_)、和美元符($)组成
• 不能以数字开头
• 不能是关键字
• 区分大小写
  标识符命名法
  小驼峰命名法：方法、变量
• 约定1:标识符是一个单词的时候，首字母小写
• 范例1:name
• 约定2：标识符由多个单词组成的时候，第一个单词首字母小写，其他单词首字母大写
• 范例2:fristName
  大驼峰命名法：类
• 约定1:标识符是一个单词的时候，首字母大写
• 范例1:Student
• 约定2:标识符由多个单词组成的时候，每个单词的首字母大写
• 范例2:Good Student

类型转换
自动类型转换：
把一个表示数据范围小的数值或者变量赋值给另一个表示数据大的变量（从低到高）
范例：double=10;

强制类型转换：
把一个表示数据类型范围大的数值或者变量赋值给另一个表示数据范围小的变量（从高到低）

• 格式：目标数据类型 变量名=（目标数据类型）值或变量;
• 范例：int a=(int)88.88;
  算数运算符
  加减乘除+取余

xxxxxxxxxx

public class hello {
public static void main(String[] args) {
int a=6;
int b=4;
System.out.println(a+b);
System.out.println(a-b);
System.out.println(a/b);
System.out.println(a%b);
System.out.println(6.0/4);
}
}

字符的"+"操作

xxxxxxxxxx

public class hello {
public static void main(String[] args) {
//定义两个变量
int a=10;
char c=‘A’;//'A’的值是65
c=‘a’;//'a’的值是97
c=‘0’;//'0’的值是48
System.out.println(a+c);
​
//char ch=a+c;
//char类型会自动提升为int类型
int e=a+c;
System.out.println(e);
//int k=10+13.23;
double d=10+13.22;
System.out.println(d);
}
}

定义：
拿字符在计算机底层的对应数值来进行计算的

• ‘A’------>65 A-Z是连续的
• ‘a’------>97 a-z是连续的
• ‘0’------>48 0-9是连续的
  计算表达式中包含多个基本数据类型的值的时候，整个算数表达式的类型会自动提升
  提升规则：
• byte类型，short类型和char类型将被提升到int类型
• 整个表达式的类型自动提升到表达式中最高等级操作数同样的类型
• 等级顺序：byte, short,char–>int–>long–>float–>double
  字符串的+操作

xxxxxxxxxx

public class hello {
public static void main(String[] args) {
System.out.println(“it”+“kui”);
System.out.println(“it”+666);
System.out.println(666+“it”);
System.out.println(“it”+6+6);
System.out.println(6+6+“it”);
}
}

注意事项：

• 当“+”操作中出现字符串时，这个“+”是字符串连接符，而不是算术运算符
• “it”+666
• 在“+”操作中，如果出现了字符串，就是连接运算符，否则就是算术运算符，当连续进行“+”操作时，从左到右逐个执行。
• 1+88+“it”
  赋值运算符

xxxxxxxxxx

public class hello {
public static void main(String[] args) {
//把10赋值给int类型的变量
int i=10;
System.out.println(“i:”+i);
​
//+=把左边和右边的数据做加法操作，结果赋值给左边
i +=20;
//i=i+20;
System.out.println(“i:”+i);
​
//注意：拓展的赋值运算符底层隐含了强制类型转换
short a=10;
a+=20;
// a=(short)(a+20);
System.out.println(“a:”+a);

}

}

自增自减运算符
符号｜作用｜说明
++｜自增｜变量的值加1
–｜自减｜变量的值减1

xxxxxxxxxx

public class hello {
public static void main(String[] args) {
//定义变量
int i=10;
System.out.println(“i:”+i);
//单独使用
i++;
++i;
System.out.println(“i:”+i);
//参与操作使用
//int l=i++;
int l=++i;
System.out.println(“i:”+i);
System.out.println(“l:”+l);
}
}

注意事项：

• ++和–既可以放在变量的后面，也可以放在变量的前面。
• 单独的使用的时候，++和–无论是放在变量的前边还是后边，结果是一样的。
• 参与操作的时候，如果放在变量的后面，先拿变量参与操作，后拿变量做++或者–。
• 参与操作的时候，如果放在变量的前面，先拿变量做++或者–，后拿变量参与操作
• 最常用的用法：单独使用
  关系运算符

xxxxxxxxxx

public class hello {
public static void main(String[] args) {
int i=10;
int a=20;
int c=10;
//==
System.out.println(ic);
System.out.println(ia);
System.out.println("");
//>=
System.out.println(i>=c);
System.out.println(i>=a);
System.out.println("");
//!=
System.out.println(i!=c);
System.out.println(i!=a);
System.out.println("");
//>
System.out.println(i>a);
System.out.println(i>c);
System.out.println("");
//不小心把==写成=
//等于把c的值赋值给了i，然后输出i
System.out.println(i=a);
}
}

注意事项：

• 关系运算符的结果都是boolean类型，要么是true，要么是false
• 千万不要把“==”误写成“=”
  逻辑运算符

xxxxxxxxxx

public class hello {
public static void main(String[] args) {
//定义变量
int a = 10;
int b = 20;
int c = 30;
//& 有false则false
System.out.println((a > b) & (a > c));//false&false
System.out.println((a < b) & (a > c));//ture&false
System.out.println((a > b) & (a < c));//false&ture
System.out.println((a < b) & (a < c));//ture&ture
System.out.println("=");
//! 有ture则ture
System.out.println((a > b) | (a > c));//false|false
System.out.println((a < b) | (a > c));//ture|false
System.out.println((a > b) | (a < c));//false|ture
System.out.println((a < b) | (a < c));//ture|ture
System.out.println("=");
//^ 相同为false不同为ture
System.out.println((a > b) ^ (a > c));//false^false
System.out.println((a < b) ^ (a > c));//ture^false
System.out.println((a > b) ^ (a < c));//false^ture
System.out.println((a < b) ^ (a < c));//ture^ture
System.out.println("===========");
//!
System.out.println((a > b));//false
System.out.println(!(a > b));//false
System.out.println(!!(a>b));//false
System.out.println(!!!(a>b));//false
}
}

短路逻辑运算符

xxxxxxxxxx

public class hello {
public static void main(String[] args) {
//定义变量
int a = 10;
int b = 20;
int c = 30;
//& 有false则false
System.out.println((a > b) && (a > c));//false&&false
System.out.println((a < b) && (a > c));//ture&&false
System.out.println((a > b) && (a < c));//false&&ture
System.out.println((a < b) && (a < c));//ture&&ture
System.out.println("=");
//｜ 有ture则ture
System.out.println((a > b) || (a > c));//false||false
System.out.println((a < b) ||(a > c));//ture||false
System.out.println((a > b) || (a < c));//false||ture
System.out.println((a < b)|| (a < c));//ture||ture
System.out.println("=");
//&&和&
System.out.println((a++>100)&&(b++>100));
//System.out.println((a++>100)&(b++>100));
System.out.println(“a:”+a);
System.out.println(“b:”+b);
}
}

注意事项：

• 逻辑与：&，无论左边真假，右边都要执行
  短路与：&&，如果左边为真，右边执行；如果左边为假，右边不执行。
• 逻辑或：|，无论左边真假，右边都要执行
  短路或：||，如果左边为假，右边执行；如果左边为真，右边不执行。
• 常用的逻辑运算符：&&、｜｜、！
  三元运算符
  public class hello {
  public static void main(String[] args) {
  int a = 10;
  int b = 20;
  int max = a>b?a:b;
  System.out.println(“max:”+max);
  }
  }
  格式：
  关系表达式？表达式1：表达式2;
  范例：
  a>b?a:b;
  执行流程：
  首先计算关系表达式的值
  如果值为ture，表达式为1的值就是运算结果
  如果值为false，表达式为2的值就是运算结果
  两只老虎

xxxxxxxxxx

public class hello {
public static void main(String[] args) {
int a = 10;
int b = 20;
boolean c = a==b?true:false;
System.out.println(“c:”+c);
}
}

三个和尚比身高

xxxxxxxxxx

public class hello {
public static void main(String[] args) {
int height1=150;
int height2=210;
int height3=165;
int tempHeight = height1>height2?height1:height2;
int maxHeight = tempHeight>height3?tempHeight:height3;
System.out.println(“maxHeight:”+maxHeight);
}
}

三个和尚进阶

xxxxxxxxxx

import java.util.Scanner;
public class hello {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println(“请输入第一个和尚的身高：”);
int height1 = sc.nextInt();
System.out.println(“请输入第二个和尚的身高：”);
int height2 = sc.nextInt();
System.out.println(“请输入第三个和尚的身高：”);
int height3 = sc.nextInt();
​
int tempHeight=height1>height2?height1:height2;
int maxHeight=tempHeight>height3?tempHeight:height3;
​
System.out.println(“这三个和尚中最高的身高是：”+maxHeight+“cm”);
}
}

分支语句
if语句

xxxxxxxxxx

public class hello {
public static void main(String[] args) {
System.out.println(“开始”);
int a =10;
int b =20;
if(ab){
System.out.println(“A等于B”);
}
int c =10;
if(ac){
System.out.println(“A等于C”);
}
System.out.println(“结束”);
}
}

if语句格式1
格式：
if（关系表达式）{
语句体;
}
执行流程：
1、首先计算关系表达式的值
2、如果关系表达式的值为true就执行语句体
3、如果关系表达式的值为false就不执行语句体
4、继续执行后面的语句体
if语句格式2 if,else
public class hello {
public static void main(String[] args) {
System.out.println(“开始”);
int a =10;
int b =20;
if(ab){
System.out.println(“A等于B”);
}else{
System.out.println(“A<B”);
}
int c =10;
if(ac){
System.out.println(“A等于C”);
}
System.out.println(“结束”);
}
}
奇偶数
import java.util.Scanner;
public class hello {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println(“请输入一个整数：”);
int number = sc.nextInt();
if(number%2==0){
System.out.println(number+“是偶数”);
}else{
System.out.println(number+“是奇数”);
}
}
}
if语句格式3

xxxxxxxxxx

import java.util.Scanner;
public class hello {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println(“请输入一个星期数（1-7）：”);
int week = sc.nextInt();
if(week1){
System.out.println(“星期一”);
}else if(week2){
System.out.println(“星期二”);
}
else if(week3){
System.out.println(“星期三”);
}
else if(week4){
System.out.println(“星期四”);
}
else if(week5){
System.out.println(“星期五”);
}
else if(week6){
System.out.println(“星期六”);
}else{
System.out.println(“星期天”);
}
System.out.println(“结束”);
}
}

奖励案例

xxxxxxxxxx

import java.util.Scanner;
public class hello {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println(“请输入一个分数：”);
int score = sc.nextInt();
if(score>100||score<0){
System.out.println(“你输入的分数有误”);
}else if(score>=90&&score<=100){
System.out.println(“山地自行车一辆”);
}
else if(score>=80&&score<=89){
System.out.println(“游乐场玩一次”);
}
else if(score>=70&&score<=79){
System.out.println(“变形金刚一个”);
}else{
System.out.println(“胖揍一顿”);
}
System.out.println(“结束”);
}
}

注意事项：正确数据、边界数据、错误数据
switch

xxxxxxxxxx

import java.util.Scanner;
public class hello {
public static void main(String[] args) {
System.out.println(“开始”);
Scanner sc=new Scanner(System.in);
System.out.println(“请输入一个星期（1-7）：”);
int week = sc.nextInt();
switch(week){
case 1:
System.out.println(“星期一” );
break;
case 2:
System.out.println(“星期二” );
break;
case 3:
System.out.println(“星期三” );
break;
case 4:
System.out.println(“星期四” );
break;
case 5:
System.out.println(“星期五” );
break;
case 6:
System.out.println(“星期六” );
break;
case 7:
System.out.println(“星期日” );
break;
default:
System.out.println(“你输入的星期数有误”);
break;
}
System.out.println(“结束”);
}
}

case穿透

xxxxxxxxxx

import java.util.Scanner;
public class hello {
public static void main(String[] args) {
System.out.println(“开始”);
Scanner sc=new Scanner(System.in);
System.out.println(“请输入一个月份（1-2）：”);
int month = sc.nextInt();
switch (month){
case 1:
case 2:
case 12:
System.out.println(“冬季”);
break;
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;
default:
System.out.println(“你输入的月份有误！”);
}
System.out.println(“结束”);
}
}

注意事项：在switch语句中，如果case控制的语句体后面不写break，将出现穿透现象，在不判断下一个case值的情况下，向下运行，直到遇到break，或者整体switch语句结束。

循环语句
for循环
public class hello {
public static void main(String[] args) {
for(int i=1;i<=5;i++){
System.out.println(“hello world1”);
}
}
}
格式：
for(初始化语句;条件判断语句;条件控制语句){
循环体语句;
}
执行流程：
1、执行初始化语句
2、执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
3、执行循环体语句
4、执行条件控制语句
5、回到2执行
输出数据
public class hello {
public static void main(String[] args) {
for(int i=1;i<=5;i++){
System.out.println(i);
}
for(int i=5;i>=1;i–){
System.out.println(i);
}
}
}
范例
public class hello {
public static void main(String[] args) {
int sum=0;
for(int i=1;i<=100;i++){
if(i%2==0){
sum +=i;}
}
System.out.println(“1-100之间的数据偶数和为：”+sum);
}
}
水仙花数

xxxxxxxxxx

public class hello {
public static void main(String[] args) {
for(int i =100; i<1000; i++){
int a =i%10;
int b =i/10%10;
int c =i/10/10%10;
if(aaa+bbb+ccc==i){
System.out.println(i);
}
}
}
}

统计

xxxxxxxxxx

public class hello {
public static void main(String[] args) {
int count=0;
for(int i =100; i<1000; i++){
int a =i%10;
int b =i/10%10;
int c =i/10/10%10;
if(aaa+bbb+ccc==i){
count++;
}
}
System.out.println(“水仙花共有：”+count+“个”);
}
}

while循环

xxxxxxxxxx

public class hello {
public static void main(String[] args) {
int i=1;
while(i<=5){
System.out.println(“hello world”);
i++;
}
}
}

基本格式：
whil(条件判断语句){
循环体语句;
}
完整格式：
初始化语句;
while(条件判断语句){
循环体语句;
条件控制语句;
}
执行流程：
1、执行初始化语句
2、执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
3、执行循环体语句
4、执行条件控制语句
5、回到2继续
范例

xxxxxxxxxx

public class hello {
public static void main(String[] args) {
int count=0;
double paper =0.1;
int zf =8844430;
while(paper<=zf){
paper *=2;
count++;
}
System.out.println(“需要折叠”+count+“次”);
}
}

do …while循环

xxxxxxxxxx

public class hello {
public static void main(String[] args) {
int i=1;
do{
System.out.println(“hello world!”);
i++;
}while(i<=5);
}
}

三种循环的区别

• for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
• do…while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）
  for和while的区别
• 条件控制语句所控制的自增变量，因为归属于for循环的语法结构中，在for循环结束后，就不能再次被访问
• 条件控制语句所控制的自增变量，对于while循环来说不归属于语法结构中，在while循环结束后，该变量还可以继续使用
  死循环格式
• For(;😉{}
• While(true){} 一般使用这个
• do{}while(true);
  素数

xxxxxxxxxx

public class hello {
public static void main(String[] args) {
boolean flag=true;
for (int i=2;i<=100;i++){
for(int j=2;j<i-1;j++) {
if(i%j==0){
flag=false;
break;
}
}
if(flag){
System.out.println(i);
}else {
flag=true;
}
}
}
}

跳转语句

xxxxxxxxxx

public class hello {
public static void main(String[] args) {
for(int i=1;i<=5;i++){
if(i%2==0){
//continue;
break;
}
System.out.println(i);
}
}
}

continue:用在循环中，基于条件控制，跳过某次循环体内容的执行，继续下一次的执行
break:在循环中，基于条件控制，种植循环体内容的执行，也就是说结束当前的整个循环
嵌套循环
外循环控制小时范围，内循环控制分钟的范围

xxxxxxxxxx

public class hello {
public static void main(String[] args) {
for(int hour=0;hour<24;hour++){
for(int minute=0;minute<60;minute++){
System.out.println(hour+“时”+minute+“分”);
}
System.out.println("--------");
}
}
}

随机数Random

xxxxxxxxxx

import java.util.Random;
public class hello {
public static void main(String[] args) {
Random r=new Random();
for(int i=0;i<10;i++){
int number = r.nextInt(10);
System.out.println(“number:”+number);
}
int X= r.nextInt(100)+1;
System.out.println(X);
​
}
}