小白学JAVA Day2（24-10-23）

原创已于 2024-10-26 23:21:55 修改 · 847 阅读

28 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

于 2024-10-24 01:13:36 首次发布

注意创建前要先配置环境

输入psvm表示：

 public static void main(String[] args)

输入sout表示：System.out.println();

System.out.println

注释

单行注释 //

多行注释 /*dhfov

nsnd*/

文档注释 /**

*@.....

标识符

所有标识符都应该以字母（a-z,A-Z)，美元符$，或者下划线_开头

首字符之后可以是字母，数字，美元，下划线的任何字符组合

大小写敏感

可以用中文命名，但不建议使用

关键字

数据类型

强类型语言：要求所有变量都必须先定义后才能使用，使用要严格符合规定

Java的数据类型分两大类：

基本类型：数值类型（整数、浮点、字符’c','在‘）

最好完全避免使用浮点数进行比较

所有的字符本质还是数字（强制类型转换）

boolean类型：true和false

引用类型：类，接口，数组

变量

Java是一种强类型语言，每个变量都必须声明其类型

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

        int a,c;
        a=1;
        c=3;
        int d=1,e=3;//尽量不要在一行声明多个变量，程序可读性会变差
        int g=1;
        int h=3;
        String f="qwe";

变量的作用域

类变量：static

实例变量

局部变量：在方法中

常量

初始化之后不能改变的值

常量名一般是使用大写字符

final 常量名=值；（注意数据的数据类型不能忽略）

public class demo2 { //类

    //实例变量：
    //在方法外面，类里面，从属于对象（类），通过类来使用，如果不自行初始化，会变成这个类型的默认值
    //数值类型初始化为0（整数），0.0（浮点数）
    //布尔值默认是false
    //除了基本类型，其余默认值都是null
    String name;
    int age;
    int age2=10;
    boolean flag;

    //类变量 static
    //（不用new了）
    static double salary=2500;//自动转换为double
    static int b;//默认为0
    static final double PI=3.14;//常量
    final static double PI2=3.14;//修饰符不存在先后顺序




    //main方法
    public static void main(String[] args) { //方法（主程序方法，又称main方法）
       //局部变量：必须声明和初始化
       /*int i;
       System.out.println(i);报错，i必须初始化*/
        int i=1;
        System.out.println(i);

        //实例变量测试输出
        //变量类型（类名） 变量名字=new demo2();
        demo2 a=new demo2();
        System.out.println(a.name);//输出null
        System.out.println(a.age);//age没有赋初始值，还是输出了0
        System.out.println(a.age2);//输出10
        System.out.println(a.flag);//输出false

        //类变量测试输出
        System.out.println(salary);//输出2500.0
        System.out.println(b);//输出0
        System.out.println(PI);
        System.out.println(PI2);

        //常量
        final int C=13;//大写
        System.out.println(C);
    }

    //其他方法
    public void add(){

    }
}

所有的变量、方法、类名：见名知意

类成员变量、局部变量：驼峰原则，首字母小写，后面大写 mouthSalary

常量：大写、下划线 MAX-VALUE

类名：首字母大写，驼峰原则 GoodMan

方法名：首字母小写、驼峰原则

进制

        int i=10;//十进制
        int i2=010;//八进制0
        int i3=0x10;//十六进制0x
        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);

转义字符

\t 制表符

\n 换行......

类型转换

强制类型转换

        int q=128;
        byte b=(byte)q;
        System.out.println(q);
        System.out.println(b);//输出-128，因为byte最大到127，内存溢出

自动类型转换

注意点：

        //操作比较大的数的时候，注意溢出问题
        int money=10_0000_0000;//JDK7新特性，数字之间可以用下划线进行分割
        int years=20;
        int total=money*years;
        long total2=money*years;
        System.out.println(total);//输出-1474836480
        System.out.println(total2);//输出-1474836480

默认是int，money*years为int，转换为long之前已经存在问题了，应这样操作：

        long total3=money*((long)years);//计算之前将其中一个int转为long
        System.out.println(total3);//输出20000000000

运算符

算术运算符

赋值运算符

关系运算符

逻辑运算符

位运算符

条件运算符

扩展赋值运算符

运算符优先级

（）

public class demo3operator {
    public static void main(String[] args) {
        //运算符
        //复制当前行到下一行Ctrl+D

        //算术运算
        int a=10;
        int b=20;
        int c=15;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/b);//输出0
        System.out.println(a/(double)b);//输出0.5
        System.out.println(c%a);//取余

        long d=12334354L;
        int e=1234;
        short f=24;
        byte g=7;
        System.out.println(d+e+f+g);//long
        System.out.println(e+f+g);//int
        System.out.println(f+g);//int 注意是int类型，有一个数为double或者long类型，结果就是long或者double，否则均为int（整数），不是short

        //关系运算
        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        System.out.println(a!=b);

        //自增自减 连加连减
        int h=3;
        int i=h++;
        int j=++h;
        System.out.println(h);
        System.out.println(i);
        System.out.println(j);
        h+=1;
        System.out.println(h);
        h-=2;
        System.out.println(j);


        //逻辑运算
        boolean k=true;
        boolean l=false;
        System.out.println("k && l="+(k&&l));//用加号连接输出
        System.out.println("k || l="+(k||l));
        System.out.println("! k="+(!k));
        //短路运算 实验验证
        System.out.println("k && l="+(l&&k));
        int m=5;
        boolean n=(m<4)&&(m++<10);
        System.out.println(m);//输出5，证明短路了

        //位运算
        /*
        * A=0011 1100
        * B=0000 1101
        * A&B=0000 1100
        * A|B=0011 1101
        * A^B=0011 0001
        * ~B=1111 0010
        * <<左移*2  >>右移/2
        * */
        int A=12;
        int B=13;
        System.out.println(A&B);//12
        System.out.println(A|B);//13
        System.out.println(A^B);//1
        System.out.println(~B);//-14??
        System.out.println(2<<3);//输出16

        //字符串连接+ +号两侧只要一侧出现了字符串类型，就会把另外一个操作数转化为string
        System.out.println(""+A+B);//输出1213 在前面拼接
        System.out.println(A+B+"");//输出25 在后面运算

        //三元运算符
        int score=80;
        String type=score<60?"不及格":"及格";//if
        System.out.println(type);

    }
}

包机制

包的本质就是文件夹

为了更好地组织类，Java提供了包机制，用于区别类名的命名空间

package pkg1[ . pkg2[ . pkg3...]];

一般运用公司域名倒置作为包名（www.baidu.com com.baidu.www）

//按照层级关系导入包

import base.*;

导入这个包下所有的类

JavaDoc

用来生成自己的API文档

public class baike {
    String name;

    /**
     * 
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }
}

方法的注解，输入/**后回车自动生成

在资源管理器中打开该Java文件，然后cmd路径进入命令行

输入javadoc 文件名

然后在该文件夹下会出现很多文件

点击index.html

Scanner对象

实现程序和人的交互

import java.util.Scanner;

public class demo4scanner {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);//Alt+Enter补全
        System.out.println("使用next的方法是：");
        //判断用户有没有输入字符串
        if(scanner.hasNext()){
            //使用next方式接收
            String str= scanner.next();
            System.out.println("输入的内容为："+str);
        }
       //凡是属于IO流的类如果不关闭会一直占用资源
       scanner.close();
    }
}

此时用户输入Hello world，最后指数出来Hello

nextLine

        Scanner scanner1 = new Scanner(System.in);
        System.out.println("使用nextLine的方法是：");
        if(scanner1.hasNextLine()){
            //使用nextLine方式接收
            String str1= scanner1.nextLine();
            System.out.println("输入的内容为："+str1);
        }
        scanner1.close();

此时用户输入Hello world，输出也是Hello world

小结

next()

一定要读取到有效字符后才可以结束输入

对输入有效字符之前遇到的空白，会自动将其去掉

只有输入有效字符后才可以将其后面输入的空白作为分隔符或者结束符

不能得到带有空格的字符串

nextLine()

以回车作为结束符，即nextLine()方法返回的是输入回车之前的所有字符

可以得到空白

最简单形式

        Scanner scanner2 = new Scanner(System.in);
        System.out.println("请输入：");
        String str2= scanner2.nextLine();
        System.out.println("输入的内容为："+str2);
        scanner2.close();

关键只有3句

练习一

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入整数：");
        if(scanner.hasNextInt()){
            int i=scanner.nextInt();
            System.out.println("整数为："+i);
        }
        else{
            System.out.println("输入的不是整数");
        }
        scanner.close();

小数换为nextFloat()即可

练习二

        //输入多个数字，并求其总和和平均数，没输入一个数字用回车确认，通过来结束输入
        double sum=0;
        int num=0;
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入数字：");
        while(scanner.hasNextDouble()){
            double x1=scanner.nextDouble();
            num++;
            sum+=x1;
            System.out.println("输入数字：");
        }
        System.out.println("平均值为："+(sum/num));
        System.out.println("个数为："+num);
        scanner.close();

流程控制

顺序结构

Java的基本结构就是顺序结构

选择结构

if单选择结构

if(布尔表达式){}

        //if单选择结构
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入内容");
        String str= scanner.nextLine();
        //equals:判断字符串是否相等
        if(str.equals("Hello"))
        {
            System.out.println(str);
        }
        scanner.close();

if双选择结构

if--else

        //if-else
        //考试分数大于60就是及格，否则不及格
        Scanner scanner1 = new Scanner(System.in);//#交互必有，第一句
        System.out.println("成绩：");
        double score=scanner1.nextDouble();//#创建变量来接受输入
        if(score>=60)
            System.out.println("及格");
        else
            System.out.println("不及格");
        scanner1.close();//写完第一句，就写这个，以防忘记

if多选择结构

if--else if--else if--......--else

#两种格式

        //if多选择结构
        //成绩
        Scanner scanner = new Scanner(System.in);
        System.out.println("成绩：");
        double score= scanner.nextFloat();
        if(score>=80)
            System.out.println("优秀");
        else if (score>=70)
            System.out.println("良好");
        else if (score>=60)
            System.out.println("及格");
        else
            System.out.println("不及格");
        scanner.close();

        Scanner scanner = new Scanner(System.in);
        System.out.println("成绩：");
        double score= scanner.nextFloat();
        if(score>=80){
            System.out.println("优秀");
        }else if(score>=70){
            System.out.println("良好");
        }else if(score>=60){
            System.out.println("及格");
        }else{
            System.out.println("不及格");
        }
        scanner.close();

嵌套的if结构

if(){ if() {} }

switch多选择结构

        //switch：匹配一个具体的值
        char grade='a';
        switch(grade){
            case 'a':
                System.out.println("1");
                break;//可选，但是不选会case穿透
            case 'b':
                System.out.println("2");
                break;
            case 'c':
                System.out.println("3");
                break;
            default://可选
                System.out.println("4");
        }

        switch (grade) {
            case 97:
                System.out.println("1");
                break;
            case 98:
                System.out.println("2");
                break;
            case 99:
                System.out.println("3");
                break;
            default:
                System.out.println("4");
        }

反编译可以看出字符的本质是数字

从JavaSE7开始，switch支持字符串String类型了（用字符串代替字符，其他相同）

循环结构

while循环

通常要让表达式失效的方式来停止循环，少部分要让循环一直执行，比如服务器的请求监听响应

        //while循环
        //输出1——100
        int i=0;
        while(i<100){
            i++;
            System.out.println(i);
        }

        //计算1+2+3+...+100
        int sum=0;
        int n=0;
        while(n<100){
            n++;
            sum+=n;
        }
        System.out.println(sum);

do...while循环

至少执行一次

        //do-while
        //计算1+2+3+...+100
        int sum1=0;
        int n1=1;
        do{
            sum1+=n1;
            n1++;
        }while(n1<=100);
        System.out.println(sum1);

注意while（）后面有分号

for循环

for（初始化语句；布尔表达式；更新）{ }

最有效，最灵活的循环结构

        //for循环
        for(int i=1;i<=100;i++){
            System.out.println(i);
        }
        //输入50.for自动生成一个for循环语句
        for (int i = 0; i < 50; i++) {
            
        }

练习一

        //计算0-100之间所有的奇数和偶数的和
        int oddsum=0;//奇数的和
        int evensum=0;//偶数的和
        for (int i = 0; i < 100; i++) {//100.for自动生成
            if(i%2!=0)
                oddsum+=i;
            else
                evensum+=i;
        }
        System.out.println("奇数的和："+oddsum);
        System.out.println("偶数的和："+evensum);

练习二

        //输出1-1000之间能被5整除的数，每行输出3个
        for (int i = 0; i <= 1000; i++) {//1000.for并加上等号
            if(i%5==0){
                System.out.print(i+"\t");//注意此处是print
            }
            if(i%(5*3)==0)
                System.out.println();//表示换行
                //System.out.print("\n");//这样也可以表示换行 
        }
        //print:输出完不会换行
        //println:输出完会换行

练习三

        //输出九九乘法表
        for (int j = 1; j <= 9; j++) {
            for (int i = 1; i <= j; i++) {//9.for
                System.out.print(i+"*"+j+"="+(i*j)+"\t");
            }
            System.out.println();
        }

增强for循环

Java5引入主要用于数组或集合的

for（声明语句：表达式）{ }

        //增强for循环
        int[] nums={1,2,3,4,5,6,7};//数组
        for(int x:nums){
            System.out.println(x);//将数组每一项遍历出来赋给了x
        }

今日总结

面向csdn/百度编程

学习基础的写程序的方法与命令

没有学docker