Java学习笔记（1）

Java学习笔记

1.1初识java

//类名:首字母大写
public class Main {
    //主函数，程序的入口main[主要的 主函数] 快捷方式main回车
    public static void main(String[] args) {
        //向控制台输入Hello world 快捷方式 sout 回车
        System.out.println("Hello world!");
    }
}

package bdqn;
//单行注释
/*
 *多行注释
 */
public class Test01 {
    /*
     主程序入口
     @param 主程序说明 args xx说明
     */
    public static void main(String[] args) {
        //带换行的输出语句
        System.out.println("带换行的输出语句1！");
        System.out.println("带换行的输出语句2！");
        //不带换行的输出语句
        //转义字符换行符：\n
        System.out.print("不带换行的输出语句1\n");
        System.out.print("不带换行的输出语句2\n");
        //转义字符制表符：\t
        System.out.println("姓名\t成绩\t");
    }
}

1.Java遵循驼峰式单词命名原则，单词组合中每个单词的第一个首字母大写 Eg:MyBook 、StudentInfo。

2.Java的代码必须写在花括号‘{}’里面 Eg：{ System.out.print(“不带换行的输出语句1\n”);}。

3.Java中一行只写一句代码，并必须以分号‘；’结尾。 4.Java中想运行必须有main函数，也就是一定要有主函数。

1.2JavaSE基础

package bdqn;

import java.util.Scanner;

/**
 * 通过scanner录入键盘信息
 */
public class Luru {
    public static void main(String[] args) {
        /**
         *   类库里面扫描类Scanner；
         *   Scanner input 创建对象的名字
         *      System.in系统输入（键盘输入）
         */
        Scanner input = new Scanner(System.in) ;
        //接受键盘录入的字符串，按回车表示录入完成
        String name = input.next();
        //提问：
        System.out.println("请问你叫什么名字？");
        //打印录入的内容
        System.out.println(name);
    }
}

1.2.1变量

变量：一个数据存储空间的表示，在计算机中存储空间即为内存，程序运行时是从内存中调用数据。

​ 不同数据存入不同内存地址的空间，数据与数据之间是相互独立的。 基本类型的变量存在栈内存当中。

变量命名：不能使用关键字命名,如public private（关键字就是在Java语法中将某些单词作为特定的功能。）；

可以使用字母、下划线、$、￥、数字（数字不能在第一位）并且遵循驼峰式命名法（第一个单词首字母小写，其余单词首字母大写）

package edu.bdqn.kg;
/**
 * 演示变量的创建
 */
public class Demo01 {
    //主函数 程序入口
    public static void main(String[] args) {
        //代码
        String name = "张睿博";//创建变量，存储某个学生的姓名。
        int a = 20;//字母
        int _a = 30;//下划线
        int $a =40;//美元符号
        int ￥a = 20;//人民币
        int in = 40;//遵循驼峰式命名，且第一个单词首字母必须小写，其余单词首字母大写
    }
}

1字节=8bit位	byte（字节类型）	boolean（布尔类型）true/false
2字节=16bit位	short（短整类型）存放数值	char(字符类型)字符（a b c 汉字‘1’ ‘2’ ‘3’）
4字节=32bit位	int(整类型) 存放数值	flat（浮点类型）存放数值（小数）
8字节=64bit位	long （长整类型）存放数值	double（双精度浮点*型）存放数值（小数）

变量的声明和使用：

1.声明变量，根据数值类型在内存申请储存空间。即：“数值类型 变量名；”

2.负值，将数据储存至对应的储存空间。即：“变量名 = 数值；”

注意：第一步和第二步可以合并。

3.使用变量，将数据取出使用。

package edu.bdqn.kg;

/**
 * 变量声明和负值
 * 声明：预定内存空间            语法格式    （变量类型   变量名;）
 * 赋值：给预定内存空间输入数据    语法格式    （变量名   =   值;）
 */
public class Demo02 {
    public static void main(String[] args) {
        int num1;//声明
        num1 = 10;//赋值
        //使用变量，通过变量名调用里面的数值，用在你需要的语句中。
        int num2 = 20;//声明和赋值一起使用
        int num3;
        num3 = num1 *   num2;//调用数据
        System.out.println(num3);
    }
}

注意：有多少数据就应有多少变量，若数据类型一样则需要调用一次数据类型，然后赋值是用逗号隔开，eg:int n1=1,n2=2,n3=3。

​ 打印时用加号和双引号隔开连接否则会相加，eg：System.out.println(n1+“”+n2+“”+n3);

package edu.bdqn.kg;

public class Demo03 {
    public static void main(String[] args) {
        int n1  = 1;
        int n2 = 2;
        int n3 = 3;
        System.out.println(n1+""+n2+""+n3);
        int n4 = 1,n5 = 2 ,n6 = 3;//变量的连续调用；
        System.out.println(n4+""+n5+""+n6);
    }
}

package edu.bdqn.kg;

public class Demo04 {
    public static void main(String[] args) {
        //字符串类型为String,表示连接一串字符
        //加号亦可作为字符串连接符。
        String name = "典韦";
        String zhiye = "刺客";
        String jineng = "麒麟焦魔砍";
        System.out.println("姓名:"+name);
        System.out.println("职业:"+zhiye);
        System.out.println("技能:"+jineng);
    }
}

1.2.2常量

常量的特点：1，常量名全部大写，如果有多个单词组成使用下划线分割。 2，常量的定义在前面加上关键字final。

​ 3，常量必须赋值，一旦赋值就不可以改变

package edu.bdqn.kg;

import java.util.Scanner;

public class Demo04 {
    public static void main(String[] args) {
        System.out.println("做个自我介绍");
        final double pi  = 3.14;//定义常量

    }
}

1.2.3 Scanner扫描类

Scanner扫描器类 jdk类库提供 需要引入它

创建和使用Scanner扫描器类分为3个步骤：1，声明变量接受扫描对象。

​ 2，使用扫描器对象input接受键盘录入的内容，此时可以设置接受的类型是什么。

​ 格式为：input.next+字符类型+()；eg:整型：input.nextInt();

package edu.bdqn.kg;

import java.util.Scanner;

public class Demo05 {
    public static void main(String[] args) {
        System.out.println("姓名：");
        Scanner input = new Scanner(System.in);
        String name =input.next();//扫描器定义字符串类型
        System.out.println("年龄：");
        Scanner input1 = new Scanner(System.in);
        int age = input.nextInt();//扫描器定义整型
        System.out.println("成绩：");
        Scanner input2 = new Scanner(System.in);
        double score = input1.nextDouble();//扫描器定义小数
        System.out.println("是否录用：");
        String pso = input.next();
        System.out.println("姓名:"+name+""+"年龄："+age+""+"成绩："+score+""+"录用："+pso);
    }
}

1.2.4自动类型转换（从短转长）

如果等号左边字符的类型长度大于右边字符的类型长度，结果会保持不变，反之，则改变。

package edu.bdqn.kg;
public class Demo06 {
    public static void main(String[] args) {
        double firstave = 83.29;
        double secondave;
        int n = 2;
        secondave =firstave+n;
        System.out.println(secondave);
    }
}

1.2.5强制类型转换（从长转短）

package edu.bdqn.kg;

public class Demo06 {
    public static void main(String[] args) {
        double firstave = 83.59;
        int secondave;
        int n = 2;
        //强制类型转换：按键---alt+回车
        secondave = (int) (firstave+n);
        System.out.println(secondave);
    }
}

1.2.6赋值运算符

package edu.bdqn.kg;

public class Demo08 {
    public static void main(String[] args) {
        //第一个变量。
        int a = 80;//等号表示赋值 a=80
        int b;//创建一个待赋值变量b
        b=a;//开始把a赋值给b
        System.out.println(b);//输出待赋值b的值
    }
}

注意：赋值运算符的顺序从右向左赋值，赋值运算符的优先级很低，如果一条语句中有多个运算符，赋值运算符最后执行。

两个变量值交换就是：首先设置一个空值c，其次把第一个值a赋给空值c，然后把第二个值b赋给第一个值a，接着把空值c赋给第二个值b 最后打印输出出来。

package edu.bdqn.kg;

public class LianXi01 {
    public static void main(String[] args) {
        int a=8;
        int b=9;
        int c;//设置空值c
        c=a;//将a的值赋给c
        a=b;//将b的值赋给a
        b=c;//将c的值赋给b
        System.out.println(a+" "+b);//输出a,b的值
    }
}

1.2.7简单运算符

package edu.bdqn.kg;

public class Demo09 {
    public static void main(String[] args) {
        //        +,-,*,/:简单运算符
        int a=10;
        int b=2;
        int c=4;
        System.out.println(a+b);//a和b相加
        System.out.println(a-b);//a和b相减
        System.out.println(a*b);//a和b相乘
        System.out.println(a/c);//a和b相除
        System.out.println(a%c);//a和c取余
    }
}

1.2.8复合运算符

package edu.bdqn.kg;

public class Demo10 {
    public static void main(String[] args) {
//        复合运算符:+=,-=,*=,/=（先运算再赋值给自己）
        int a=10;
        int result=20;
        //加法：+=
        result +=a;//相当于result=resul+a
        System.out.println(result);
        //减法：-=
        result -=a;//相当于result=result-a
        System.out.println(result);
        //乘法：*=
        result *=a;//相当于result=result*a
        System.out.println(result);
        //除法：/=
        result /=a;//相当于result=result/a
        System.out.println(result);
    }
}

1.2.9自增、自减运算符

package edu.bdqn.kg;

public class Demo11 {
    public static void main(String[] args) {
//        自增运算符：++      自减运算符：--
        int a = 1;
        int b = 1;
        a++;
        b--;
        System.out.println(a+" "+b);
    }
}

1,一般自增自减都单独放一行，不会对其他变量产生影响。

2，如果自增自减和其他运算符放在一行，自增自减运算符优先级高于其他运算符优先级

1.2.9.1自增、自减运算符（2）

package edu.bdqn.kg;

public class Demo12 {
    public static void main(String[] args) {
        int a = 2;
        int b = 2;
        int c;
//        c=a+b++;//++在后先运算c=a+b,再计算b++（--于此相同）
        c=a*++b;//++在前先运算++b,再计算c=a*b（--于此相同）
        System.out.println(a+""+b+""+c);
    }
}

1.2.10关系运算符（比较运算符）

**比较两个数大小关系，比较结果true/false,所以接受结果需要boolean类型的变量 **

符号有： == != < > >= <=

优先级排序： > < >= <= == !=

支持的数据类型：> < >= <= 这四个判断只支持数值类型的数据

1.2.10.1 关系运算符比较字符串

如何比较字符串是否相等？

eg：”abc“ “acb” “abc” 使用方法进行比较，对字符串进行比较 s1.equals(s3) 使用 ==进行比较，比较的是内存地址

1.2.11 逻辑运算符

逻辑运算符 && || ！

逻辑与&&：运算符左右两边都为真，最终结果才为真。 逻辑或||：运算符左右两边都为假，最终结果才为假。 非 ！：逻辑取反

特点：1.左右两边的值是boolean类型的值 true/false。

​ 2.短路：如果在逻辑与的左边判断是假，右边不执行（短路与）。如果在逻辑或的左边判断是真，右边不执行（短路或）。

​ 3.逻辑运算结果是boolean。

1.2.12条件运算符

package edu.bdqn.kg;

public class Demo16 {
    public static void main(String[] args) {
        /**
         * 条件 ? 表达式1 :  表达式2
         * 注意：
         * 1.条件表达式 结果必须是boolean
         * 2.条件为true 返回表达式1
         * 3.表达式false 返回表达式2
         */
         //判断一个数是否为偶数。
        int a=10;
        System.out.println(a%2==0?"是偶数":"是奇数");
    }
}

优先级：首先是小括号”（）“，接着是”!“和自增”++“自减”–“运算符，然后是算数运算符”*,/,+,-“,接下来是关系运算符”<,>,<=,>=,==,!=“，紧接着是逻辑运算符”&&，||“，最后是赋值运算符”=“

1.3流程语句

1.3.1if–else语句(单分支流程)

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        //张浩的成绩
        System.out.println("请输入您的成绩。");
        Scanner input = new Scanner(System.in);
        int Score= input.nextInt();
        //分支结构 需要将后面的代码使用花括号包起来，否则只对下一句产生效果
        if (Score>90) {
            //满足上述if后面的条件之后才会执行
            System.out.println("奖励他一部手机");
        }
        else {
            //不满足上述if后面的条件才会执行
            System.out.println("给他两个大嘴巴子");
        }
    }
}

if语句中的变量需要判断字符串时需要用“.equals()”包起来，（“.equals”返回值是布尔“boolean”类型）

package edu.bdqn.kg;

import java.util.Scanner;

public class Lianxi {
    public static void main(String[] args) {
        System.out.println("明天天气预报怎么样？");
        Scanner input = new Scanner(System.in);
        String weather= input.next();
        if (weather.equals("晴天")) {
            System.out.println("我们去郊游");
        }
        else {
            System.out.println("我们在教室内敲代码。");
        }
    }
}

1.3.1.1if–else语句(多分支流程)

注意：1.前面的分支条件，不能包含后面的分支条件。

package edu.bdqn.kg;

import java.util.Scanner;

public class Demo03 {
    public static void main(String[] args) {
        System.out.println("请输入您的成绩");
        Scanner input = new Scanner(System.in);
        double score=input.nextDouble();
        //定义scanner扫描器
        if (score >=80) {
            System.out.println("良好");
        } else if (score >=70) {
            System.out.println("中等");
        } else if (score >=60) {
            System.out.println("及格");
        }else {
            System.out.println("去死");
        }
    }
}

1.3.2 switch-case语句（等值多分支流程）

特点：1.判断条件值，是具体的值而不是模糊的区间范围。 2.其他和区间值多分支结构类似。

注意：1.switch（表达式），表达式的变量类型:int String char,不可以放：boolean float double

​ 2.表达式的类型需要和case常量类型一致。 3.default为默认情况可以放在任意位置，但是一般情况下放最后，亦可省略。

​ 4.每一个case完成需要有break，但是break不是必须要加，如果不加会执行下一个case分支

package edu.bdqn.kg;

import java.util.Scanner;

public class Demo05 {
    public static void main(String[] args) {
        System.out.println("你是第几名");
        Scanner scanner = new Scanner(System.in);
        int n=scanner.nextInt();
        switch (n){
            case 1:
                System.out.println("优秀");
                break;
            case 2:
                System.out.println("良好");
                break;
            case 3:
                System.out.println("合格");
                break;
            default:
                System.out.println("差");
                break;
        }
    }
}

1.3.3嵌套if语句

package edu.bdqn.kg;

import java.util.Scanner;

public class Demo06 {
    public static void main(String[] args) {
        /**
         * 嵌套if结构，判断第一个if的条件才会进行下面的判断。
         */
        System.out.println("您跑步的成绩为");
        Scanner scanner = new Scanner(System.in);
        double second=scanner.nextDouble();
        if (second <10 ) {
            System.out.println("恭喜您，进入决赛。请输入你的性别");
            String sex= scanner.next();
            if (sex.equals("男")) {
                System.out.println("欢迎进入男子组");
            }else if (sex.equals("女")) {
                System.out.println("欢迎进入女子组");
            }
        }else {
            System.out.println("很遗憾您被淘汰了。");
        }
    }
}

1.4循环

循环的特点：1.重复 2.相同或类似的操作

1.4.1while循环

while：在条件上面坐文章 条件是变值，并且操作步骤会改变条件情况，如果不想出现无限循环需输入循环终止条件。

package edu.bdkn.kg;

public class Demo01 {
    public static void main(String[] args) {
        int i =1;
        while (i<=9/*循环条件*/){
            i++;
            System.out.println("xx是傻子！！！！");//循环体
        }
    }
}

1.4.2do_while循环

do_while循环至少需要执行一次

package edu.bdkn.kg;

import java.util.Scanner;

public class Demo03 {
    public static void main(String[] args) {
        System.out.println("请输入你的考号：");
        Scanner scanner = new Scanner(System.in);
        double score = scanner.nextDouble();
        do{
            System.out.println("拿到实验，编写程序");
            System.out.println("老师打分");
            double score1=scanner.nextDouble();
            if (score1>60) {
                score=score1;
                System.out.println("考试通过。");
            }else if (score1<=60){
                score=score1;
                System.out.println("重新考试");
            }
        }while (score<=60/*循环限定条件*/);//判断结果是不是符合循还条件，如果符合则会进入小学换
    }
}

1.4.3for循环

package edu.bdkn.kg;

public class Demo05 {
    public static void main(String[] args) {
        /**
         * for循环执行流程：
         * 1.执行括号的第一条语句，该语句作为初始化操作。
         * 2.执行括号第二条语句，作为循环判断条件，如果判断失败不进入循环体。
         * 3.条件判断成功，进入循环体{}，执行循环体{}里面的语句。
         * 4.执行括号第三条语句，作为改变循环条件。接着重复上述2-3-4步骤，直到不满足2的条件结束循环。
         * 注意：在循环体内遇到continue或break关键字，特殊处理
         */
        for (int i=1;i<=1000;i++){
            if (i%5==0){
                System.out.println("能被5整除的数："+i);
            }
        }
    }
}

1.4.3.1for循环（嵌入continue）

package edu.bdkn.kg;

public class Demo06 {
    public static void main(String[] args) {
        for (int i=1;i<=10;i++){
            if (i%2!=0){
                continue;//跳过if语句中的限定条件
            }
            System.out.println("1-10中的偶数有:"+i);
        }
    }
}

1.4.3.1for循环（嵌入break）

break语句只是跳出了本循环不影响其他循环

package edu.bdkn.kg;

public class Demo08 {
    public static void main(String[] args) {
        for (int i = 0; i <=10; i++) {
            if (i==8) {
                System.out.println("骨折，退出比赛");
                break;//跳出  在循环体遇到break语句，直接跳出循环，执行循环外的语句。
            }
            System.out.println("跑了"+i+"圈");
        }
        System.out.println("程序结束");
    }
}