Java基础知识

概述

什么是java:1.是边编译边解释的面向对象的编程语言。

2.java语言是1995年发布的，发布语言公司是：Sun

3.下载安装Java时从Oracle官网下载，最好下载LTS长期维护版本。Java8，Java11，Java17

4.由于Java虚拟机JVM的存在，可以全平台运行。

5.java之父：james gosling oak

JDK安装

JDK--Java Development kit(Java开发工具包）
JRE--Java Runtime Environment(Java运行环境）
JVM--Java Virtual Machines(Java 虚拟机）
java的技术体系结构：安装jdk的时候，主要安装的是java se相关内容。

1.先到oracle官网去下载JDK（https://www.oracle.com/technetwork/java/javase/downloads/index.html）

2.打开环境变量设置

3.JAVA_HOME：jdk的安装路径

4.PATH:JDK的安装包中的bin目录--path配置之后，可以在命令行窗口使用命令

5.测试环境变量的配置：

window+R,然后输入cmd，就可以打开命令行窗口。然后输入java-version命令，查看安装jdk版本

java第一个程序

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

java的变量

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

变量声明的语法规则：变量类型变量名字

在变量声明时同时初始化: 变量类型变量名字 = 初始值
先声明变量，在第一次使用变量之前再对变量赋初值
未经声明的变量不能使用
如果多个变量的类型相同，可以在一条语句中声明，中间用逗号分隔
变量的命名需要符合Java标识符语法要求

-可以有字母，数字，”_”和”$”符组成

-首字符不能以数字开头

-Java是大小写敏感的语言，命名变量时需要注意

-不能使用Java保留字(Java语言规定好的，有特殊含义的字符：public static void…
中文可以作为变量名字，但是不推荐使用。

Java变量命名最好能“见名知意” Java编程规范要求：变量的命名需要采用“驼峰命名法”，即：如果Java变量名字由多个

英语单词组成，除第一个单词首字母小写外，其他的单词，需要首字母大写，其余的字母小写。如（timeMills)

java的关键字

java中基本数据类型

整形int

int是最常用的整数类型。一个int类型占用4个字节（32位），

最大表示范围为：-2147483648 ~ 2147483647
整数类型的直接量(literal)默认是int类型。
两个int整数相除(/)，结果取整，舍弃小数部分（非四舍五入），结果还是整数
整数运算要防止溢出

-整数运算的过程中，运算结果，如果超过了整数能表示的最大范围，会发生溢出。

正数过大溢出，结果变为负数；负数过小溢出，结果变为正数。
代码

package day2;// int数据类型介绍public class IntDemo {public static void main(String[] args) {// 1. int的数据是占4个字节int  a = 10000 ;System.out.println("a:" + a); // 输出变量a.//int a1 = 10000000000 ;// 100亿 , 编译错误。 超过了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 = 13int c2 = a1 - a2; // c2 = 5int c3 = a1 * a2; // c2 = 36int c4 = a1 / a2;// 取整: java程序中规定，两个整数的运算结果只能是整数(9/4 等于2)//   , 数学中(9/4等于2.25)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型。
代码

package day2;// long : 长整形 ， 8个字节 ， 如果int数据范围不够，就选择使用longpublic class LongDemo {public static void main(String[] args) {// 1. 定义long类型的变量long a1 = 100;// java中“直接量”默认为int类型。// long a2 = 10000000000;// 100亿超过了int的范围，所以导致编译错误。long a2 = 10000000000L ; // 在直接量后，添加"L 或 l "的标志，表示这个直接量
是long类型。// 2. 时间毫秒数// 练习： 自己计算一年的毫秒数// long micro = 365 * 24 * 60 * 60 * 1000 ; //全部都是int类型参与运算，结
果就是int类型，超过int范围，就溢出。long micro = 365L * 24 * 60 * 60 * 1000 ; // 把365转为long类型， 所以运
算结果就是long类型。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.0System.out.println(a1 - a3); // 2.0System.out.println(a1 * a3); // 5.25System.out.println(a1/a3); // 2.3333333333333335System.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 ); // 位移为:122.5}
}

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’;
转义字符（\）:对于不方便输出的字符，采用转义字符表示。

代码

// 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); // 65int c = '中';  // ‘中’对应的编码，赋值给c。System.out.println(c);// 3. 字符的表达方式char  d = '0';char  d1 = 48 ;char  d2 = '\u0048';System.out.println(d  + ":" + d1 + ":" + d2);// 4. 字符的运算char  d3 = '0'; // 编码为48char d4 = '9'; // 编码为57System.out.println(d4 - d3); // 9//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指数计算

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() ; //// 计算bmibmi =  w / (h * h);System.out.println(name + ",你的bmi:" + bmi);}
}

随机字符

//产生 A~Z的随机字符// 练习： 0~9随机整数// 练习： a~z的随机字符public class AZDemo {public static void main(String[] args) {// 1. 产生随机数double random = Math.random();  // Math.random() 产生一个随机数 , [0,1)区间
的浮点数double data = random * 26 ;int  a  = (int) data ; // java的强制数据类型转换System.out.println("0~26:" + a);// 2. 得到随机字符char c = (char)(a  +  65);// java的强制数据类型转换System.out.println("随机字符：" + c);}
}

boolean类型

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

// 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 = falsec =  a || b ;// c = truec = !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("未成年.");}}
}

数据类型转换

自动数据类型转换（隐式转换）：小类型，自动转为大类型。

强制数据类型转换：从大类型，转到小类型，需要强制转化，可能会有精度损失或者溢出。

import javax.swing.text.StyledEditorKit;// -- 数据类型转换//   自动类型转换//   强制数据类型转换public class DataTypeDemo {public static void main(String[] args) {// 1. 自动类型转换long  a1 = 100 ; // 自动类型转换： 直接量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); // 100System.out.println("a2:" + a2); // 3// 3.强转造成精度损失或者溢出double d = 3.141592666666666 ;float d1 = (float)d;System.out.println("精度损失：" + d1); // 3.1415927long data = 10000000000L;int  data1 = (int)data;System.out.println("溢出：" + data1);// 1410065408// 4. byte , short两种数据byte b1 = 100; // 自动类型转换//byte b2 = 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 = 3.5F;int  l6 = (int)l5;// d. 定义一个boolean类型的变量，然后赋值给byte类型。boolean l7 = true;// byte l8 = l7;// 编译错误： boolean不能转换为整数}
}

运算符

算术运算符

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

++（自增），--（自减）运算是在自身值的基础上，增加或者减少1. ++，--写在变量的前面，运算的时候，需要先增加或者减少1，再参与运算。

++，--写在变量的后面，运算的时候，需要先参与运算，再增加或者减少1。
“+”,“-”,可以作为数据正负符号。
代码

// 算术运算符：   + ， - ， * ， / , %
//             ++ , --
//             符号（+ ， -）// 能做算术运算的类型：   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);// 2.   除法(/) 运算double data4 = data1/3 * data2 ; // 运算结果以大范围数据为准。System.out.println("data4:" + data4); // 10.5data4 = 1/2 ; // 0.0 : 这里1、2都是int类型，所以运算结果是0. 但是把int的数
据赋值给double类型，所以最终值是0.0System.out.println("data4:" + data4);data4 = 1/2.0;  // 0.5System.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); // 6i--; // 自减： 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 = 5int i1 =  i++  + j++   + i-- ; // i = 6, j = 6 ， i1System.out.println("i1:" +i1);// i1=18// 5. 符号(+ , -)int m1 = -5; // 负号int m2  = + 5; // 正号int m3 =  -5 - 5;System.out.println("m3:" + m3);int m4 = -5 + -10;System.out.println("m4:" + m4);int m5 = -5 + +10;System.out.println("m5:" + m5);}
}

关系运算符

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

代码

// 关系运算：//       大于（>）， 大于等于(>=)， 等于(==)，不等于(!=)， 小于(<)，小于等于(<=)
//       能进行关系运算: byte ， short ,int , long , char , float , double
//       不能进行关系运算： boolean , 其它的引用类型public class GuanXiDemo {public static void main(String[] args) {// 1. 关系运算的结果是boolean 类型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);}}
}

逻辑运算符

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

代码

//   逻辑运算：   && -与 ， || 或   ， ！ 非//         运算规则： 与运算（全为真则结果为真，有假则结果为假。）//                 或运算（全为假则结果为假，有真则结果为真。）//                 非运算( 真变假，假变为真，本质就是取反。)
//       逻辑运算的结果是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 ;// trueb4  = b1 && b2 && b3 ;// falseb4 = b1 || b3; // trueb4 = b1 || b2 || b3; // trueb4 = !b3; // trueb4 = !(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 是 4boolean 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}
}

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

赋值运算符“=”是最常用的赋值运算。它将“=”右边的运算结果的值，赋给“=”左边的变量。
赋值运算符的优先级很低。（低于算数运算符）
在赋值运算符的前面，加入算数运算符，即为扩展赋值运算符。

+=，-=，*=，/=，%=

字符串拼接“+”

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

三目运算符

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

如果X为false，则运算结果为Z的值。

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

// 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=？   , 这里的 k += 20 完全等价于 k = k + 20 . 所有 k = 30 .System.out.println("k:" + k );k /= 4 ; // k =? , k = k/4 所以k= 7System.out.println("k:" + k );// 2. "+" 做字符串拼接String str = "hello";System.out.println( k + k + str); // "14hello"System.out.println(k + str  + k); //7hello7System.out.println(str + k + k); // hello77System.out.println(str + (k+k)); //hello14System.out.println((str+k) + k + k); // hello777System.out.println(str + k + k ); // hello77System.out.println(k+k+k+k);//28// 3. 三目运算int age = 19 ;String  info = age >= 18 ? "成年人" : "未成年人";  // 需要把三目运算的就结果，
赋值给一个变量，保存起来。System.out.println("你现在：" + age  + "岁，你是：" + info);}
}

三目运算找最大值

import java.util.Scanner;// 用三目运算，判断出用户输入的两个数据中最大的那个。public class MaxData {public static void main(String[] args) {// boolean ？ 表达式1 ： 表达式2Scanner 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语法中的分支结构包含以下四种
分支结构可以嵌套使用
1.if //如果…
2.if……else…… //如果…否则…
3.if…….else if……. //如果…否则如果…..
4.switch……case…… //switch….情况1…情况2…..

if...else代码：

public class IfElseManyDemo1 {public static void main(String[] args) {Scanner sc =new Scanner(System.in);System.out.println("请输入1~7的数据：");int num = sc.nextInt();if(num <0  || num  > 7){System.out.println("输入的数据不合理，请重新输入。");}else{if(num == 1){System.out.println("星期一");}else  if(num == 2){System.out.println("星期二");}else if(num == 3){System.out.println("星期三");}else if(num == 4){System.out.println("星期四");}else  if(num == 5){System.out.println("星期五");}else if(num == 6){System.out.println("星期六");}else{
System.out.println("周日");}}}
}

switch代码：

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

循环结构

for循环

循环是程序设计语言中反复执行某些代码的一种计算机处理过程，是一组相同或相似的语句被有规律地执行。循环三要素

1.循环变量初始化

2.循环条件（以循环变量为判断条件）

3.循环变量的改变（向着循环结束变）
for循环是最经典的循环语法，也是使用最多的循环方式。

for语法规则：

for(表达式1；表达式2；表达式3){ // 语句序列 } 表达式1：初始化表达式，负责完成循环条件的初始化

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

表达式3：循环后的操作表达式，负责修改变量，改变循环条件
for循环代码执行流程

累加代码

//计算1+2+3......+100的和
public class SumDemo {public static void main(String[] args) {int sum = 0 ;// 保存和 , 0不影响加法运算的结果。for(int i=1 ; i <=100 ; i ++){sum = sum +i ;// 每一次重复做的事情。}System.out.println("1+...100：" + sum);// 练习： 计算1+1/2+1/3......+1/888的和;double sum1 = 0 ;for(int i = 1 ; i <=888 ; i ++){sum1 =   sum1 +  1.0/i;}System.out.println("sum1:" + sum1);}
}

for循环的特殊写法

for(;表达式2；表达式3)for(;表达式2;）for(;;)for(int a = 0, b=5 ; a<b; a++,b--) {System.out.println(a+",,,"+b);}

while循环

while语法规则：

语句0 ；

while(循环条件){ 语句1 ；//循环体

} 语句2 ；
代码

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

猜数字

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

do…while语法规则：

语句0 ; do{ 语句1;//循环体

语句2;// }while (循环条件); 语句3 ;
对比while循环

while循环先判断，再执行；

do…while先执行一次，再判断,至少要执行一次。

While循环比do…while循环用得多。

代码

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 = 1 ; // 记录次数int pwd ;do{if(count == 6){System.out.println("你的输入次数用完了，请半个小时之后，在尝试。");//break; 结束循环return;  // 结束整个程序的运行}System.out.println("请输入密码：");pwd = scanner.nextInt();count ++ ;// 改变输入的次数}while (pwd != 123456);System.out.println("手机解锁成功了。");}
}

死循环

循环没有指明结束条件的情况会造成死循环

break&continue

break可用于循环语句或switch语句。

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

continue 只能在循环语句中使用。

代码

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 ;  // 记录分数}}}// for循环结束，表示考试结束了，显示最终得分System.out.println("最后得分：" + score);
}
}

循环的嵌套

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

// 循环的嵌套： 循环的内部，还包含一个循环。//     *** 外层循环执行一次， 内层循环执行所有次。 （内部循环执行结束了，再次执行到外层
循环的下一次。）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(); // 输出一个回车换行}}
}

数组

什么是数组

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

数组的使用

声明数组的语法：数据类型[] 数组名 = new 数据类型[大小]；

数组声明后的默认值

------数组new之后，每个元素都有默认值。int,long默认值为0，double默认值为0.0，boolean

默认值为false,char默认值为空字符。
代码

// array - 数组// 当我们有一组数据需要保存在一个变量中的时候，一般可以声明一个对应长度和对应数据类型的数
组， 然后把这组数据存储在数组中。public class ArrayDemo {public static void main(String[] args) {// 1. 定义一个数组//int a = 1,b=10,c=20,d=30,e=50; // 定义了五个变量，存储了五个数据。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','A',10} ; // arr2的长度是 4 ，每个位置的元素已经指
定了。double[] arr3 = new double[]{1.5,2.5,3.5,4.5}; //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. 正好就
是数组的每一个元素。}
}
}

数组交换位置

public class ArrayDemo2 {public static void main(String[] args) {// 1. 创建整形数组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 ++ ){ // 假设： i <= arr.length// i = 0,1,2,3,4,5,6 , 下
标只能是0，1，2，3，4，5 ，// i=6 数据数据arr[6] , 找
不到 ， 程序处理不了， 就抛异常System.out.print(arr[i] + "\t");}/*Exception : 异常ArrayIndexOutOfBoundsException : array 数组 ， index 索引 ， out of
bounds 超出边界Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException:
6at day5.ArrayDemo2.main(ArrayDemo2.java:33) // 类中的第33行。*/}
}

数组的排序

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

// bubble: 泡// 冒泡排序： 双重for循环， 外层for循环走一次，内层循环周n次， 就能把数组中的一个元素的位
置排好 。public class BubbleDemo {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,5if(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.print(arr[i] + "\t");}}
}

降序

// bubble: 泡// 冒泡排序： 双重for循环， 外层for循环走一次，内层循环周n次， 就能把数组中的一个元素的位
置排好 。public class BubbleDemo1 {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,5if(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.print(arr[i] + "\t");}}
}

数组排序函数sort

Arrays.sort()——jdk提供的排序方法。

String[] names ={"tom","cat","jerry"};Arrays.sort(names);System.out.println( Arrays.toString(names) );    // import
java.util.Arrays;

数组复制

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

数组扩容

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

个人总结

if（条件）{

}else{

if(条件){

}else if(条件){

}

int input =sc.nextInt();

switch(input){

case 1:

}

int sum =0;

for(int i= 0;i<=20;i++){

sum +=i;

}

while(条件){

}

break;//结束当前循环

return;//结束整个程序

JAVA技术解析

一，运行原理

高级语言运行过程
在程序真正运行在CPU上之前，必须要让OS的kernel理解我们在编辑器或者IDE里根据每种语言的语法规则敲入的源代码，kernel才能做出相关的调度，所以需要先将源代码转化成可执行的二进制文件，这个过程通常由编译器完成。有些编译器直接将源代码编译成机器码，载入内存后CPU可以直接运行。而机器码的格式与跟具体的CPU架构相关连，例如ARM CPU无法理解Intel CPU机器码。因此，同样的源代码需要根据不同的硬件进行特定的编译。高级语言转换到低级语言的桥梁就是编译器。程序员写好源代码，编译器将源码编译成可执行的机码，然后CPU读取机器码，执行程序。

面试题解析

1、在JAVA中，如何跳出当前多重嵌套循环？

在Java中的跳转语句有两种break语句(结束当前循环)和continue语句(结束当次循环)，跳出多重循环可以使用break。
2、JDK和JRE有什么区别？

JRE是java运行时环境，而JDK是java开发工具包，JDK包含JRE，但是JRE可以独立安装
3、=、==、和equls的区别

“=”是赋值；“==”是等于；“equals”可以作为输出语句
4、string是基础数据类型吗？基础的数据类型有哪些？

是基础数据类型，int,long,float,boolean,double,char
5、如何实现数组和List之间的转换？

使用 Arrays. asList(array) 进行转换。
List 转数组：使用 List 自带的 toArray() 方法。

public void arraysToList(){/*** List转Array*/List<String> arrayList = new ArrayList<>();arrayList.add("a");//使用toArray之后，转换的是Object数组Object[] objects = arrayList.toArray();System.out.println(Arrays.toString(objects));/*** Array转List*/String[] str = {"a", "b", "c"};List<String> list = Arrays.asList(str);System.out.println(list.toString());}

华清远见-重庆中心-JAVA基础阶段技术总结/知识点梳理/个人总结/关于JAVA技术的解析（看法）/面试题解析相关推荐

华清远见重庆中心—后端基础阶段技术总结/个人总结
后端基础阶段技术总结 JAVA概述 1.java的历史 Oak(橡树)语言,由Green开发团队开发,主要用于微型嵌入式设备编程,第一次提出了开源协议 . Java之父詹姆斯.高斯林经历过Sun公 ...
华清远见重庆中心--后端基础阶段技术总结/个人总结
目录目录目录 Java基础知识 java概述 JDK安装 JDK卸载 JDK版本切换认识JetBrains 安装IDEA IDEA环境的认识新建一个Java的项目新建一个文件第一个Java ...
华清远见-重庆中心-JavaWeb后端阶段技术总结
华清远见-重庆中心-JavaWeb后端阶段技术总结 JavaWeb 使用Java开发Web服务的技术,统称为JavaWeb. B/S与C/S模式 B/S:Browser/Server 浏览器/服务器模 ...
华清远见-重庆中心-JavaWeb综合阶段技术总结
JavaWeb 使用Java开发Web服务的技术,统称为JavaWeb. B/S与C/S模式 B/S:Browser/Server 浏览器/服务器模式用户只需要一个浏览器即可访问服务器 C/S:Cl ...
华清远见-重庆中心-javaweb后端阶段知识点梳理
JavaWeb 使用Java开发Web服务的技术,统称为JavaWeb. B/S与C/S模式 B/S:Browser/Server 浏览器/服务器模式用户只需要一个浏览器即可访问服务器 C/S:Cl ...
华清远见-重庆中心-VSS前端阶段知识点梳理
VSS 前端开发 1.html 1.1什么是html? Hyper Text Markup Language 超文本标记语言超文本:有视频.音频.图片等,超越文本标记语言:有一套标签 2.网页的基 ...
华清远见-重庆中心-JAVA基础阶段技术总结
系列文章目录第一章华清远见--重庆中心-JAVA基础阶段技术总结第二章文章目录系列文章目录文章目录前言一.关于java 1.发展历程 2.编程开发 3.java架构 4.java的特点 ...
华清远见—重庆中心——JAVA高级阶段知识点梳理
华清远见-重庆中心--JAVA高级阶段知识点梳理 String字符串 String是一个类,属于数据类型中的引用类型.Java中所有使用""引起来的内容都是属于这个类的实例,称为字 ...
华清远见-重庆中心-JAVA面向对象阶段技术总结
华清远见-重庆中心-JAVA面向对象阶段技术总结面向对象和面向过程的编程思想面向对象(OOP) 通过创建(new)对象,赋予对象对应的行为和特征,让这些对象相互配合来解决问题面向过程(POP) ...
华清远见-重庆中心-框架阶段技术总结/知识点梳理
文章目录华清远见-重庆中心-框架阶段技术总结/知识点梳理/个人总结框架 Java主流框架 Spring 概念组成名词解释 IOC DI Spring控制台应用 1.创建一个普通的Maven项目 ...

华清远见-重庆中心-JAVA基础阶段技术总结/知识点梳理/个人总结/关于JAVA技术的解析（看法）/面试题解析