Java学习笔记（1）Java基础语法

这里不需要看，以后会慢慢提到的

数据类型：boolean、int、long、short、byte、float、double、char、class、interface。
流程控制：if、else、do、while、for、switch、case、default、break、continue、return、try、catch、finally。
修饰符：public、protected、private、final、void、static、strict、abstract、transient、synchronized、volatile、native。
动作：package、import、throw、throws、extends、implements、this、supper、instanceof、new。
保留字：true、false、null、goto、const。

提示：由于 Java 区分大小写，因此 public 是关键字，而 Public 则不是关键字。但是为了程序的清晰及可读性，要尽量避免使用关键字的其他形式来命名。

常量值

常量值：在程序执行的过程中，其值不可以发生改变

整数常量值，超过int范围的必须加L或l（小写L）
小数常量值，无论多少，不加F，就是double类型。要表示float类型，必须加F或f
char常量值，必须使用单引号
String字符串常量值，必须使用双引号

public class ConstantDemo {
	public static void main(String[] args) {		
		//输出整数常量值
		System.out.println(12);
		System.out.println(-23);
        System.out.println(2352654566L);
		
		//输出小数常量值
        System.out.println(12.34F);
		System.out.println(12.34);
		
		//输出字符常量值
		System.out.println('a');
		System.out.println('0');
        System.out.println('尚');
		
		//输出布尔常量值
		System.out.println(true);
		System.out.println(false);
        
        //输出字符串常量值
		System.out.println("HelloWorld");
	}
}

变量

1.变量的概念

变量：在程序执行的过程中，其值可以发生改变的量

变量的作用：用来存储数据，代表内存的一块存储区域，这块内存中的值是可以改变的。

2.变量的声明

//存储一个整数类型的年龄
int age; 

//存储一个小数类型的体重
double weight;

//存储一个单字符类型的性别 
char gender;

//存储一个布尔类型的婚姻状态
boolean marry;

//存储一个字符串类型的姓名
String name;

//声明多个同类型的变量
int a,b,c; //表示a,b,c三个变量都是int类型。

3.变量的赋值

变量名 = 值;

给变量赋值，变量名必须在=左边，值必须在=右边

给变量赋的值类型必须与变量声明的类型一致或兼容（<=）

基本数据类型转换

1.自动类型转换（隐式类型转换）

自动转换：将取值范围小的类型自动提升取值范围大的类型

（1）当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时。

int i = 'A';//char自动升级为int，其实就是把字符的编码值赋值给i变量了
double d = 10;//int自动升级为double

byte b = 127; //右边的整数常量值必须在-128~127范围内
//byte bigB = 130;//错误，右边的整数常量值超过byte范围
long num = 1234567; //右边的整数常量值如果在int范围呢，编译和运行都可以通过，这里涉及到数据类型转换
long bigNum = 12345678912L;//右边的整数常量值如果超过int范围，必须加L，否则编译不通过

（2）当存储范围小的数据类型与存储范围大的数据类型一起混合运算时，会按照其中最大的类型运算。

int i = 1;
byte b = 1;
double d = 1.0;

double sum = i + b + d;//混合运算，升级为double

（3）当byte,short,char数据类型进行算术运算时，按照int类型处理。

byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2;//编译报错，b1 + b2自动升级为int

char c1 = '0';
char c2 = 'A';
System.out.println(c1 + c2);//113

2.强制类型转换（显示类型转换）

强制类型转换：将取值范围大的类型强制转换成取值范围小的类型。

转换格式 ：数据类型变量名 = （数据类型）被强转数据值; //()中的数据类型必须<=变量的数据类型，一般都是=

（1）当把存储范围大的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围小的变量时，需要强制类型转换，提示：有风险，可能会损失精度或溢出

int i = (int)3.14;//强制类型转换，损失精度

double d = 1.2;
int num = (int)d;//损失精度

int i = 200;
byte b = (byte)i;//溢出

（2）当某个值想要提升数据类型时，也可以使用强制类型转换

int i = 1;
int j = 2;
double shang = (double)i/j;

3.基本数据类型与字符串类型的转换

1、任意数据类型的数据与String类型进行“+”运算时，结果一定是String类型

System.out.println("" + 1 + 2);//12

2、但是String类型不能通过强制类型()转换，转为其他的类型

String str = "123";
int num = (int)str;//错误的
int num = Integer.parseInt(str);//后面才能讲到，借助包装类的方法才能转

流程控制语句

1.顺序结构

顺序结构就是程序从上到下逐行地执行。表达式语句都是顺序执行的。并且上一行对某个变量的修改对下一行会产生影响。

public class TestStatement{
	public static void main(String[] args){
		int x = 1;
		int y = 2;
		System.out.println("x = " + x);		
        System.out.println("y = " + y);	
        //对x、y的值进行修改
        x++;
        y = 2 * x + y;
        x = x * 10;	
        System.out.println("x = " + x);
        System.out.println("y = " + y);
    }
}

2.输入输出语句

输出语句

换行输出语句：输出内容后进行换行，格式如下：
System.out.println(输出内容);//输出内容之后，紧接着换行
不换行输出语句：输出内容后不换行，格式如下
System.out.print(输出内容);输出内容之后不换行

示例代码：

public class TestPrintlnAndPrint {
    public static void main(String[] args) {
        String name = "柴林燕";
        int age = 18;

        //对比如下两组代码：
        System.out.println(name);
        System.out.println(age);

        System.out.print(name);
        System.out.print(age);
        System.out.println(); //()里面为空，效果等同于换行，输出一个换行符
        //等价于 System.out.print("\n"); 或  System.out.print('\n');
        //System.out.print();//错误，()里面不能为空   核心类库PrintStream类中没有提供print()这样的方法

        //对比如下两组代码：
        System.out.print("姓名：" + name +",");//""中的内容会原样显示
        System.out.println("年龄：" + age);//""中的内容会原样显示

        System.out.print("name = " + name + ",");
        System.out.println("age = " + age);
    }
}

输入语句

1.各种类型的数据输入

import java.util.Scanner;
//如果在.java源文件上面没有这句import语句，
//那么在代码中每次使用Scanner就要用java.util.Scanner的全名称，比较麻烦

/*
键盘输入代码的四个步骤：
1、申请资源，创建Scanner类型的对象
2、提示输入xx
3、接收输入内容
4、全部输入完成之后，释放资源，归还资源

如果你在键盘输入过程中，遇到java.util.InputMismatchException异常，
说明你输入的数据，其类型与接收数据的变量的类型不匹配。
 */
public class Test05Input {
    public static void main(String[] args) {
        //1、准备Scanner类型的对象
        //Scanner是一个引用数据类型，它的全名称是java.util.Scanner
        //input就是一个引用数据类型的变量了，赋给它的值是一个对象（对象的概念我们后面学习，暂时先这么叫）
        //new Scanner(System.in)是一个new表达式，该表达式的结果是一个对象
        //引用数据类型  变量 = 对象;
        //这个等式的意思可以理解为用一个引用数据类型的变量代表一个对象，所以这个变量的名称又称为对象名
        //我们也把input变量叫做input对象
        Scanner input = new Scanner(System.in);//System.in默认代表键盘输入
        //这里变量名是input，下面就用input

        //2、提示输入xx
        System.out.print("请输入一个整数：");

        //3、接收输入内容
        int num = input.nextInt();
        System.out.println("num = " + num);

        //列出其他常用数据类型的输入
        /*
        long bigNum = input.nextLong();
        double d = input.nextDouble();
        boolean b = input.nextBoolean();
        String s = input.next();
        char c = input.next().charAt(0);//先按照字符串接收，然后再取字符串的第一个字符（下标为0）
        */

        //释放资源
        input.close();
    }
}

2、next()与nextLine()

import java.util.Scanner;

/*
next()方法：
	遇到空格等空白符，就认为输入结束
nextLine()方法：
	遇到回车换行，才认为输入结束
 */
public class Test08NextAndNextLine {
    public static void main(String[] args) {
        //申请资源
        Scanner input = new Scanner(System.in);

        System.out.print("请输入姓名：");
        //String name = input.next();//张 三  只能接收张，后面的空格和三无法接收，被下面的输入接收
        String name = input.nextLine();
        System.out.println("name = " + name);

        System.out.print("请输入年龄：");
        int age = input.nextInt();	//23回车换行  这里只接收23，回车换行被下面的输入接收
        input.nextLine();//读取23后面的回车换行，但是这个不需要接收，只有下面一个输入是nextLine()情况下才需要这样，如果下面的输入是next()或者是nextInt(),nextDouble()等就不需要这么干
        System.out.println("age = " + age);

        System.out.print("请输入电话号码：");
        String tel = input.nextLine();
        System.out.println("tel = " + tel);

        //释放资源
        input.close();
    }
}

分支语句

单分支条件判断：if

if(条件表达式)｛
  	语句体;
｝

案例：从键盘第一个小的整数赋值给small，第二个大的整数赋值给big，如果输入的第一个整数大于第二个整数，就交换。输出显示small和big变量的值。

import java.util.Scanner;

public class Test09If {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.print("请输入第一个整数：");
        int small = input.nextInt();

        System.out.print("请输入第二个整数：");
        int big = input.nextInt();

        if (small > big) {
            int temp = small;
            small = big;
            big = temp;
        }
        System.out.println("small=" + small + ",big=" + big);

        input.close();
    }
}

双分支条件判断：if...else

if语句第二种格式： if...else

if(关系表达式) {
语句体1;
}else {
语句体2;
}

案例：从键盘输入一个整数，判定是偶数还是奇数

import java.util.Scanner;

public class Test10IfElse {
    public static void main(String[] args){
        // 判断给定的数据是奇数还是偶数
        Scanner input = new Scanner(System.in);

        System.out.print("请输入整数：");
        int a = input.nextInt();

        if(a % 2 == 0) {
            System.out.println(a + "是偶数");
        } else{
            System.out.println(a + "是奇数");
        }

        input.close();
    }
}

多分支条件判断：if...else if

if (判断条件1) {
  	执行语句1;
} else if (判断条件2) {
  	执行语句2;
}
...
}else if (判断条件n) {
 	执行语句n;
} else {
  	执行语句n+1;
}

switch...case多分支选择结构

switch(表达式){
    case 常量值1:
        语句块1;
        【break;】
    case 常量值2:
        语句块2;
        【break;】   
    。。。
   【default:
        语句块n+1;
        【break;】
     】
}

执行过程：

（1）入口

①当switch(表达式)的值与case后面的某个常量值匹配，就从这个case进入；

②当switch(表达式)的值与case后面的所有常量值都不匹配，寻找default分支进入;不管default在哪里

（2）一旦从“入口”进入switch，就会顺序往下执行，直到遇到“出口”，即可能发生贯穿

（3）出口

①自然出口：遇到了switch的结束}

②中断出口：遇到了break等

循环语句

for循环语句格式：

for(初始化语句①; 循环条件语句②; 迭代语句④){
	循环体语句③
}

执行流程：

第一步：执行初始化语句①，完成循环变量的初始化；

第二步：执行循环条件语句②，看循环条件语句的值是true，还是false；

如果是true，执行第三步；

如果是false，循环语句中止，循环不再执行。

第三步：执行循环体语句③

第四步：执行迭代语句④，针对循环变量重新赋值

第五步：根据循环变量的新值，重新从第二步开始再执行一遍

关键字break

使用场景：终止switch或者当前循环

在选择结构switch语句中

在循环语句中

离开使用场景的存在是没有意义的

案例：从键盘输入一个大于1的自然数，判断它是否是素数提示：素数是指大于1的自然数中，除了1和它本身以外不能再有其他因数的自然数，即某个素数n，在[2,n-1]范围内没有其他自然数可以把n整除

import java.util.Scanner;

public class Test04Break {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.print("请输入一个整数：");
        int num = input.nextInt();

        boolean flag = true;//假设num是素数
        //找num不是素数的证据
        for(int i=2; i<num; i++){//i<=Math.sqrt(num);
            if(num % i ==0){//num被某个i整除了，num就不是素数
                flag = false;
                break;//找到其中一个可以把num整除的数，就可以结束了，因为num已经可以判定不是素数了
            }
        }

        //只有把[2,num-1]之间的所有数都检查过了，才能下定结论，num是素数
        if(num >1 && flag){
            System.out.println(num + "是素数");
        }else{
            System.out.println(num + "不是素数");
        }
    }
}

while循环

1、while循环语句基本格式：

while (循环条件语句①) {
    循环体语句②；
}

执行流程：

第一步：执行循环条件语句①，看循环条件语句的值是true，还是false；
- 如果是true，执行第二步；
- 如果是false，循环语句中止，循环不再执行。
第二步：执行循环体语句②；
第三步：循环体语句执行完后，重新从第一步开始再执行一遍

关键字：continue

使用场景：提前结束本次循环，继续下一次的循环

分析如下代码运行结果：

public class Test10Continue {
    public static void main(String[] args) {
        for(int i=1; i<=5; i++){
            for(int j=1; j<=5; j++){
                if(i==j){
                    continue;
//                    break;
                }
                System.out.print(j);
            }
            System.out.println();
        }
    }
}

使用continue提高效率

public class Test10Continue {
    public static void main(String[] args) {
        //找出1-100之间所有的素数（质数）
        for(int i=2; i<=100; i++){
            if(i!=2 && i%2==0 || i!=5 && i%5==0){//偶数一定不是素数，
                continue;
            }

            //里面的代码会运行100遍
            //每一遍i的值是不同的，i=2,3,4,5...100
            //每一遍都要判断i是否是素数，如果是，就打印i
			/*
			如何判断i是否是素数
			（1）假设i是素数
			boolean flag = true;//true代表素数
			（2）找i不是素数的证据
			如果在[3,i-1]之间只要有一个数能够把i整除了，说明i就不是素数
			修改flag = false;
			这里从3开始找，是因为我们前面排除了偶数
			（3）判断这个flag
			*/
            //（1）假设i是素数
            boolean flag = true;//true代表素数
            //（2）找i不是素数的证据
            for(int j=3; j<i; j++){  // j<=Math.sqrt(i);
                if(i%j==0){
                    flag = false;//找到一个就可以了
                    break;
                }
            }
            //（3）判断这个flag
            if(flag){
                System.out.println(i);
            }
        }
    }
}