Java语言基础

Java关键字和标识符 关键字：

下面就是Java的关键字，将来会逐一学习到

标识符：

1. 所有的标识符的首字符都应该以字母（大小写），美元符号，下划线开始
2. 首字符之后可以是字母，美元符号，下划线或数字的任何字符组合
3. 不能使用关键字作为变量名或方法名
4. 标识符的大小写敏感的
5. 可以使用中文命名（不建议）

编程规范

1. 所有变量、方法、类名 见名如意
2. 类成员变量（类变量和实例变量）：首字母小写和驼峰原则：monthSalary
3. 局部变量：首字母小写和驼峰原则
4. 常量：大写字母和下划线：MAX_VALUE
5. 类名：首字母大写和驼峰原则：Man，GoodMan
6. 方法名：首字母小写和驼峰原则

变量

1. 每个变量都有类型，类型可以是基本类型，也可以是引用类型（String）
2. 变量名必须是合法的标识符
3. 变量声明是一条完整的语句，因此每一个声明都必须以分号结束

例子

package com.zhou.base;

public class Demo08 {

    //实例变量:从属于对象;如果不自行初始化，基本类型的默认值 一般为 0 0.0
    //布尔值:默认是false
    //除了基本类型，其余的都是null
    //main方法
    String name;
    int age;

    //类变量 static
    static double salary = 2500;

    public static void main(String[] args) {

        //局部变量:必须声明和初始化值
        int i = 10;
        System.out.println(i);

        //实例变量  变量类型 变量名字 =new demo08();
        Demo08 q = new Demo08();
        q.age = 1;
        q.name = "qinjiang";
        System.out.println(q.age);
        System.out.println(q.name);



        //类变量 static
        System.out.println(salary);

        q.add();

    }
    //其他方法
    public void add(){
        //System.out.println(i);
        Demo08 demo08 = new Demo08();
        demo08.age = 18;
        demo08.name = "zhouxiang";
        System.out.println(demo08.age);
        System.out.println(demo08.name);

        System.out.println(salary);
    }
}

基本数据类型

1. 整数类型

   byte占一个字节 范围：-128~127

   short占两个字节 范围：-32768~32767

   int占四个字节

   long占8个字节（数字后面加个L）

2. 浮点类型

   float占四个字节（数字后面加个F）

   double占八个字节

3. 字符类型

   char占两个字节

4. 布尔型

   占一位（bit） 其值只有true和false两个

例子：

package com.zhou.base;

public class Demo02 {
    public static void main(String[] args) {
        //八大基本数据类型
        byte num1 = 1;
        int num2 = 20;
        short num3 = 45;
        long num4 = 45L;

        float num5 =50.1F;
        double num6 =1.1;
         char name = 'q';
         //字符串 ，String不是关键字，类
        //布尔值
        boolean flag = true;
        boolean flag1 = false;
        System.out.println();
    }
}

拓展

![2](C:Users周先生Desktopcsdn2.png)package com.zhou.base;

public class Demo03 {
    public static void main(String[] args) {
        //整数拓展： 进制 二进制0b 十进制 八进制0 十六进制0x
        int i =10;
        int i2 =010;
        int i3 =0x10;
        System.out.println(i);//10
        System.out.println(i2);//8
        System.out.println(i3);//16
        //==============================
        //浮点数拓展 银行业务怎么表示
        //BigDecimal 数学工具类
        //==============================


        float f =0.1F;//0.1
        double d = 1.0/10; //0.1
        System.out.println(f==d);//false

        float f1 = 323232332323F;
        float f2 = f1 + 1;
        System.out.println(f1==f2);//true
        //float 有限 离散 舍入误差  接近但不等于
        //double
        //最好完全使用浮点数进行比较
        //最好完全使用浮点数进行比较
        //最好完全使用浮点数进行比较

        //==============================
        //字符拓展
        //==============================
        char c1 = 'A';
        char c2 = '中';
        System.out.println(c1);
        System.out.println((int)c1);
        System.out.println(c2);
        System.out.println((int)c2);
        //所有的字符本质还是数字
        //转义字符
        // t  制表符
        // n 换行


        String sa = new String("hello world");
        String sb = new String("hello world");
        System.out.println(sa==sb);//false


        String sc = "hello world";
        String sd = "hello world";
        System.out.println(sc==sd);//true
        //对象 从内存分析

        //布尔值扩展
        boolean flag = true;
        if (flag){};//与下方一样
        if (flag==true){};
    }
}

基本数据类型的转换

低到高叫：自动类型转换

高到低叫：强制类型转换

例子

package com.zhou.base;
public class Demo05 {
    public static void main(String[] args) {
        int i =128;
        byte b = (byte) i;
        //强制转换 （类型）变量名 高---低
        //自动转换  低---高
        System.out.println(i);//128
        System.out.println(b);//-128  原因是内存溢出 byte最大是127
        
        System.out.println((int)23.7);//23
        System.out.println((int)-23.7f);//-23


        char c = 'a';
        int d = c+1;
        System.out.println(d);
        System.out.println((char)d);
    }
}

拓展

操作比较大的数的时候，注意溢出问题

package com.zhou.base;

public class Demo06 {
    public static void main(String[] args) {
        //操作比较大的数的时候，注意溢出问题
        //JDK新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 20;
        int total = money*years;//-1474836480，计算的的时候溢出了
        long total2 = money*years;//同样是上述数字，转换之前都已存在问题

        long total3 = money*(long)years;//先把一个数转换为Long
        System.out.println(total3);
    }
}

运算符

1. 算术运算符：+，-，*，/，%，++，–
2. 赋值运算符：=
3. 关系运算符：>,<,>=,<=,==,!=instanceof
4. 逻辑运算符：&&(and)，||(or)，！(非)
5. 位运算符：&，|，^，~，>>,<<,>>>
6. 条件运算符？：
7. 扩展赋值运算符：+=，-=,*=,/=
8. 三目运算符

简单的例子就没举，下面是一些我认为比较重要的和难点

例子1：自增和自减

package com.zhou.operator;

public class Demo04 {
    public static void main(String[] args) {
        //++ -- 自增，自减
        int a = 1;
//        int b = a++;
//        System.out.println(a);//2
//        System.out.println(b);//1
//        //可以看出++ 在后面 就是 先给b赋值 再自增


        int c = ++a;
        System.out.println(a);
        System.out.println(c);
        //可以看出++ 在前面 就是 先自增 再赋值给c

        //幂运算
        //很多运算，我们会使用一些工具类
        double pow = Math.pow(2, 3);
        System.out.println(pow);
    }
}

例子2：短路运算

package com.zhou.operator;

public class Demo05 {
    public static void main(String[] args) {
        //逻辑运算符
        //与（and）     或(or)      非(取反)
        boolean a = true;
        boolean b = false;
        System.out.println(a&&b);//全真为真
        System.out.println(a||b);//有真为真
        System.out.println(!b);//取反

        //短路运算
        int c = 5;
        boolean d = (c<4) && (c++<4);
        System.out.println(d);
        System.out.println(c);
    }
}

例子3：位运算

![3](C:Users周先生Desktopcsdn3.png)package com.zhou.operator;

public class Demo06 {
    public static void main(String[] args) {
        

        
        System.out.println(2<<3);
    }
}

例子4：三目运算符

package com.zhou.operator;

public class Demo08 {
    public static void main(String[] args) {
        //三元运算符
        //x ? y : z
        //如果x==true，结果为y,否则为z
        int score = 80;
        String type = score < 60 ? "不及格" : "及格";//必须掌握
        System.out.println(type);

    }
}

例子5：字符串连接运算符

package com.zhou.operator;

public class Demo07 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        a+=b;//a = a+b
        a-=b;//a = a-b
        System.out.println(a);
        //字符串连接符 +
        System.out.println("对的"+a+b);
        System.out.println(a+b+"");
        //String类型在前面就会转换为int

        //双引号中的内容是字符串，会直接打印出双引号中的内容
        System.out.println("a+b=" + (a+b)); //"a+b=22
    }
}

包机制

JavaDoc

1.选择是整个项目还是模块还是单个文件

2.文档输出路径

3.Locale 选择地区，这个决定了文档的语言，中文就是zh_CN

4.传入JavaDoc的参数，一般这样写 -encoding UTF-8 -charset UTF-8 -windowtitle “文档HTML页面标签的标题” -link http://docs.Oracle.com/javase/7/docs/api

用户交互Scanner

通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据

next();

1. 一定要读取到有效字符后才可以结束输入
2. 对输入有效字符之前遇到的空白，next（）方法会自动将其去掉
3. 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
4. next（）不能得到带有空格的字符串

package com.zhou.scanner;

import java.util.Scanner;

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();
    }
}

nextLine();

1. 以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符
2. 可以获得空白

package com.zhou.scanner;

import java.util.Scanner;

public class Demo02 {
    public static void main(String[] args) {
        //从键盘接收数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用nextLine方式接收:");
        //判断是否还有输入
        if (scanner.hasNextLine()){
            String str = scanner.nextLine();
            System.out.println("输出的内容为："+str);
        }
        scanner.close();
    }
}

练习

输入多个数字，并求其总和与平均数，每输入：

package com.zhou.scanner;

import java.util.Scanner;

public class Demo05 {
    public static void main(String[] args) {
        //我们可以输入多个数字，并求其总和与平均数，每输入
        //一个数字用回车确定，通过输入非数字来结束输入并输出其执行结果
        Scanner scanner = new Scanner(System.in);

        //和
        double sum = 0;
        //计算输入了多少个数字
        int number = 0;
        System.out.println("请输入：");
        //通过循环判断是否还有输入，并在里面对每一次进行求和和统计
        while(scanner.hasNextDouble()){
            double v = scanner.nextDouble();
            number++;
            sum+=v;
            System.out.println("你输入了第"+number+"个数据，当前的总和是"+sum);
        }
        //平均数
        double j = sum/number;
        System.out.println("总和："+sum);
        System.out.println("平均值"+j);
        scanner.close();

    }
}

分支语句

一共有三种结构

第一种：if结构：满足条件时执行语句，不满足则不执行(一条路)。

第二种：if…else结构：满足条件执行语句，不满足则执行另外的语句(两条路)。

第三种：if…else if结构：多个条件，满足不同条件执行不同语句(多条路)。

例子：

第一种

package com.zhou.struct;

import java.util.Scanner;

public class IfDemo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入内容：");
        String s = scanner.nextLine();

        //equals：判断字符串是否相等
        if (s.equals("Hello")){
            System.out.println(s);
        }
        System.out.println("End");
        scanner.close();
    }
}

第二种

package com.zhou.struct;

import java.util.Scanner;

public class IfDemo02 {
    public static void main(String[] args) {
        //考试分数大于60就是及格，小于60就不及格。
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入考试分数:");
        double v = scanner.nextDouble();
        if(v>=60){
            System.out.println("及格");
        }else{
            System.out.println("不及格");
        }
        scanner.close();
    }
}

第三种

package com.zhou.struct;

import java.util.Scanner;

public class IfDemo03 {
    public static void main(String[] args) {
        
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入考试分数:");
        double v = scanner.nextDouble();
        if(v==100){
            System.out.println("恭喜满分");
        }else if(v<100&&v>=90){
            System.out.println("A级");
        }else if(v<90&&v>=80){
            System.out.println("B级");
        }else if(v<80&&v>=70){
            System.out.println("C级");
        }else if(v<70&&v>=60){
            System.out.println("D级");
        }else if(v<60&&v>=0){
            System.out.println("不及格");
        }else{
            System.out.println("成绩不合法");
        }
        scanner.close();
    }
}

循环结构

第一种：for循环的语法格式为： for(初始化; 布尔表达式; 更新){//代码语句 };

关于for循环有以下几点说明：
最先执行初始化步骤，可以声明一种类型，但可初始化一个或多个循环控制变量
，也可以是空语句。然后检测布尔表达式的值，如果是true，循环体被执行；如果是false，
循环体终止；开始执行循环体后面的语句。执行一次循环后，更新循环控制变量（迭代因子控制循环变量的增减）
再次检测布尔表达式，循环执行上面的过程。

例子

计算0到100之间的奇数和偶数和

package com.zhou.struct;

public class ForDemo02 {
    public static void main(String[] args) {
        //计算0到100之间的奇数和偶数和
        int sum1 = 0;
        int sum2 = 0;
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                sum1+=i;
            }else{
                sum2+=i;
            }
        }
        System.out.println("偶数和："+sum1);
        System.out.println("奇数和："+sum2);
    }
}

用while或for循环输出1-1000之间能被5整除的数

package com.zhou.struct;

public class ForDemo03 {
    public static void main(String[] args) {
        //用while或for循环输出1-1000之间能被5整除的数，
        //并且每行输出3个
        int i = 1;
        while (i<=1000){
            if (i%5==0){
                System.out.print(i+"t");
            }
            if (i%(5*3)==0){
                System.out.println();
//                System.out.print("n");
            }
            i++;
        }
    }
    //println 输出会换行
    //print 输出不换行
}

打印九九乘法表

package com.zhou.struct;

public class ForDemo04 {
    public static void main(String[] args) {
        //打印九九乘法表

        for (int a = 1; a <= 9 ; a++) {
            for (int b = 1; b <= a; b++) {
                System.out.print(b+"*"+a+"="+(a*b)+"t");
            }
            System.out.println();
        }
    }
}

拓展：掺入了数组

package com.zhou.struct;

public class ForDemo05 {
    public static void main(String[] args) {
        int[] numbers = {10,20,30,40,50};

        for (int i = 0;i<5;i++){
            System.out.println(numbers[i]);
        }
        System.out.println("====================");
        //遍历数组的元素
        for(int x:numbers){
            System.out.println(x);
        }
    }
}

第二种：While是最基本的循环，循环的语法格式为：

while(布尔表达式 ){

//循环内容 }

只要布尔表达式为 true，循环就会一直执行下去。

例子

计算1-100

package com.zhou.struct;

public class WhileDemo02 {
    public static void main(String[] args) {
        //计算1-100
        int i = 0;
        int sum = 0;
        while (i<101){
            sum+=i;
            i++;

        }
        System.out.println(sum);
    }
}

第三种：do…while循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。循环的语法格式为：do{ //代码语句 }while(布尔表达式);

例子

计算1-100

package com.zhou.struct;

public class DoWhileDemo01 {
    public static void main(String[] args) {
        //计算1-100
        int i = 0;
        int sum = 0;
        do {
            sum+=i;
            i++;
        }while (i<101);
        System.out.println(sum);
    }
    }

验证dowhile和while的差距

package com.zhou.struct;

public class DoWhileDemo02 {
    public static void main(String[] args) {
        int a = 0;
        while (a>1){
            System.out.println(a);
            a++;
        }
        System.out.println("=============================");
        do {
            System.out.println(a);
            a++;
        }while (a<0);
    }
}

第四种：switch…case结构：一种特殊的分支结构，用于判断整数String类型，需要配合break使用(多条路)。

例子

1

package com.zhou.struct;

public class SwitchDemo01 {
    public static void main(String[] args) {
        //case穿透 switch匹配一个具体的值
        char grade = 'C';


        switch (grade){
            case 'A':
                System.out.println("优秀");
                break;
            case 'B':
                System.out.println("良好");
                break;
            case 'C':
                System.out.println("及格");
                break;
            case 'D':
                System.out.println("再接再厉，挂科");
                break;
            default:
                System.out.println("未知等级");
        }
    }
}

2

package com.zhou.struct;

public class SwitchDemo02 {
    public static void main(String[] args) {
        String name = "秦疆";

        //JDK7的新特性，表达式结果可以是字符串
        //字符的本质还是数字

        switch (name){
            case "狂神":
                System.out.println("狂神");
                break;
            case "秦疆":
                System.out.println("秦疆");
                break;
            default:
                System.out.println("I don't known");
        }
    }
}

break和continue

break

package com.zhou.struct;

public class SwitchDemo02 {
    public static void main(String[] args) {
        String name = "秦疆";

        //JDK7的新特性，表达式结果可以是字符串
        //字符的本质还是数字

        switch (name){
            case "狂神":
                System.out.println("狂神");
                break;
            case "秦疆":
                System.out.println("秦疆");
                break;
            default:
                System.out.println("I don't known");
        }
    }
}

continue

package com.zhou.struct;

public class ContinueDemo01 {
    public static void main(String[] args) {
        int i = 0;
        while (i < 100) {
            i++;
            if (i % 10 == 0) {
                System.out.println("1");
                continue;
            }
            System.out.print(i + "t");
        }
    }
}

区别

break在任何循环语句的主体部分，均可用break控制循环的流程
break用于强行退出循环，不执行循环中剩余的语句（break语句
也在switch语句中使用）
continue 语句用在循环语句体中，用于终止某次循环过程
即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定

方法

什么是方法

1. 是解决一类问题的步骤的有序组合
2. 包含于类或对象中
3. 在程序中创建，在其他地方被引用

设计方法的原则：一个方法只完成一个功能

方法的定义

()小括号里面还有参数类型和参数名

public就是修饰符

解释：

修饰符：static public 等

返回值类型：int void（空）

方法名：骆峰

参数类型：int 等

方法体：定义该方法的功能

return：返回值类型不是void 就需要return 返回值；

break,continue和return的区别

break; 和 continue; 这两个语句主要是用来控制循环的，跟方法没有关系。

return; 和以上的两个语句不是一个级别的，return;是用来终止当前方法的。

方法调用：

当方法返回一个值的时候，方法调用通常被当做一个值，例如

int larger = max(30,40);

如果方法返回值是void，方法调用一定是一条语句

System.out.println(“Hello，kuangshen!”);

值传递（Java）

引用传递

例子

package com.zhou.method;

public class Demo01 {
    //main方法
    public static void main(String[] args) {
        //实际参数：实际调用传递给他的参数
        int sum = add(1, 1);
        System.out.println(sum);
    }
    //加油
    //形式参数，用来定义作用的
    public static int add(int a,int b){
        return a+b;
    }
}

方法重载

重载就是在一个类中，有相同的函数名称（方法名），但形参不同的函数（方法）

方法重载的规则：

1. 方法名称必须相同
2. 参数列表必须不同（个数不同，或类型不同，或参数排列顺序不同等）
3. 方法的返回类型可以相同也可以不相同
4. 仅仅返回类型不同不足以成为方法的重载

package com.zhou.method;

public class Demo02 {
    public static void main(String[] args) {
        double aaa = min(3.1, 2.3);
        System.out.println(aaa);

    }
    //比大小
    //方法重载
    public static double min(double num1,double num2){
        double result;

        if (num1==num2){
            System.out.println("num1==num2");
            return 0;//终止方法
        }
        if (num1>num2){
            result = num1;
        }else {
            result = num2;
        }
        return result;
    }
    //比大小
    public static int min(int num1,int num2){
        int result;

        if (num1==num2){
            System.out.println("num1==num2");
            return 0;//终止方法
        }
        if (num1>num2){
            result = num1;
        }else {
            result = num2;
        }
        return result;
    }
}

可变参数

使用规范:一个方法中只能指定一个可变s参数，它必须是方法的最后一个参数。任何普通的参数必须在他之前申明

package com.zhou.method;

public class Demo04 {
    public static void main(String[] args) {
        //调用可变参数的方法
        printMax(33,4,34,23,53,0,12,43);
    }
    public static void printMax(double... numbers){
        if (numbers.length==0){
            System.out.println("No argument passed");
            return;
        }
        double result = numbers[0];
        //排序
        for (int i = 1;i < numbers.length;i++){
            if (numbers[i]>result) {
                result = numbers[i];
            }
        }
        System.out.println("the max value is:"+result);
    }
}

递归

递归就是方法自己调用自己，在编写的时候一定要有一个结束条件，否则将会造成StackOverflowError的错误。

递归结构包括两个部分：

1. 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
2. 递归体：什么时候需要调用自身方法

package com.zhou.method;

public class Demo05 {
    public static void main(String[] args) {
        System.out.println(f(5));
    }
    public static int f(int n){
        if (n==1){
            return 1;
        }else {
            return n*f(n-1);
        }
    }
}

命令行传参

有时候你希望运行一个程序时候在传递给他消息。这要靠传递命令行参数给main（）方法（函数）实现

package com.zhou.method;

public class Demo03 {
    public static void main(String[] args) {
        //args.length 数组长度
        for (int i = 0;i< args.length;i++){
            System.out.println("args["+i+"]:"+args[i]);
        }
    }
}