温故而知新：Java重温第一天

Java学习第1天

 

Java基础01：注释

  1. IDEA中NEW Module 新建模块

  2. 注释的不会执行，写给人看的，起到提醒作用等。

  3. 单行注释 //

  4. 多行注释 / * * /

  5. 文档注释 /** */

标识符

  1. 关键字

    image-20210614113200240

数据类型

  • 强类型语言

    • 要求变量的使用符合规定，所有的变量都必须先定义后才能使用

  • 弱类型语言

  • Java的数据类型分为两大类

    • 基本类型（primitive type）

    • image-20210614113713044

    public class Demo02{
    public static void main(String[] args){
        //八大基本数据类型
        
        //整数
        int nu1 = 10;
        byte num2 = 20;
        short num3 = 30;
        long num4 = 30L;//长整型后面要加上L
        
        //小数
        float num5 = 50.1F;//float类型要在数字后面加上F，最好完全避免使用float进行比较
        double num6 = 3.14215456511 ;
            
         //字符
         char name = '国';
         //字符串
         String name1 = "zhb";
         
         //布尔值
         boolean flag = true;//只有true和false 用于判断真假
        
            
         
        
    }
}

    • 引用类型 （reference type）

      包含，类，方法等。

  • 什么是字节

    • 位（bit）：是计算机内部数据储存的最小单位，11001100是一个八位的二进制数。

    • 字节（byte）：是计算机中数据处理的基本单位，习惯用上大写B来表示。

    • 1B（byte，字节） = 8bit（位）

    • 字符：是指计算机中使用的字母，数字，字和符号

  • 所有的字符本质还是数字image-20210614120719518

类型转换

  • Java是强类型语言，所以要进行运算的时候，需要用到类型转换image-20210614133100359

    public class Demo{
    public static void main(String[] args{
        int i=128;
        byte b = (byte)i;//输出-128，因为内存溢出
        
        //强制转换 （类型）变量名  高——低
        //自动转换  低——高
        
        /*
        注意点：
        1.不能对布尔值进行转换
        2.不能把对象类型转换成不相干的类型
        3.在把高容量转到低容量的时候，强制转换
        4.转换的时候可能存在内存溢出或者精度问题
        */
        
        
    }
}

变量

  1. 变量是什么：就是可以变化的量！

  2. java中 每个变量都必须声明类型

  3. java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域

  4. 定义变量时，最好不要一行定义多个，比如

    int a = 1,b = 2, c = 3;//尽量不要这样,影响程序可读性
int a = 1;
int b = 2;
int c = 3;

变量作用域

  1. 三种变量：

    public class Demo08{
    //类变量 static
    static double salary = 2500; 
    
    //属性：变量
    
    //全局变量：从属于对象；
    String name;
    int age;
    
    //main方法
    public static void main(String[] args){
        //局部变量：必须声明和初始化值
        int i=10;//在main方法中定义的变量无法在其他方法中使用称为局部变量。
        System.out.println(i);
        
        Demo08 demo08 = new Demo08();
        System.out.println(demo08.name);//可以使用类定义的变量，称为全局变量；
        
        //类变量
        System.out.println(salary);//可以直接使用定义的静态变量;
    }
    
    //其他方法
    public void add(){
       System.out.println(i); 
    }
}

  2. 常量

    public class Demo09{
    //修饰符，不存在先后顺序
    static final double PI = 3.14;
    
   public static void main(String[] msg){
       System.out.println(PI);//输出为3.14 
   }
}

  3. 变量的命名规则

    image-20210614141419078

运算符

image-20210614141627907

  • 扩展：Math函数

    • 幂运算 2^3

      • Math.pow(2,3) 意思为2的三次方

  • 逻辑运算符、位运算符

    • 逻辑运算

    public class Demo05{
    
        public static void main(String[] args){
        //与（and）或（or）非（取反）
        boolean a=true;
        boolean b=false;
​
        System.out.println("a&&b："+(a&&b));//输出为false，两个都为真才为true
        System.out.println("a||b："+(a||b));//输出为true，有一个为真即为true
        System.out.println("!(a&&b)："+!(a&&b));//输出为true，去相反的值
​
        System.out.println("分割线==================================");
        //短路运算
        int c = 5;
        boolean d = (c<4)&&(c++<4);//可以发现第一个判断为假之后，后面的判断语句不执行，所以c不进行c++
        System.out.println(d);//输出false
        System.out.println(c);//输出5
    }
}

    • 位运算

      /*
A = 0011 1100
B = 0000 1101
​
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~B = 1111 0010
​
<< 由下面的二进制可以发现 左移相当于*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

  • 三元运算符

//字符串连接符 + String
 System.out.println(""+a+b);
 System.out.println(a+b+"");
​
    public class Demo08{
        public static void main(String[] args){
            // x > y : z    
            //如果X为真，则结果为Y，否则结果为Z
            
           int score = 80;
            String type = score <60 ? "不及格":"及格";
            //尽量用if
            System.out.println(type);//输出得及格
            
        }
    }

包机制

image-20210614145548054

用户交互 Scanner

  • hasNext()方法

public class Demo01{
    public static void main(String[] args){
        
        //创建一个扫描器对象，用于接收键盘数据
        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();
        
         /*
         next()方法
         1.一定要读取到有效的字符串才后才可以结束输入
         2.对输入的有效字符之前遇到的空白，next()方法会自动去掉
         3.只有输入有效字符串后才能将其后输入的空白作为分隔符或者结束符。
         4.next()不能得到带有空格的字符串
         所以以上代码接收从接盘输入的字符串时，如果输入为Hello World！，输出的字符串只有Hello
         */
        
    }
}

  • hasNextLine()方法

public class Demo01{
    public static void main(String[] args){
        
        //创建一个扫描器对象，用于接收键盘数据
        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();
        
        
        /*
        1.以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符。
        2.可以获得空白
        3.所以输入 Hello world！可以接收中间空白输出完整的
        Hello World！
        */
    }
}

Scanner的进阶用法

  • 可以用于判断输入的是否为整数等等，更多用法可以自行开发。

public class Demo01{
    public static void main(String[] args){
        
        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);
       
        System.out.println("请输入整数");
        
        int i=0;
          
        //判断用户是否输入INT型
        if(scanner.hasNextInt()){
            //使用next方式接收
            i = scanner.nextInt();
            System.out.println("输出的内容为："+i);
        }else{
            System.out.print("请输入整数");
        }
        
        
        //凡是属于IO流的类如果不关闭会一直占用资源，要养成用完就关的好习惯
        scanner.close();
        
   
    }
}

image-20210614193443055

  • 用于输入多个数字，求和

public class Demo01{
    public static void main(String[] args){
​
        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);
​
        System.out.println("当输入的不是数字的时结束输入");
        System.out.println("请输入:");
        double sum=0;
        int i=0;
        //使用循环判断是否还有输入
        while(scanner.hasNextDouble()){
            double x= scanner.nextDouble();
            i = i+1;//m++
            sum = sum+x;
​
        }
        System.out.println("输入个数为："+i);
        System.out.println("输入的数值和为："+sum);
        //凡是属于IO流的类如果不关闭会一直占用资源，要养成用完就关的好习惯
        scanner.close();
    }
}

image-20210614193021473

顺序结构

image-20210614163358236

选择结构

  • equals和 == 的区别(重点)

    • equals用于判断字符串是否相等

public class Demo01{
    public static void main(String[] args){
        
        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);
       
        System.out.println("请输入内容");
        String s = scanner.nextLine();
        
        //equlas:判断字符串是否相等
        if(s.equals("Hello")){
            
            System.out.println(s);
        }
​
        scanner.close();
​
    }
}

  • if

    • 具有嵌套if结构，在if判断中增加if判断

    if(布尔表达式1){
    //如果布尔表达式1为真则执行
    if(布尔表达式2){
        //如果布尔表达式2为真则执行
    }
}

  • if...else 意思为：如果。。。否则。。。

    • if双选择结构

    if(布尔表达式1){
    //如果布尔表达式1为真则执行
    }else{
     //如果布尔表达式1为假则执行
    }
}

  • swith...case

    • 判断一个变量与一系列值中某个值是否相等，每个值称为分支

    swith(expression){
    case value;
    //语句
         break;//可选
    case value;
    //语句
         break;//可选
    case value;
    //语句
         break;//可选
    //可以由任意数量的case语句
}
/*
其中的expression为输入的指，value为判断的指，
如果expression == value，则执行下方代码。
*/

循环结构

  • while循环

while(布尔表达式){
    //循环内容
}
​
//如果布尔表达式一直为true则会一直循环，所以我们需要避免无限循环【死循环】。
//我们大多数情况看是会让循环停止，所以需要一个让表达式失效的方式来借宿循环
//数部份情况需要一直循环，比如服务器的请求响应监听等等。
​

  • do..while循环

    • 对于while循环来说，do..while循环至少会循环一次

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

  • for循环

    • for循环语句是支持迭代的一种通用结构，是最有效，最快捷的方法。

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

    for(初始化;布尔表达式;更新){
    //代码语句
}
​
/*
关于for循环由以下几点说明：
1.最先执行初始化步骤，可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
2.然后，检测布尔表达式的值，如果为true，循环执行，否则停止，开始执行循环体后面的语句，
3.执行一次循环后，更新循环控制变量(迭代因子控制循环变量的增减)后再次检查布尔表达式，循环执行以上操作。
*/

    • 用for循环打印99乘法表

    public class Main {
​
    public static void main(String[] args){
​
        //循环乘法表最外圈的1-9
        for(int i=1;i<10;i++){
            //循环乘法表里面的一圈
            for(int j=1;j<=i;j++){
                if(j<i){
                    System.out.print(i+"*"+j+"="+i*j+"\t");
                }else{
                    System.out.println(i+"*"+j+"="+i*j+"\t");
                }
            }
        }
    }
}

    image-20210614192706291

  • 增强for循环

 for(声明语句 ; 表达式){
     //代码句子
 }
//声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数据元素的值相等。
//表达式：表达式是要访问的数据名，或者是返回值为数组的方法。
​
public class Demo01{
    public static void main(String[] args){
     //创建数据
        int[] number = {10,20,30,40,50};
        
      //遍历数组元素
        for(int i; number){
            System.out.println(i);
        }
    }

break continue

  • break：结束当前的事件，终止不再循环，也不再循环剩下语句。

  • continue：跳出此次循环，之后继续进行下一次是否执行循环的判定。

打印三角形

public class Main {
​
    public static void main(String[] args) {
        int j=0;
        //打印5行的三角形
        for(int i=1;i<=5;i++){
            for(j=5;j>=i;j--){
                System.out.print(" ");
            }
            for (int x=0 ;x<(i-1)*2+1;x++){
                    System.out.print("*");
            }
            System.out.println();
        }
    }
}



posted on 2021-06-14 20:04  阿滨滨  阅读(49)  评论(0)    收藏  举报
博客园  ©  2004-2025
浙公网安备 33010602011771号 浙ICP备2021040463号-3