Java 入门 2

最新推荐文章于 2024-07-14 22:18:32 发布

Mihusasa

最新推荐文章于 2024-07-14 22:18:32 发布

阅读量121

点赞数

文章标签： java

本文链接：https://blog.csdn.net/Mihusasa/article/details/120475946

版权

Java 入门 2

#位运算符

1.位运算符:针对多个数据进行操作(使用"补码"计算结果)

计算出来的结果是具体的数据值;

2.基本的位运算符:

位与&: 有0,则0 位或|: 有1,则1 位异或^:相同则为0,不同则为1 反码~: 按位取反,全部都0变1,1变0

位异或^的另一个特点: 一个数据被另一个数据位异或两次,其值是它本身

应用:(面试题)请有最有效的方式,实现两个数据交换!
(公式:左边a,b,a / 右边:a ^ b)
class Demo{
    public static void main(String[] args){
        //可以使用位异或的特点
        int a = 10 ;
        int b = 20 ;
        a = a ^ b ; // a = a ^ b 把这个表达式带到下面
        b = a ^ b ; // b = a ^ b ^ b-->b = a 
        a = a ^ b ; // a = a ^ b ^ a ,a=b
        
        System.out.println("a:"+a) ;//a:20
        System.out.println("b:"+b) ; //b:10

3.位移符号:(了解)

<<:左移将这个数据(补码)左移动,右边不够的补0,将左边多余的移动位数丢弃掉! >>:右移将这个数据(补码)向右移动指定的位数;如果最高符号位为0,左边补0; 如果最高符号位为1,左边补1;将右边的多余的数据丢弃掉; >>>:无符号右移无论最高符号位是1还是0,始终左边补0;(使用补码无符号右移)

结论:
        <<:
                将<<符号左边数据乘以2的移动次幂
        >>:
                将>>符号左边的数据除以2的移动次幂

#三元运算符

1.三元运算符又称:三目运算符;

二目运算符:
        int a = 1;
        int b = 2;
        a < b 的结果.

2.三元运算符的格式:

(表达式)?执行语句1(具体的结果):执行语句2(具体的结果);

3.执行的流程:

先判断表达式的结果是否成立,如果结果为true,就执行成立的语句1;

否则不成立,则执行不成立的语句2;

例:

/*
  1)定义两个变量,求两个变量中的最大值
  2)定义三个变量,求三个变量中的最大值
  3)定义两个变量,求两个变量是否相等  (boolean :true/false)
*/
class OperatorDemo{
    
    public static void main(String[] args){
        //定义两个变量
        int a = 30 ;
        int b = 20 ;
        
        //定义一个结果变量:max
        //(表达式)?执行语句1:执行语句2;
        int max = (a>b)?a:b; 
        //a大于b如果成立,那么就执行a的结果,否则就执行b的结果
        System.out.println("两个数据中的最大值是:"+max) ;
        
        System.out.println("------------------------------------") ;
        
        //2)定义三个变量,求三个变量中的最大值 (采用方式1实现)
        //方式1(分步实现): 可以使用中间变量的方式,先使用这个中间变量记录两个数据中的最大值,
        //然后在使用这个中间变量和第三个变量进行比较;
        
        //定义三个变量
        int x = 100 ;
        int y = 120 ;
        int z = 60 ;
        
        //定义一个中间变量:先记录x和y的最大值
        int temp = (x > y)? x : y ;
        //定义结果变量max2
        int max2 = (temp>z)? temp : z ;
        
        System.out.println("三个数据中的最大值是:"+max2) ;
        
        
        System.out.println("------------------------------------") ;
        
        //方式2:三元运算符的嵌套(不建议使用,如果没有带括号,层次不明显)
        int max3 = ( x > y)?((x>z)?x:y):((y>z)?y:z) ; //带了括号,结构很明显
        //int max3 =  x > y?x>z?x:y:y>z?y:z ; 
        System.out.println("三个数据中的最大值是:"+max3) ;
        
        System.out.println("----------------------------------") ;
        
        //定义两个变量,求两个变量是否相等
        
        int m = 50 ;
        int n = 55 ;
        
        //定义boolean类型变量接收
        boolean flag = (m==n)? true:false;
        System.out.println("flag:"+flag) ;
        
        //优化上面代码:==本身比较 :本身结果就是true/false
        
        boolean flag2 = (m==n) ;
        System.out.println("flag2:"+flag2) ;    
    }
}

#键盘录入数据

Jdk提供了一个Scanner:文本扫描器类, 可以提高程序灵活性,我们书写的变量可以直接使用Scanner类来键盘录入,不需要直接将变量写死!

1.使用步骤

1) 导包用哪个一类,就需要导入到当前Java文件中(只要不是java.lang包下的类,都需要导入)

固定写法:

import java.util.Scanner; //用谁导谁

书写位置:在class的上面

2) 固定格式:创建文本扫描器对象

Scanner 对象名 = new Scanner(System.in) ; //对象名:自己起名字

3) 提示并录入数据 (默认录入int类型)

System.out.println("请您输入数据:") ;

int 变量名= 对象名.nextInt() ; //录入一个int类型的数据

//String num = sc.nextLine() ;//录入字符串类型)

4) 完成自己的业务操作:使用这个变量名(求两个数据是否相等/比较数据最大值等等...)

#流程控制语句

流程控制语句的三个分类

顺序结构语句

选择结构语句

循环结构语句

1.顺序结构语句

当进入到类中之后,jvm调用main方法,代码由上而下依次加载除非一种特例:当jvm退出了就不会进行执行了! //后期System类中有一个功能:exit(int status) 参数里面为0,表示正常终止jvm

例:

class ShunXuDemo{
    
    public static void main(String[] args){ //程序的入口
        //定义变量
        int a = 10 ; //局部变量(在方法定义中的变量)
        System.out.println("a:"+a) ;
        System.out.println("程序开始") ;
        
        //让Jvm退出(正常终止正在运行的jvm),main方法就结束了
        System.exit(0) ;
        
        System.out.println("程序结束了...") ;
    
    }
}

2.选择结构语句

2.1 if语句

if 语句有三种格式

if语句格式1:

应用场景:针对一种情况判断   
    if(表达式){
           语句;
        }
        
执行流程: 
    1)首先表达式是否成立,成立,则执行该语句
    2)不成立,不会进入if里面;
    
if语句格式注意事项:

        1)有{括号的地方不能有分号;
        2)当前if(表达式){    
            语句 ;
            }
         //{}可以省略不写,但是开始学习不建议!

//局部代码块:主要的作用就是限定局部变量 "生命周期"

y的变量只能在{}内有效,超出这个范围,就无法访问

If语句格式2:

应用场景:发中使用最多,针对两种情况进行判断!
    
    if(表达式){
        语句1;
    }else{
        语句2;
    }
    
执行流程:
    1)先判断表达式是否成立,如果成立,执行执行语句1;
    2)如果不成立,则执行语句2;
        
    需求:键盘录入两个数据,比较两个数据是否相等

    //开发中 在业务中进行流程判断: if...else结构会经常用到
    举例:登录 ----->String类型  :字符串数据  equals(String str):
    比较两个字符串是否相等

if语句格式2和三元运算符有什么区别?

if是一个流程控制语句,不仅能够表示具体的结果,而且还可以一个输出语句体现;

但是三元运算符,一般情况:就是最终是具体的结果体现!
        
if范围大于三元;能够使用三元运算符实现的一定能够使用if格式2;反之,不一定!

if语句格式3 :

应用场景:针对多种情况进行判断
    
    if(表达式1){
        语句1 ;
    }else if(表达式2){
        语句2;
    }else if(表达式3){
        语句3;
        ...
        ...
        ...
    }else{
        语句n+1;
    }
    
执行流程:
    1)首先判断表达式1是否成立,如果成立,则执行语句1;
    2)如果上面表达式1不成立,继续判断表达式2是否成立,如果成立,执行语句2
    3)如果表达式2也不成立,继续判断表达式3是否成立,如果成立,执行语句3
        ...
        ...
    4)如果上面的条件表达式都不成立,则执行最终语句n+1 ;

2.2 switch语句

switch语句的格式:

switch(表达式){
            case 值1:
                语句1;
                break ;
                
            case 值2:
                语句2;
                break ;
            ...
            ...
            ...
            default:
                语句n+1 ;
                break ;
        }
        
执行流程:很类似于if格式3  
        1)switch中的表达式的结果值和case语句匹配,值1和结果匹配,
            就执行语句1,遇见break,switch结束;
        2)值1和switch表达式结果不匹配,继续判断值2是否匹配,如果匹配,就执行语句2,switch语句结束
        
        ...
        ...
        3)如果case语句后面值都不匹配,这个执行default语句,执行语句n+1,程序执行到末尾结束...
        
        
    break:属于跳转控制语句中的一种  
            结束,中断意思!(不能单独使用,只能在switch和/循环语句/中使用)

switch跟的表达式可以是什么数据类型? 能够跟的基本类型:int,byte,short,char Jdk版本不同的跟的类型不一样 JDK5以后,可以跟枚举: enum : 枚举类(引用类型,里面的都常量!) JDK5以后新特性 JDK7以后:可以跟String类型

Switch语句的注意事项:

1) case语句后面只能是常量(Java是一个强类型语言: 语法,结构非常严谨)

相对来说:前端:javascript :简称"js",Switch语句的case中不仅可以常量,也可以是变量

是一个弱类型语言(语法结构非常不严谨)

2)case语句中beark 最好携带上,如果没有携带break语句,会造成"case穿透"

"case穿透": (要灵活使用,并不是说这个情况不好)

某个case语句中没有带break,此时当跟case的值匹配,这个时候继续就往下执行,不会在判断case

3)default语句可以在switch语句中的任何位置,不会影响switch的执行流程

如果在语句中,

default里面的break千万不能省略;省略,造成case穿透(考点)

如果在语句末尾,break可以省略不写,前期不建议 4)switch语句的结束条件是什么?

a)遇见break结束

b)程序默认执行到末尾

3.循环结构语句

3.1 for循环语句

for循环语句的格式:

    for(初始化语句;条件表达式;步长语句/控制体语句){
            循环体语句;
    }
    
//执行流程:
    1)初始化语句对变量进行赋值 
    2)判断条件表达式是否成立;
        如果是成立,执行循环体语句;
    3)继续执行控制体语句 
    4)继续回到2)里面判断
        如果是成立,执行循环体语句;
    继续回到3)  
    ...
    ...
    ...
    一直执行到条件不成立结束;

求和类型题的思想步骤: 1) 定义一个最终的结果变量: sum ,从0开始 2) 使用循环语句:明确了循环次数,优先使用for 3) 循环体语句:sum+=变量 ; 4) 输出最终结果变量
什么是水仙花数:

1) 三位数: 100-999 2) 每个位的立方之和是这个数据本身 . 如:153
如何定义任意数字的各个位是多少?

设任意数为 x

个位 int ge = x % 10;

十位 int shi = x / 10 % 10;

百位 int bai = x / 10 / 10 %10;

......

/*
   输出所有的 "水仙花数"
   统计所有的 "水仙花数"有多个
   分析步骤: 
            1)定义统计变量 count
            2)水仙花:明确范围:100-999
            3)确定每各位的数据本身ge,shi,bai 
            4)满足的条件:ge*ge*ge+shi*shi*shi+bai*bai*bai==x, 这个时候统计变量++
            
            5)输出count即可
*/
class HelloWord{
    
    public static void main(String[] args){
        
            //1)定义统计变量 num
            int num = 0 ;
            //2)水仙花:明确范围:100-999
            for(int x = 100 ; x <= 999; x ++){
                //确定每各位的数据本身ge,shi,bai 
                int ge = x % 10 ;
                int shi = x /10 % 10 ;
                int bai = x /10/10 % 10 ;
                
                //确定值满足的条件
                if((ge*ge*ge+shi*shi*shi+bai*bai*bai)==x){
                    
                    //统计变量++
                    num ++ ;
                    System.out.println("第"+num+"次的数据是:"+x) ;
                }
            }
            System.out.println("水仙花数共有"+num+"个") ;  
    }
}

3.2 while循环语句

while循环的格式:

常用的格式
        初始化语句;
        while(条件表达式){
            循环体语句;
            控制体语句;
        }
执行流程:
            1)先初始化赋值
            2)判断条件表达式是否成立,成立,则执行循环体语句-
            3)执行控制体语句---继续判断条件是否成立,----循环,,,
            ...
            ...
            4)执行到条件表达式不成立,while语句结束

如何产生一个随机数字?

产生一个随机数---->使用JDK--->java.lang.Math:数学运算的工具类产生随机数的功能

Math类:public static double random() :功能就是获取随机数的功能要产生随机数:Math.random() ----> 获取的结果 double [0.0,1.0) ,取不到1.0

class MathDemo{
    
    public static void main(String[] args){
        //System.out.println(Math.random()) ;
        //要产生1-100之间的随机数
        int num = (int)(Math.random()*100+1) ;
        System.out.println(num) ;
    }
}

3.3 do-while循环语句

do-while循环语句的格式:

初始化语句;
    do{
        循环体语句;
        控制体语句;
    }while(条件表达式) ;
    
执行的流程:
    1)初始化语句赋值
    2)执行循环体语句
    3)执行控制体语句
    4)条件表达式判断,如果条件成立,继续执行循环体...
        ...
        
        ...
    条件表达式不成立,语句结束;

开发中,do-while循环语句使用不多,jdk---提供的源码会涉及的

do-while循环语句和for,while循环语句最大的区别: 当条件不成立的时候,循环体语句至少执行一次!
开发中:优先使用for,然后在while(不明确循环次数)

3.4 while和for循环的区别

1)共同点:都是能够实现循环的效果;
    
2)从格式有些差异
通用格式
for循环:     
        for(初始化语句;条件表达式;控制体语句){
                循环体语句;
        }
        
whil循环: 
        while(条件表达式){
            循环体
            控制体语句
        }
        
a) 从内存角度考虑:for循环结束之后,当前里面的局部变量被释放了,节省内存空间!
   相对来说,while循环,结束之后,依然可以访问到这个变量,
   整个main方法结束之后,才释放内存,使用过程中,消耗内存空间!
   for循环比while更好一些!
            
b) 当前明确循环次数时候,优先使用for循环;不明确循环次数使用的while循环
   for使用最多;

3.4 死循环

常见的两种死循环:

3.4.1 for循环的死循环

for循环的死循环格式:(开发中使用不多,jdk原码中会见到这种格式)
    for(;;){
        
        //当满足某个条件的时候,结束 ----->break;
        循环体语句;
    }

3.4.2 while循环的死循环

开发中,使用多:while循环:死循环格式
    while(true){
                    
        //当满足某个条件的时候,结束 ----->break;
        循环体语句;
    }

应用: 猜字小游戏

/*
    需求:键盘录入数据,猜数字小游戏    
    
    分析:
        1)得需要产生一个随机数---->使用jdk--->java.lang.Math:数学运算的工具类
                    1-100之间的随机数
                    产生随机数的功能
        2)键盘录入一个数据:guessNumber      
        while(true){
            3)需要不断的录入数据,
            4)判断guessNumber和随机数进行比较,如果大了,提示大了
            小了,提示"猜的数字小了"
            如果一致,提示"恭喜您,猜中了"
            break ;
        }   
*/

//导包
import java.util.Scanner ;
class WhileTest2{
    public static void main(String[] args){
            //要产生一个1-100之间的随机数
            int num = (int)(Math.random()*100+1) ;  
            //死循环
            while(true){
                //需要不断的录入数据,
                //创建键盘录入对象
                Scanner sc = new Scanner(System.in) ;
                System.out.println("请输入一个是数字(1-100):") ;
                //键盘录入一个数据:guessNumber
                int guessNumber = sc.nextInt() ;
                
                //判断
                if(guessNumber>num){
                    //大了
                    System.out.println("您要猜的数字大了...") ;
                }else if(guessNumber<num){
                    //小了
                    System.out.println("您要猜的数字小了...") ;
                }else{
                    System.out.println("恭喜您,猜中了!!!") ;              
                    //中断循环
                    break ;
                }
            }       
    }
}

3.5 for循环语句的嵌套

for循环语句的嵌套格式:

        for(初始化语句;条件表达式;控制体语句){---外层循环
            //循环体语句
            for(初始化语句;条件表达式;控制体语句){--- 内层循环
                循环体语句...
            }
        }
        
 将一个for循环语句作为 "循环体"去执行;

应用举例:

//99乘法表
        //为了表示有效数据:从1开始
        for(int x = 1 ; x <= 9 ; x++){//控制行数
            //内层循环:列数在变化
            for(int y = 1; y <=x ; y++){
                System.out.print( x+"*"+y+"="+(y*x)+"\t") ;
                //使用制表符号:
                //转义字符"\x" 
                //\n :表示换行
                //\t :制表符,类似于tab键的效果,缩进空格               
            }
            System.out.println() ;
        }
    }
}

println(): 后期用到的打印功能, ln:换行

/*
 “百钱买百鸡”是我国古代的著名数学题。题目这样描述：3 文
 钱可以买1只公鸡，2 文钱可以买一只母鸡，1 文钱可以买3 只小鸡。用100 文
 钱买100 只鸡，那么各有公鸡、母鸡、小鸡多少只？ 

分析:
	经典算法题----使用 "穷举法"
	
1)定义三个变量:公鸡,母鸡,小鸡,x,y,z
2)穷举公鸡最大取的数量:0 33 之间	外层循环:每一个取到的数量获取到
  穷举母鸡最大取的数据范围:0 50只 之间	内层循环:母鸡的数量获取到
  
  z = 100 - x - y;
  
3)满足条件:
		(3x + 2y + z ==100) 同时满足: 1 文钱可以买3 只小鸡(小鸡的数量一定要能够取整)
										z % 3 == 0										
4)分别输出x,y,z		
*/
class ChickenNumber{
	public static void main(String[] args){
		
		//定义三个变量:x,y,z分别代表公鸡,母鸡,小鸡
		//穷举公鸡数量
		for(int x = 0 ; x <= 33;x++){
			//获取到每一个公鸡数量
			//穷举出母鸡的数量
			for(int y = 0 ; y <= 50 ; y ++){
				//获取到每一个母鸡数量
				//定义小鸡的数量
				int z = 100-x-y ;
				
				//满足条件:
				//100文钱买有100只鸡(包含公鸡,母鸡,小鸡)
				//3 文钱可以买1只公鸡，
				//2 文钱可以买一只母鸡，
				//1 文钱可以买3 只小鸡,小鸡要能够3整除
				if((3*x+2*y+z/3==100) && (z%3==0)){
					System.out.println("公鸡有:"+x+"只"+",母鸡有:"+y+"只"+",小鸡有"+z+"只") ;
				}
/*
公鸡有:0只,母鸡有:40只,小鸡有60只
公鸡有:5只,母鸡有:32只,小鸡有63只
公鸡有:10只,母鸡有:24只,小鸡有66只
公鸡有:15只,母鸡有:16只,小鸡有69只
公鸡有:20只,母鸡有:8只,小鸡有72只
公鸡有:25只,母鸡有:0只,小鸡有75只
*/
			}
		}
	}
}

/*
    输入整数A,然后判断是否是质数
    提示:
            对A数据进行开平方根: 目的为了缩小范围
            
什么是质数:
    除去1和它本身外,不能被其他数据整除整除的称为"质数"
    0不是质数!
            
            
    分析:
        1)键盘录入数据A 
        2)从2开始---取值范围: 对这个数据开平方根 (变量i)
                    public static double sqrt(double a),缩小范围
        3)可以使用假设法
            boolean flag  = true ;//是质数         
        4)判断
            if(A % i == 0 ){
                //提示"不是质数" 
                flag = false; 
                break ;
            }
                        
        5)if(flag){//true
            //提示"是质数"
            
        }       
        需求: 录入任意一个数据,将每各位数据进行求和!(作业)
            
                157
                    思路:先取低位,然后继续取整 /10 --->while循环                  
*/
//导包
import java.util.Scanner ;
class Test3{
    public static void main(String[] args){
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in) ;
        
        //提示并录入数据
        System.out.println("请您输入一个数据num:") ;
        int num = sc.nextInt() ;
        //假设成立
        boolean flag = true ;

        //对这个数据开平方根 (变量i)
        for(int i = 2 ; i <= Math.sqrt(num) ; i ++){
            
            //判断
            if(num % i == 0){
                System.out.println("不是质数") ;
                //修改标记flag
                flag = false ;
                break ;
            }
        }
        if(flag){
            //是质数
            System.out.println("是质数") ;
        }       
    }
}

4. 跳转控制语句

包括: break ; continue ; return ;

break:中断,结束
不能单独使用,
1)只能在switch或者循环语句中使用;  单循环for循环中使用  
2)在for循环嵌套中使用 
   break 标签语句 ;(现在很少见)      
   给外层循环,或者内层循环起名字--->标签语句;
    
    class BreakDemo{
    public static void main(String[] args){
        wc:for(int x = 0 ; x < 4 ; x ++){  //外层循环,行数 x=0,1,2,3
            nc:for(int y = 0 ; y < 5 ; y ++){ //内层循环,列数
                //if(x == 2){
                    //break wc ; //结束外层循环                   
                //}
                if(y==2){
                    break nc ;//结束内层循环,控制列数
                }
                System.out.print("*") ;
            }
            System.out.println() ;
        }
    }
}

continue:继续---->结束当前循环,立即进入下次循环 
  也不能单独使用
  
    class ContinueDemo{
    public static void main(String[] args){
        
        //continue ;//continue 在 loop 外部,不能离开循环使用
        
        //定义for循环
        for(int x = 1 ; x <= 10 ; x
        ++){
            
            //加一个条件
            /*
            if(x == 3){
                continue ;
            }
            /1,2,4,5,6,7,8,9,10
            */
            
            if(x % 3==0){
                continue ;//结束循环,立即进入下次循环
            }
            System.out.println(x) ;//1,2,4,5,7,8,10
        }
    }
}

return:返回具体的结果(结束方法)
rturn关键字不是为了跳转出循环体，更常用的功能是结束一个方法，也就是退出一个方法。跳转到上层调用的方
法。这个在方法的使用那里会在详细的讲解。演示案例：结束循环其实是结束了main方法

但是一般return很少单独使用,需要在有具体返回值类型的方法中使用!
return 一般都是结合方法使用
return 结果值;

Mihusasa

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java 入门 2

Java 入门 2#位运算符1.位运算符:针对多个数据进行操作(使用"补码"计算结果)计算出来的结果是具体的数据值;2.基本的位运算符:位与&: 有0,则0 位或|: 有1,则1 位异或^:相同则为0,不同则为1 反码~: 按位取反,全部都0变1,1变0 位异或^的另一个特点: 一个数据被另一个数据位异或两次,其值是它本身应用:(面试题)请有最有效的方式,实现两个数据交换!(公式:左边a,b,a / 右边:a ^ b)class Demo{ public..
复制链接

扫一扫