华清远见重庆中心—JAVA基础阶段技术总结/个人总结

m0_70552692

已于 2023-02-26 15:41:06 修改

阅读量186

点赞数

文章标签： java 开发语言 jvm

于 2022-12-26 23:17:21 首次发布

本文链接：https://blog.csdn.net/m0_70552692/article/details/128446183

版权

Java基础知识总结

摘要由CSDN通过智能技术生成

概述

1995年 Java问世，1996年 JDK 1.0，2009年 Oracle以超过70亿美元交易总值收购了Sun
java之父：James Gosling Oak
Java特点：简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。

Java的分类

JavaME（Java2 Micro Edition，Java2平台的微型版），主要应用于嵌入式系统开发，如机顶盒、移动电话和PDA之类嵌入式消费电子设备。
javaSE（Java 2 Standard Edition，Java 2平台的标准版），主要应用于桌面应用软件的编程。
javaEE（Java 2Enterprise Edition，Java 2平台的企业版），主要应用于分布式的网络程序的开发，如电子商务网站和ERP系统。

jdk的安装

JDK --- Java Development Kit （Java 开发工具包）

JRE --- Java Runtime Environment （Java 运行环境）

JVM --- Java Virtual Machines （Java 虚拟机）
java的技术体系架构：安装jdk的时候，主要安装的是java se相关内容。

Java的第一个程序

public class Hello {
    public static void main(String[] args) {
        System.out.println("Helloword");
    }
}

Java语言需要先编译然后解释运行

编写的Java文件(.java)要先经过编译，生成字节码文件(.class),java程序的运行需要jvm的支持为字节码文件提供运行环境。jvm是一个软件，安装在操作系统中。
Java源文件(.java) → java字节码文件(.class)→JVM→ 操作系统

Java的编译期和运行期

编译期：通过Javac命令编译源程序，编译(.java文件)生成字节码文件(.class)
运行期：通过Java命令启动jvm加载.class文件然后运行.class文件

Java的跨平台

Java的一大特点跨平台：实现"一处编译，到处使用"。Java有一个核心：JVM，Java Virtual Machine(Java虚拟机)，它用于解释Java的字节码文件。Java官方提供了针对不同平台的JVM软件，这些JVM遵循相同的标准，只要是标准的.class文件，就可以在不同的操作系统上运行，且运行结果一样。

编写Java程序的注意事项

Java的每一个程序都要创建class类，这是jdk指定的规则。
Java的每一个程序都有一个main方法，称为主函数或入口函数，是程序启动的依赖。
Java中严格区分大小写和中英文字符等，程序中涉及的符号（[]、()、{}）必须是成对出现的。

标识符 ：为 ”变量、类（接口）、方法“ 进行命名的符号

1、标识符的开头只能以_、$、字母
2、标识符的中间和结尾以_、$、字母、数字为主要内容
3、不能以关键字或者特殊字符命名,(长度、大小写、换行)
4、见名知意(对变量进行特殊的名称定义，会帮助我们或者其他开发者理解程序功能,翻译软件)

1、驼峰法 我的苹果 ==> my apple ==> myApple MyApple
首写字母小写 ：小驼峰法  主要用于变量、方法命名
首写字母大写 ：大驼峰法  主要用于类 或者接口命名
2、下划线隔断法  我的苹果 ==> my_apple

Java中的语句注释

单行注释快捷键：ctrl + /

//123abc

多行注释快捷键：ctrl+shift+/

/*123abc
12245
58525*/

文档注释

/**
123abc
12245
58525
 */

Java变量

变量：是指在内存中的一块存储空间，用于存储程序运算过程中需要用到的数据

变量的定义

变量声明的语法规则：变量类型变量名字=初始值;

Java变量	变量的定义	未经声明的变量不能使用
		一条语句中声明多个同类型变量，用逗号隔开
	变量的命名	名字必须符合Java标识符语法规则,可以由字母、数字、_、$组成首字母不能以数字开头、区分大小写命名时需要注意、不能使用 Java保留字。
		见名知意，驼峰命名法，避免中文
	变量的初始化	未经初始化的变量不能使用
		定义时初始化初次使用前初始化
	变量的使用和访问	可以对变量的值进行存取和操作
		变量操作需遵守定义时的数据类型

变量相关代码

package day2;
//定义（声明）变量
public class vardemo {
    public static void main(String[] args) {
        //1.定义变量
        int a ; //定义一个整形变量a
        a = 100 ; //“=”： 表示给变量赋值
        int b ;
        b = 200 ;
        int c = a + b ;
        System.out.println("c:" + c);
        //2.定义变量的时候，直接给变量赋值
        String birth = "2000-10-10";
        //int a = 22 ; //编译错误：同一个代码区域内，不允许变量名重复
        int age = 22 ;
        System.out.println("你出生于：" + birth  + ",今年" + age + "岁");
        //3.未经声明的变量不能使用
        //address = "看DNF"; 编译错误，未经声明的变量不能直接使用
        String address ;//声明变量
        address = "在看放空单费";
        //4.一条语句声明多个变量
        int a1 , a2 , a3 ;
        //System.out.println(a1 + a2 + a3);//编译错误：没有初始化的变量，不能直接做加法运算。
        a1 = 5 ;
        a2 = 6 ;
        a3 = 7 ;
        System.out.println("和：" + (a1+a2+a3));
        int b1= 7 ,b2= 8 ,b3=9 ;
        System.out.println("和：" + (b1+b2+b3));
        //5.变量名规则
        int $ = 100;
        int _ = 200;
        //int * = 300;//编译错误：变量名只能包含数字 字符 _  $,并且不能是纯数字
        String name = "alice";
        //System.out.println(Name);//编译错误:严格区分大小写
        //int int = 2022111;//编译错误：不能用关键字作为变量名
        String englishName = "张老师";//这里不是驼峰命名法：第一和单词首字母大写，后续单词首字母小写

    }
}

Java中的关键字

abstract	assert	boolean	break	byte	continue
case	catch	char	class	const	double
default	do	extends	else	enum	final
finally	float	for	goto	long	if
implements	import	native	new	null	istanceof
int	interface	package	private	protected	public
return	short	static	strictfp	super	switch
synchronized	this	while	void	throw	throws
transient	try	volatile

Java中的交接班数据类型

类型名称	字节空间	类型说明
byte	一个字节（8位）	存储一个字节数据
short	两个字节（16位）	兼容性考虑，一般不用
int	四个字节（32位）	存储整数（常用）
long	八个字节（64位）	存储长整数（常用）
float	四个字节（32位）	存储浮点数
double	八个字节（16位）	存储双精度浮点数（常用）
char	两个字节（8位）	存储一个字符

整形int

int是最常用的整数类型：4个字节（32位）最大表示范围：-2147483648~2147483647
整数类型的直接量(literal)默认是int类型。
两个int整数相除(/)，结果取整，舍弃小数部分（非四舍五入），结果还是整数。
整数运算要防止溢出 -整数运算的过程中，运算结果，如果超过了整数能表示的最大范围，会发生溢出。正数过大溢出，结果变为负数；负数过小溢出，结果变为正数。
int类型代码

package day2;
//int数据类型介绍
public class lntDemo {
    public static void main(String[] args) {
        //1.int的数据是占4个字节
        int a = 10000 ;
        System.out.println("a:" + a);//输出变量a
        //int a1 = 10000000000;//编译错误：超过了int的最大范围
        int b = 1500000000;
        int c = 1500000000;
        int sum = b + c ;//和超过了int的最大值
        System.out.println("sum:" + sum);//sum:-1294967296,这里溢出了。并没有啥错但是结果不准确
        //2.直接量
        int k = 100 ;//这里的100就是直接量
        System.out.println("k十进制：" + k);
        int k1 = 0x100 ;
        System.out.println("k1十六进制：" + k1);
        int k2 = 0100 ;
        System.out.println("k2是8进制" + k2);
        //3.int数据的运算：+ - * /(取整) %(取余)
        int a1 = 9 ;//定义变量
        int a2 = 4 ;
        int c1 = a1 + a2;//c1=13
        int c2 = a1 - a2;//c2=5
        int c3 = a1 * a2;//c3=36
        int c4 = a1 / a2;//取整：Java程序中规定，两个整数的运算结果只能是整数（9/4 等于2）
        System.out.println("c4:" + c4);
        int c5 = a1 % a2;//取余：获取两个数相除的余数
        System.out.println("c5:" + c5);

        if(a1 % 2 == 0){//a1 % 2 == 0 判断是否相等，结果是true或false
            System.out.println(a1 + "是偶数");
        }else{
            System.out.println(a1 + "是奇数");
        }
        //除法的练习，计算百分比
        int current= 33;
        int total = 50;
        System.out.println("第一种：");
        System.out.println(current / total * 100 + "%");
        System.out.println("第二种：");
        System.out.println(current *100 / total + "%");
    }
}

长整型long

如果要表示的整数已经超过了int的范围，那么可以用long类型定义变量，保存数据。
long类型（8个字节，64位）数据范围：-9223372036854775808~9223372036854775807
long类型直接量的表示，需要在数据后面加一个L或l;
通过long类型来存储系统当前毫秒数，jdk提供了一个方法（ System.currentTimeMillis() ）,来获取从1970.1.1日零时至今的毫秒数，返回结果为long.
对于较大的整数运算(超出int范围)，可以使用long型。
long长整型代码

package day2;
//long：长整型，8个字节，如果int的数据范围不够，可以使用long
public class LongDome {
    public static void main(String[] args) {

        //1.定义long类型的变量
        long a1 = 100;
        //java中直接量默认为int类型
        //long a2 = 10000000000;//超过了int的范围，所有导致编译错误
        long a2 = 1000000000L ;//在直接量后，添加“L”或“l”的标志，表示这个直接量是long类型

        //2.时间毫秒数
        //练习：自己计算一年的毫秒数
        //long micro = 365L * 24 * 60 * 60 * 1000 ;//全部都是int类型参与运算，结果就是int类型，超过int范围就溢出
        long micro = 365L * 24 * 60 * 60 * 1000 ;
        System.out.println("一年的毫秒数：" + micro);

        //3.获取系统的毫秒数：七点为1970.1.1 0:0:0距离此刻的时间毫秒数
        long time = System.currentTimeMillis();
        System.out.println("距今的时间毫秒：" + time);

    }
}

double & float 类型

浮点类型就是小数类型，包含double 和 float。
浮点类型的默认直接量是double类型。
如果要使用float类型，需要在数据后面加F或f。
double类型的精度比float类型的精度高，因此，一般用double类型。
eg: float f1 = 3.3F; double money = 3.5;
double类型数据运算的时候，会有舍入误差。由于舍入误差，导致浮点数不能精确运算。二进制中无法表示1/10，就像十进制中无法精确表示1/3，所以二进制表示浮点数存在误差
代码

package day2;
//double - 双精度浮点型（8个字节）
//float - 单精度浮点型（4个字节）
public class DoubleDemo {
    public static void main(String[] args) {
        //1.定义变量
        double a1 = 3.5;
        //float a2 = 3.5;//编译错误：java中的浮点数直接量默认是double类型，不能将double直接复制给float
        float a2 = 3.5F ;//直接量的后面，使用“F”或"f"，让直接量为float类型
        //2.double用于计算：+ - * / %
        double a3 = 1.5;
        System.out.println(a1 + a3);//5.0
        System.out.println(a1 - a3);//2.0
        System.out.println(a1 * a3);//5.25
        System.out.println(a1 / a3);//2.3333333333335
        System.out.println(a1 % a3);//0.5

        double a4 = 1.4;
        System.out.println(a3 - a4);//0.10000000000000009

        //3.练习：计算自由落体运动的位移：s= 1/2 * g * t * t
        double g = 9.8;
        int t = 5;
        double s;
        s = 0.5 * g * t * t;//运算数据有double类型，因此整体的结构是double类型
        System.out.println("位移为：" + s);
    }
}

char类型

字符类型实质上是一个16位的无符号整数，这是整数对应的字符编码
Java字符类型采用Unicode字符集编码。Unicode字符编码是国际上通用的定长字符集，所有字符都是16位。
字符直接量，可以采用字符的形式，比如‘中 ’；或者采用Unicode编码的方式，如：‘\u4e4d’
字符是整数可以参与运算，比如 char c = ‘A’ ; int a = 10 + c ;//75
字符直接量赋值
整数赋值(0~65535)
Unicode编码赋值
eg: char a = ‘A’; char a = 65; char a = ‘\u0045’;
转义字符（\）:对于不方便输出的字符，采用转义字符表示。

转义符	含义	Unicode值
\b	退格	\u0008
\n	换行	\u000a
\r	回车	\u000d
\t	制表符（tab）	\u0009
\"	双引号	\u0022
\'	单引号	\u0027
\\	反斜杠	\u005c

代码

package day2;
//char - 字符，本质就是一个整数
public class CharDemo {
    public static void main(String[] args) {
        //1.定义字符类型的变量
        char a = 'A';
        System.out.println(a);
        //char b ='AB';//编译错误：字符只能是单个
        //2.字符的本质就是整数
        //字符和整数的对应关系，一般称为编码表
        //比如ascii码表、utf-8编码表、gbk编码表
        int b = a ;//这里把a的编码对应的整数，赋值给变量b
        System.out.println(b);//65
        int c = '中';//'中'对应的编码，赋值给c
        //3.字符的表达方式
        char d = '0';
        char d1 = 48 ;
        char d2 = '\u0048';
        System.out.println(d + ":" + d1 + ":" + d2);
        //4.字符的运算
        char d3 = '0';
        char d4 = '9';
        System.out.println(d4-d3);
        //5.字符范围
        //char c2 = -5;//编译错误：字符都是正整数，这里比最小值还小
        //char c3 = 1000000;//编译错误：超过了字符的最大值(65535)
        int k = 100000;
        //char c4 = k ;//只能吧整数的直接量赋值给字符，不能把int变量赋值给字符
        short k1 = 300;
        //char c5 = k1;
        //6.转义字符：程序中的特殊字符，如果要输出，可以使用“\ + 字符”方式，然后输出这个内容
        System.out.println("孔子说:\"学而时习之。\"");
        System.out.println("3\t+\t5\t=\t8");




    }
}

数据类型案列：bmi指数计算

package day2;

import java.util.Scanner;

//BMI的公式=体重（kg）/身高（m）*身高（m）
public class BMIDemo {
    public static void main(String[] args) {
        //要求：让用户输入姓名、体重、身高，然后根据用户输入的数据，计算bmi指数，然后输出bmi指数
        Scanner scanner = new Scanner(System.in);
        double bmi , h , w ;
        System.out.println("请输入你的姓名：");
        String name = scanner.next();//输入字符串
        System.out.println("请输入你的身高(m)：");
        h = scanner.nextDouble();//nextDouble：用于double类型数据
        System.out.println("请输入你的体重(kg)：");
        w = scanner.nextDouble();
        //计算bmi
        bmi = w / (h * h);
        System.out.println(name + ",你的bmi：" + bmi);
    }
}

boolean类型

boolean类型即布尔类型，适用于逻辑运算，在程序流程控制中作为条件判断。
boolean类型的值只有两个：true/false，不能用0或非0代替true/false.
boolean类型不能与整数类型做转换。
代码

package day3;
//boolean - 布尔：true（真）、false（假）
public class BooleanDemo {
    public static void main(String[] args) {
        //1.定义变量
        //Java中规定boolean类只有两个值：true、false
        boolean a = true ;//true就是一个直接量
        boolean b = false ;//false就是一个直接量
        //boolean c = 1 ;//编译错误:1不是boolean类型，不能赋值给变量c
        //2.布尔运算：逻辑运算
        //&&:与运算  ||:或运算   !:非运算
        boolean c = a && b ;//c=false
        c = a || b ; //c=true
        c = !a ;//c=false
        //3.boolean类型主要用于条件判断
        int age = 19 ;
        boolean d = age > 18 ;//age>18 结果是true，所以d=true
        if(d){//if....else 就是在判断boolean的数据值，如果为真就输出成年人，如果为假就输出未成年
            System.out.println("成年人.");
        }else{
            System.out.println("未成年.");
        }
    }
}

数据类型之间的转换

自动数据类型转换（隐式转换）：小类型自动转为大类型。
强制数据类型转换：从大类型转到小类型需要强制转化，可能会有精度损失或者溢出。
数据类型从小到大：byte→ short（char）→int→ long→ float→ double
代码

package day3;
//--数据类型转换
//  自动类型转换
//  强制类型转换
public class DataTypeDemo {
    public static void main(String[] args) {
        //1.自动类型转换
        long a1 = 100;//自动类型转换：直接量是int类型，a1是long类型。说明这里是自动类型转换
        //2.强制类型转换
        //int a2 = 3.6;//编译错误:3.6是double类型，a2是int类型，不能直接转换
        int a2 = (int)3.6;//强制数据类型转换：在数据3.6前面添加（int）告诉程序把3.6转换为int
        System.out.println("a1:" + a1);//100
        System.out.println("a2:" + a2);//3
        //3.强制造成精度损失或溢出
        double d = 3.1415926666666 ;
        float d1 = (float)d;
        System.out.println("精度损失：" + d1);

        long data = 1000000000L;
        int  data1 = (int)data;
        System.out.println("溢出：" + data1);
        //4.byte，short两种数据
        byte b1 = 100;//自动类型转换
        //short s1 = 200;//编译错误：超过了byte的范围
        //short s1 = 100;
        //short s2 = 100000000;//编译错误：超过了short的范围
        byte b2 = 5;
        //byte b3 = b1+b2;//编译错误：数据类型不匹配，因为Java中的运算byte和short都会转换为int的结果。
        byte b3 = (byte)(b1 + b2);//表示吧运算结果进行强制转换
        System.out.println("b3:" + b3);
        //5.面试题
        short aa1 = 5;
        short aa2 = 5;
        //short aa3 = aa1 + aa2;  编译错误：short参与运算的时候，转换为int，运算的结果就是int，int类型不能直接赋值给short
        short aa3 = (short)(aa1+aa2);
        short aa4 = 5 + 5; //这里可以，是因为编译的时候，这里的5+5是直接量的运算，已经计算出结果为10,10可以赋值给short类型
        //一天的毫秒数
        long time = 24 * 60 * 60 * 1000;//这里全部都是直接量，所有编译器会将结果算出来赋值给time

        //6.练习
        //a.定义一个long类型的变量，然后赋值给double类型的变量
        long l1 = 10;
        double l2 = l1;//自动类型转换
        //b.定义一个char类型的变量，然后赋值给short类型
        char l3 = ' ';
        short l4 = (short)l3;//强制数据类型转换
        //c.定义一个float类型的变量，然后赋值给int类型
        float l5 = 0.5F;
        int l6 = (int)l5;
        //d.定义一个boolean类型的变量，然后赋值给byte类型
        boolean l7 = true;
        //byte l8 = l7; 编译错误：boolean不能转换为整形
    }
}

Java算数运算符

Java中的算数运算符，包含：+（加），-（减），*（乘），/（除）,%（取余），++（自增）,--(自减)。

两数相除：1、两数都是整数类型，求整数商
         2、两数任意一个是浮点数，求浮点数的商

++（自增），--（自减）运算是在自身值的基础上，增加或者减少1
++i，写在变量的前面，运算的时候，需要先增加或者减少1，再参与运算。
i++，写在变量的后面，运算的时候，需要先参与运算，再增加或者减少1。
“+”,“-”,可以作为数据正负符号。
代码

package day3;
//算数运算符：+、-、*、/、%
//          ++(自增)、--(自减)
//          符号（+、-）
//能做算数运算的类型：byte、short、int、long、char、float、double
//不能做算数运算的类型：boolean、其他复杂类型
public class SuanShuDemo {
    public static void main(String[] args) {
        //1.加法（减法、乘法）运算
        long data1 = 10;
        double data2 = 3.5;
        double data3 = data1 + data2;//运算结果以大范围为准
        System.out.println("data3:" + data3);//13.5
        //2.除法运算
        double data4 = data1/3 * data2 ;//运算结果以大范围为准
        System.out.println("data4:" + data4);//10.5
        data4 = 1/2; //0.0:这里1、2都是int类型，所以结果为0.但是吧int的数据赋值给double类型，所有最终值是0.0
        System.out.println("data4:" + data4);
        data4 = 1/2.0;
        System.out.println("data4:" + data4);
        //3.取余（%）运算
        long m = data1 % 3 ;//如果m是0，表示能整除，如果m不是0，表示不能整除。
        boolean k = m ==0 ; //m==0：表示判断m是否为0，是结果为true，不是结果为false
        System.out.println("k:" + k);//k:false
        //4.++(--)运算：在原来的数据上增加1或者减少1
        int i = 5;
        i ++ ;//自增：i = i+1;
        System.out.println("i:" + i);//6
        i -- ;//自减：i = i-1;
        System.out.println("i:" + i);//5
        /*
        int j = ++ i ;//前自增：先对i进行增加，然后把增加之后的数据值，赋值给变量j
        System.out.println("i:" + i +", j=" + j);//i=6,j=6
        */
        int j = i ++ ;//后自增：先把i的数据值赋值给变量j，然后再对i增加1
        System.out.println("i:" + i +", j=" + j);//i=6,j=5

        int i1 = i++ + j++ + i--;


        //5.符号（+，-）
        int m1 = -5 ;//负号
        int m2 = +5;//正号
        int m3 = -5-5 ;
        System.out.println("m3:" + m3);//-10
        int m4 = -5 + -10 ;
        System.out.println("m4:" + m4);//-15
        int m5 = -5 + +10;
        System.out.println("m5:" + m5);//5
    }
}

Java关系运算符

Java中的关系运算符，包含：>（大于）、<（小于）、==（等于）、>=（大于等于）、<=（小余等于）、!=（不等于）。
关系运算的结果为boolean类型。
代码

package day3;
//关系运算：
//      大于(>)、大于等于(>=)、等于(==)、不等于(!=)、小于(<)、小于等于(<=)
//      能进行关系运算：byte、short、int、long、char、 float、double
//      不能进行关系运算：boolean、其他的引用类型
public class GuanXiDemo {
    public static void main(String[] args) {
        //1.关系运算的结果是boolea类型
        int a = 100;
        int b = 200;
        boolean r = a > b ;//关系运算：r是false
        char c = '中';
        char c1 = '国';
        if(c > c1){//c > c1:如果条件满足，那么就是true否则就是false
            System.out.println("中的编码值大于国的编码值");
        }else{
            System.out.println("中的编码值小于国的编码值");
            //2.等于（==）
            int a1 = 10;
            int a2 = 20;
            //int a3 = a1==a2;//编译错误：a1==a2是条件运算，结果是boolean类型，不能赋值给int类型
            int a3 = a2 = a1;//"="是赋值运算
            System.out.println("a1:" + a1 + ",a2:" + a2 + ",a3:" + a3);
            //3.练习：定义两个整数，找到两个整数中最大的那个
            a1 = 30;
            a2 = 50;
            boolean b1 = a1 >= a2 ;//赋值运算符的优先级最低，先做其他运算，最后赋值
            if(b1){
                System.out.println("a1大：" +a1);
            }else{
                System.out.println("a2大：" +a2);
            }
        }
    }
}

Java逻辑运算符

&& “与”运算
|| “或”运算
！“非”运算
逻辑运算的结果为boolean类型。

与或的混合判断
逻辑与 的优先级高于 逻辑或，所以先执行与运算。
注意：非运算 高于”与，或“运算。（仅次于括号的优先级）

代码

package day3;
//逻辑运算：与&&、||或、！非
//运算规则：与运算（全为真这结果为真，有假则结果为假）
//        或运算（全为假这结果为假，有真则结果为真）
//        非运算（真变假，假变为真，本质就是取反）
//逻辑运算的结果是boolean值
//能做逻辑运算类型：boolean
//不能做逻辑运算的类型：除了boolean类型，都不能做逻辑运算

//短路逻辑：&&、||  指当我们能够判断出运算结果的时候，后续的表达式不在执行。--常用短路逻辑
//不短路逻辑：&、|   每个参与运算的表达式都需要执行。--不常用
public class LuoJiDemo {
    public static void main(String[] args) {
        //1.运算
        boolean b1 = true;
        boolean b2 = true;
        boolean b3 = false;
        boolean b4 = b1 && b2 ;//true
        b4 = b1 && b2 && b3;//false
        b4 = b1 || b3;//true
        b4 = b1 || b2 ||b3;//true
        b4 = !b3;//true
        b4 = !(b1||b2);//false
        b4 = !(b1 && b3) || b3;//true

        //2.短路逻辑
        int a = 3, b = 5;

        /*
        boolean b5 = a > b && a++ >1 ;//a>b是false，那么与（&&）运算的结果确定出来时false，这里用的是“短路与（&&）”，所有后面
                                        //a++>1的表达式不会被执行到，因此最终a还是3
        System.out.println("a:" +a); a是3

         boolean b5 = a > b & a++ >1;//&不是短路与，整个运算的所有表达式都要执行
         System.out.println("a:" + a);//a是4

         boolean b6 = a<b || a++>0;//a<b结果是true，“短路非(||)运算”，后面的a++>0不会判断
        System.out.println("a:" +a);//a是3
         */

        boolean b6 = a > b || a++>0;//a>b结果是false，或运算的结果不定，因此判断a++>0的情况
        System.out.println("a:" +a);//a是4
    }
}

赋值运算符和扩展赋值运算符

赋值运算符“=”是最常用的赋值运算。它将“=”右边的运算结果的值，赋给“=”左边的变量。例如：i = 6；
赋值运算符的优先级很低。（低于算数运算符）
在赋值运算符的前面，加入算数运算符，即为扩展赋值运算符： +=，-=，*=，/=，%=

“+” 字符串拼接

运算符“+”，用于数据类型，加法运算。还可以用于字符串型，字符串拼接运算。
字符串（String）+ 数据，java中会自动将数据转为字符串，然后两个字符串相连，生成一个新的字符串。

三目运算符

三目运算符格式: X ? Y : Z; boolean表达式?表达式1 ：表达式2；
X为boolean表达式，如果X为true,在运算结果为Y的值，如果X为false，则运算结果为Z的值。

java运算符的优先级

y扩展赋值运算、三目运算和字符串拼接代码:

package day3;
//1.“=”：赋值运算
//2.+=、*=、/=、%=  扩展的赋值运算符：表示变量的数据取出来和其他数据进行运算，然后把运算结果赋值给变量
//3.“+”：用于字符串拼接
//4.三目运算：?: , 语法规则：boolean ? 表达式1 : 表达式2. , boolean值为true，执行表达式1，否则执行表达式2
public class OtherYunSuanDemo {
    public static void main(String[] args) {
        //1.扩展的赋值运算符号
        int k = 10 ;
        k += 20 ;//这里的k+=20完全等价于k=k+20，所以k=30
        System.out.println("k:" + k);

        k /= 4 ;//k=k/4,所以k=7
        System.out.println("k:" + k);
        //2.“+”：用于字符串拼接
        String str =  "hello";
        System.out.println( k + k + str);//"14hello"
        System.out.println( k + str + k);
        System.out.println( str + k + k);
        System.out.println( str + (k+k));
        System.out.println( (str+k) + k + k);
        System.out.println( str + k + k);
        System.out.println( k + k + k + k);
        //三目运算
        int age = 19;
        String info = age >= 18 ? "成年人" : "未成年人" ;//需要吧三目运算的结果赋值给一个变量保存起来
        System.out.println("你现在：" + age + "岁，你是：" + info);
    }
}

案列：三目运算符找最大值

package day3;

import java.util.Scanner;

//用三目运算，判断出用户输入的两个数据中最大的那个
public class MaxData {
    public static void main(String[] args) {
        //boolean ? 表达式1 ： 表达式2
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数：");
        int data1 = sc.nextInt();
        System.out.println("请在输入一个数：");
        int data2 = sc.nextInt();
        int max = data1 < data2 ? data2: data1;
        System.out.println("两个数中较大的是：" + max);

    }
}

Java程序的结构

任何复杂的程序都是由"顺序结构"、"分支结构"、"循环结构"组成
顺序结构：程序从上到下一句一句执行
分支结构：程序设计根据指定的条件进行分支, 根据某个结果选择运行
循环结构：根据给定的条件反复进行循环，直到条件不成立为止

分支结构

Java 语法中的分支结构包含以下四种，分支结构可以嵌套使用

if //如果…
if……else…… //如果…否则…
if…….else if……. //如果…否则如果…..
switch……case…… //switch….情况1…情况2…..
if...else代码：

package day4;

import java.util.Scanner;

//练习：用户输入1-7的整数，然后程序转换“星期几”
public class IfElseManyDemo1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.printf("请输入1-7的数据：");
        int x = sc.nextInt();
        if(x < 0 || x > 7) {
            System.out.printf("输入的数据不合理，请重新输入");
        }else{
            if (x == 1) {
                System.out.printf("本天是星期一");
            } else if (x == 2) {
                System.out.printf("本天是星期二");
            } else if (x == 3) {
                System.out.printf("本天是星期三");
            } else if (x == 4) {
                System.out.printf("本天是星期四");
            } else if (x == 5) {
                System.out.printf("本天是星期五");
            } else if (x == 6) {
                System.out.printf("本天是星期六");
            } else if (x == 7) {
                System.out.printf("本天是星期日");
            }
        }
    }
}

import java.util.Scanner;

public class Work02 {

    //计算BMI指数
    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);
        System.out.println("请输入身高(米):");
        double height = scan.nextDouble();
        System.out.println("请输入体重(千克):");
        double weight = scan.nextDouble();

        double bmi = weight / (height * height);

        System.out.println(bmi);
        if(bmi < 18.5){
            System.out.println("偏瘦");
        }else if(bmi < 24){
            System.out.println("正常");
        }else{
            System.out.println("偏胖");
        }

    }

}

switch代码

package day4;

import java.util.Scanner;

//switc ... case的语法规则
//switch(变量) {
//  case 数值1：...
//  case 数值2：...
//  default：...
//  }
public class SwitchDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.printf("请输入数据值1~7:");
        int week = sc.nextInt();
        switch (week){
            case 1:
                System.out.printf("星期一");
                break; //break:中断Java中的关键字，这里表示执行完case之后，整个Switch语句块结束
            case 2:
                System.out.printf("星期二");
                break; //break:中断Java中的关键字，这里表示执行完case之后，整个Switch语句块结束
            case 3:
                System.out.printf("星期三");
                break;
            case 4:
                System.out.printf("星期四");
                break;
            case 5:
                System.out.printf("星期五");
                break;
            case 6:
                System.out.printf("星期六");
                break;
            case 7:
                System.out.printf("星期日");
                break;
            default:
                System.out.printf("数据不合理，请重新输入。");
        }
    }
}

package day4;

import java.util.Scanner;

public class SwitchDemo2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("*******ATM*********");
        System.out.println("*******0.取钱*********");
        System.out.println("*******1.存钱*********");
        System.out.println("*******2.查询*********");
        System.out.println("*******3.转账*********");
        System.out.println("*******4.退卡*********");
        int num = sc.nextInt();
        switch (num){
            case 0:
                System.out.println("取钱成功！");
                break;
            case 1:
                System.out.println("存钱成功！");
                break;
            case 2:
                System.out.println("查询成功！");
                break;
            case 3:
                System.out.println("转账成功！");
                break;
            case 4:
                System.out.println("退卡成功！");
                break;
            default:
                System.out.println("操作失败");
        }
    }
}

循环结构：for循环

循环是程序设计语言中反复执行某些代码的一种计算机处理过程，是一组相同或相似的语句被有规律地执行。
循环三要素：循环变量初始化、循环条件（以循环变量为判断条件）、循环变量的改变（向着循环结束变）
for循环是最经典的循环语法，也是程序使用最多的循环方式。
for循环语法规则：for(表达式1;表达式2;表达式3){语句块}

表达式 1 ：初始化表达式，负责完成循环条件的初始化

表达式 2 ：循环条件表达式，值为 boolean 的表达式，指定循环条件

表达式 3 ：循环后的操作表达式，负责修改变量，改变循环条件
for循环流程：执行语句1，再判断boolean表达式，如果为true，继续执行，如果boolean表达式为false则执行语句2

代码

public class Work03 {

    //水仙花数
    // 三位数分别求三次幂的和 是自己本身
    public static void main(String[] args) {

        for(int a = 1; a <= 9; a++){
            for(int b = 0; b <= 9; b++){
                for(int c = 0; c <= 9; c++){
                    if(a * 100 + b * 10 + c == a * a * a + b * b * b + c * c * c){
                        System.out.println(a * 100 + b * 10 + c);
                    }
                }
            }
        }
    }

}

public class Work05 {

//    * 5、抛小球
//    *   以一个高度抛出小球，小球弹起高度的一半后，再次下落
//    *   当小球弹了n次，它距离地面的距离为多少。
     // 求小球总共走了多长距离
    public static void main(String[] args) {

        int n = 6;
        double h = 100;
        double sum = 0;
        for(int i = 0; i < n; i++){
            sum += h;
            //特殊：从右往左运算.
            sum += h = h / 2;
        }
        System.out.println(sum);
    }

}

package day4;
//计算1+2+3....+100的和
public class SunDemo {
    public static void main(String[] args) {
        int sum = 0;//保存和，0不影响加法运算的结果
        for (int i=1 ; i<=100 ; i++){
            sum +=i ;//sum +=i:sum=sum+i,每一次重复做的事
        }
        System.out.println("1+....100:" + sum);

        //练习：1+1/2+1/3....+1/888的和
        double sum1 = 0;//保存和，0不影响加法运算的结果
        for (int i=1 ; i<=888 ; i++){
            sum1 +=1.0 / i ;//sum +=i:sum=sum+i,每一次重复做的事
        }
        System.out.println("1+1/2+1/3....1/888:" + sum1);
    }
}

for循环执行顺序

while循环代码

package day4;
//while循环的语法规则
//while（boolean）{
//   语句块
// }
public class WhileDemo {
    public static void main(String[] args) {
        //1.输出1*9=9到9+9=81
        int num = 1;//循环的初始变量
        while (num <=9){//循环的条件
            System.out.println(num + "* 9 =" + (num * 9));//循环执行的语句块
            num ++ ;//循环的初始变量的变化
        }
        //2.练习：输出自己的名字20次
        int num1 = 1;
        while(num1 <= 20){
            System.out.println("tom" + num1);
            num1++;
        }
        //练习：输出1~100中能被3整除的数据
        int x = 1;
        while (x<=100){
            if(x%3==0){
                System.out.println(x);
            }
            x++;
        }
        //
    }
}

案列：猜数字

package day4;

import java.util.Scanner;

public class GuessData {
    public static void main(String[] args) {
        //1.产生一个随机整数[0,100]
        int data = (int)(Math.random()*100);
        System.out.println("data:" + data);
        //2.输入数据的功能
        Scanner sc = new Scanner(System.in);
        //3.循环让用户输入数据，然后对比大小直到用户输入正确
        while (true) {//while的条件为true的时候，表示这个while循环会一直执行，一般称为“死循环”
            //我们可以循环代码块中做条件判断，符合某种条件的时候，就利用break结束循环
            System.out.println("请输入一个整数[0-100]:");
            int input = sc.nextInt();
            if (input > data) {
                System.out.println("太大了，小一点");
            } else if (input < data) {
                System.out.println("太小了，大一点");
            } else {
                System.out.println("恭喜你，猜对了");
                break;//循环结束
            }
        }
    }
}

do.....while循环

while循环先判断，再执行； do…while先执行一次，再判断。 While循环比do…while循环用得多。
循环没有指定结束条件的情况下会造成死循环也就是无限循环
do...while代码

package day5;

import java.util.Scanner;

//do{ 语句 }while(条件);特点是循环体至少执行一次
public class DoWhileDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
//        int num ;
//        do{
//            System.out.println("请输入一个数据：");
//            num = scanner.nextInt();
//        }while (num != 30);



        //练习:输入密码(123456)解锁手机，只能输入5次，超过5次了就提示用户过半个小时在尝试
        int count = 0;//记录次数
        int pwd;
        do{
            if(count == 6){
                System.out.println("抱歉你的次数已用完，请半小时后在尝试");
                //break;//结束循环
                return;//结束整个程序的运行
            }
            System.out.println("请输入密码：");
            pwd = scanner.nextInt();
            count ++;//改变输入的次数
        }while (pwd != 1234656);
        System.out.println("手机解锁成功了");
    }
}

break & continue

break可用于循环语句或switch语句。
break用于循环，可使程序终止循环从而执行循环后面的语句。常常与条件语句一起使用。
continue 用于循环语句中，表示跳过循环体剩余语句，继续执行下一次循环。 continue 只能在循环语句中使用。
代码

package day5;

import java.util.Scanner;

//随机出10到题，记录用户的考试分数，每题10分
public class TestDemo {
    public static void main(String[] args) {
        int score = 0;//用于记录分数
        Scanner sc = new Scanner(System.in);
        for (int i = 1; i <= 10; i++) {
            int a = (int) (Math.random() * 10);//强制转换
            int b = (int) (Math.random() * 10);//强制转换
            System.out.println("题目：" + a + "+" + b + "=");
            System.out.println("请输入你的答案：");
            int answer = sc.nextInt();
            if (answer == -1) {//表示用户跳过这题
                continue;//Java中的关键字，用于跳过本次循环，继续下一次循环
            } else if(answer == -2){
                break;//结束for循环
            } else {
                if (answer == a + b) {
                    score += 10;//记录分数，增加10分
                }
            }
        }
        //for循环结束，表示考试结束了显示最终得分
        System.out.println("最后得分：" + score);
    }
}

循环的嵌套

循环的内部，再有其它循环，就是循环的嵌套。
外层走一次，内层走所有次。循环层数越少越好，效率越高
代码

package day5;
//循环的嵌套:循环的内部还包含一个循环
//     ***
public class JiuJiuDemo {
    public static void main(String[] args) {
        for(int i = 1; i <= 9; i++){ //外层循环
            for (int j=1; j<=i;j++){ //j<=i:可以设置内层循环的次数
                System.out.print(i + "+" + j + "=" + (i+j) + "\t");// \t转移字符，tab建的宽度
            }
            System.out.println(); //输出一个回车换行
        }
    }
}

数组

数组：相同数据类型元素组成的集合
数组的声明语法：数据类型[] 数组名 = new 数据类型[],例如：string[] arr = new string[5];
数组new之后，每个元素都有默认值。int、long默认值为0，double默认值为0.0，boolean默认值为false,char默认值为空字符。

元素按线性顺序排列。所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素；除最后一个元素外，每一个元素都有唯一的后继元素（“一个跟一个”）,可以通过元素所在位置的顺序号（下标）做标识来访问每一个元素（下标从0开始，最大到元素的个数-1）
代码

package day5;
//array - 数组
// 当我们有一组数据需要保存在一个变量中时，
public class ArrayDemo {
    public static void main(String[] args) {
        //1.定义一个数组
        int[] arr ;//arr是数组类型
        //arr = new int[];//编译错误：Java规定创建数组对象的时候，必须指定数组的长度
        arr = new int[6];// 内存空间会分配存储长度为6个整形的数据空间
        //2.数据的初始化
        int[] arr1 = new int[5];//arr1的长度是5，这里的每个元素都是int类型的默认值：0
        char[] arr2 = {'A','B','C',10};//arr2的长度是4，每个位置上的元素已经指定了
        double[] arr3 = new double[]{5.2,1.5,2.3,3.1};//arr3的长度是4,每个位置都有具体的数据

        /*
        //3.通过数组的下标（从0开始，到元素个数-1结束）访问到数据中的元素
        System.out.println(arr1[0]);//arr1[下标]
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        System.out.println(arr1[3]);
        System.out.println(arr1[4]);//数组长度是5，下标值：0,1,2,3,4  其他数据则发生异常
         */
        for (int i=0;i<5;i++){
            System.out.println(arr1[i]);//arr1[i]:i从0逐渐变化到4，正好就是数组的每一个元素
        }
    }
}

数组的位置交换

package day5;

public class ArrayDemo2 {
    public static void main(String[] args) {
        //1.创建一个长度为10的整形数组
        int [] arr = new int[]{10,15,8,40,25,5};
        //2.把数组中最大的数据值移动到最末位
        for (int i=0;i<=arr.length-2;i++){
            if(arr[i] < arr[i+1]){// 当前元素小于下一个元素，不交换位置反之交换位置
                continue;//跳出本次循环
            }else{
              int temp = arr[i];
              arr[i] = arr[i+1];
              arr[i+1] = temp;
            }
        }
        //3.遍历输出数组的元素
        for (int i=0; i< arr.length;i++){
            System.out.println(arr[i]);
        }
        //4.把数组中最小的数据值移动到最末位
        for (int i=0;i<arr.length-1;i++){
            if(arr[i] < arr[i+1]){// 当前元素小于下一个元素，说明需要交换位置
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        //5.遍历输出数组的元素
        System.out.println("末尾最小的是：");
        for (int i=0; i< arr.length;i++){
            System.out.print(arr[i] + "\t");
        }
    }
}

数组的排序

冒泡排序:所谓的冒泡算法就是从左往右依次比较两个数大小，若前一个数大于后一个数，则两个数交换位置
升序

package day5;
//bubble: 泡
//冒泡排序：双重for循环，外层for循环走一次，内层循环走n次，就能吧数组中的一个元素的位置排好
public class MaoPaoDemo {
    public static void main(String[] args) {
        int [] arr = new int[]{10,15,8,40,25,5};
        //1.升序排序
        for(int i=0; i< arr.length - 1; i++){
            for (int k=0;k<arr.length -1;k++){ // k=0、1、2、3、4  k+1=1、2、3、4、5
                if(arr[k]<arr[k+1]){
                    continue;
                }else{//下一个小就交换位置
                    int temp = arr[k];
                    arr[k] = arr[k+1];
                    arr[k+1] = temp;
                }
            }
        }
        //2.输出升序数组
        for (int i = 0; i< arr.length;i++){
            System.out.println(arr[i] + "\t");
        }
    }
}

降序

package day5;
//bubble: 泡
//冒泡排序：双重for循环，
public class MaoPaoDemo1 {
    public static void main(String[] args) {
        int [] arr = new int[]{10,15,8,40,25,5};
        //1.降序排序
        for(int i=0; i< arr.length - 1; i++){
            for (int k=0;k<arr.length -1;k++){ // k=0、1、2、3、4  k+1=1、2、3、4、5
                if(arr[k]<arr[k+1]){
                    int temp = arr[k];
                    arr[k] = arr[k+1];
                    arr[k+1] = temp;
                }
            }
        }
        //2.输出降序数组
        for (int i = 0; i< arr.length;i++){
            System.out.println(arr[i] + "\t");
        }
    }
}

排序

import java.util.Arrays;

public class Demo10 {

    public static void main(String[] args) {
        //问题 ["红","蓝","绿","蓝","红","绿"]
        // 按照:' 绿 < 蓝 < 红 '的规则排序
        String[] b = {"红","蓝","绿","蓝","红","绿"};

        for(int j = 0; j < b.length - 1; j++){
            for(int i = 0; i < b.length - 1; i++){
                if(b[i] == "蓝" && b[i+1] == "绿" || b[i] == "红" && b[i+1] == "蓝"|| b[i] == "红" && b[i+1] == "绿" ){
                    String tmp;
                    tmp = b[i];
                    b[i] = b[i+1];
                    b[i+1] = tmp;
                }
            }
        }
        System.out.println(Arrays.toString(b));
    }

}

数组复制和数组扩容

JDK提供对数组进行复制的方法，即将一个数组（源数组）中的各个元素值复制到另一个数组（目标数组）中：

数组的长度在创建后不可以改变的。所谓“扩展”是指创建一个更大新数组，并将原有数组的内容复制到其中。 Jdk提供了一个方法，Arrays.copyOf 可以实现数组的“扩容”
代码

package day5;

import java.util.Arrays;

//数组复制并且扩容
public class ZuoYiDemo1 {
    public static void main(String[] args) {
        //1.创建了字符串数组
        String[] strs = new String[4];//元素的默认值是null
        for (int i=0;i< strs.length;i++){
            //System.out.print(strs[i] + "\t");
            strs[i] = "tom" + i;//给数组元素赋值
        }
        System.out.println();
        //2.Arrays.toString的使用
        String str= Arrays.toString(strs);//调用Arrays.toString方法，实现吧数组类型转换为字符串类型
        System.out.println("str" + str);//[tom0,tom1,tom2,tom3]
        //3.数组扩容
        //strs[4] ="tom4";//运行时错误：数组的长度为4，下标只能为0,1,2,3， 这里strs[4]就会抛出异常
        strs = Arrays.copyOf(strs, strs.length+1);//Arrays.copyOf(原数组，新的长度)
        strs[4]="tom";
        System.out.println(Arrays.toString(strs));
        //练习：把2~100区间的质数找出来，保存在一个数组中，然后输出这些质数
        int[] datas={2,3};//数组的长度是2
        int count=0;//统计循环次数
        for (int i=2;i<100;i++){
            for (int j=2;j<=Math.sqrt(i);j++){
                if (i%j==0){
                    break;//说明不是质数，循环结束
                }
                if (j==(int)Math.sqrt(i)){
                    //说明i是质数，把i保存到数组中
                    //对数组扩容
                    datas= Arrays.copyOf(datas,datas.length+1);
                    datas[datas.length-1]=i;
                }
                count++;//没循环一次，count+1
            }
        }
        System.out.println("count:" + count);
        System.out.println("datas:" + Arrays.toString(datas));
    }
}