1. Linux 操作系统
1) 开源免费的操作系统，主要作为服务器操作系统，而Java主要是服务器端的开发，所以部署的环境是Linux。
2) Linux与Windows结构的区别
(1) 文件系统不同：Linux是目录，Windows是盘符
(2) 外部设备映射不同：Linux是挂载点，Windows是盘符
(3) 安全级别不同：Linux安全级别高，Windows安全级别相对较低
3) Linux常用命令
(1) pwd——显示当前工作目录；
(2) ls——查看当前工作目录；
(3) Cd——改变当前工作目录
相对路径：相对于当前目录的位置；绝对路径：相对于根目录的位置
2. Java的开发环境
1)Java的编译运行过程
Java的开发环境分为编译期和运行期。在编译期，.Java源文件经过编译，生成.class字节码文件；在运行期，JVM虚拟机加载.class字节码文件并运行.class文件；Java的编译特性，让Java具有跨平台、一次编译、到处使用的特点。
2)解释JVM、JRE和JDK的区别
jvm：是Java的虚拟机，其主要作用是加载.class并运行.class文件；jre：是Java的运行环境，除了jvm以外还包含运行Java程序所必须的环境；jdk：是Java的开发工具包，除了jre外还包含开发Java程序所必须的命令工具。所以，JRE=JVE+java开发系统类库；JDK=JRE+编译、运行等命令工具。
3)配置环境变量JAVA_HOME:指向jdk的安装路径
CLASSPATH:表示类的搜索路径，一般简写为.
PATH:指向jdk下的bin目录
4)Java的注释
1)单行注释:// 2)多行注释:/* */ 3)文档注释:/** */
3.Java中的变量
1)变量：是存数的，指代的是它所存的那个数
2)变量的声明：int a; //声明一个整型变量，名为a； int b,c,d; //声明三个整型的变量，名为b,c,d
3)变量的命名规则
(1)只能包含字母、数字、_和$符，并且不能以数字开头
(2)严格区分大小写
(3)不能使用关键字
(4)可以中文命名，但不建议建议"英文的见名知意"，"驼峰命名法"
4)变量初始化的两种方式
(1)声明的同时初始化。例如：int a=20；//声明一个整型变量，赋值为20；
(2)先声明后初始化。例如：int a； a=5；//先声明整型变量a,在给变量a赋值为5
5)变量的使用
对变量的使用，就是对它所存的那个数的使用，其在使用的时候必须注意两点：
第一，变量的使用必须和数据类型相匹配；第二，变量在使用之前必须先声明并初始化
4. 基本数据类型
Java中基本数据类型有8个，常用的有5个：
1)int:整型，4个字节，范围是：-21个多亿到21个多亿。在Java中，整数直接量默认为int型，但不能超出范围，超范围则编译错误；两个整数相除，结果还是整数，小数位无条件舍弃；整数运算时超出范围，则发生溢出，溢出是需要避免的
2)long:长整型，8个字节，很大。长整型直接量需在数字后加L或l；运算时或有可能发生溢出，建议在第1个数字后加L。System.currentTimeMillis()；用于获取自 1970.1.1零时到此时此刻的毫秒数
3)double:浮点型，8个字节，很大。浮点数直接量默认为double型，表示float需在数字后加F或f；double型数据参与运算时，有可能会出现舍入误差。
4)boolean:布尔型，1个字节。只能取值为true和false
5)char:字符型，2个字节。采用Unicode编码格式，一个字符对应一个码(0到65535)；表现形式的是char字符，但实质上存储的是int码；ASCII码('a'--97 'A'--65 '0'--48)；字符必须放在单引号中；特殊字符需通过\来转义
5.基本数据类型的转换
类型从小到大依次为:byte-short-int-long-float-double;
char-int-long-float-double;
1)数据类型装换的两种方式:自动类型转换:小类型到大类型
强制类型转换:大类型到小类型。其在转换的时候，可能会发生溢出或精度损失
语法:(要转换成为的数据类型)变量
2)数据类型装换的两点规则整数直接量可以直接赋值给byte,short,char,但不能超范围
byte,short,char型数据参与运算时， 先一律转换为int再运算
6. Scanner的用法
import java.util.Scanner;
Scanner scan = new Scanner(System.in);
System.out.println("请输入年龄:")；
int age = scan.nextInt();7.java中的运算符和分支结构
1)运算符算术运算符:+-*/%,++,--
关系运算符:>,=,<=,==,!= (Boolean型)
逻辑运算符:&&,||,! (Boolean型)
赋值运算符:=,+=,-=,*=,/=,%=
字符串连接运算符:+
三目/条件运算符:boolean?数1:数2 对于条件表达式，先计算条件boolean，然后进行判断。如果b的值为true，计算数1的值，输出结果为数1的值；否则，计算数2的值，运算结果数2的值。三目运算可以进行嵌套。列如：
public static void main(String[] args){
int a=10;
int b=20;
System.out.println("此三元运算式结果是："+((a>b)?'A':'B'));
}//B
2)分支结构
(1)if结构：满足条件时执行语句，不满足则不执行(1条路)
语法：
if(条件表达式){
语句块;
}
//判断一个数，是不是偶数
public class Test {
public static void main(String[] args){
int a = 4;
if(a%2==0){
System.out.println(a+"是偶数");
}
System.out.println("over");
}
}
(2)if...else结构：满足条件执行语句，不满足则执行另外的语句(两条路)
语法：
if(条件表达式){
语句块1;
}else{
语句块2;
}
//判断一个数是不是偶数，输出
public class Test {
public static void main(String[] args){
int a = 4;
if(a%2==0){
System.out.println(a+"是偶数");
}else{
System.out.println(a+"不是偶数");
}
System.out.println("over");
}
}
(3)if...else if结构：多个条件，满足不同条件执行不同语句(多条路)
语法：
if(条件表达式1){
语句块1;
}else if(条件表达式2){
语句块2;
}else if(条件表达式3){
语句块3;
}
//判断一个数正数、负数或是0并输出结果
public class Test {
public static void main(String[] args){
int a = 4;
if(a>0){
System.out.println(a+"是正数");
}else if(a<0){
System.out.println(a+"是负数");
}else if(a==0){
System.out.println(a+"是0");
}
System.out.println("over");
}
}
(4)switch...case结构:多条路
一种特殊的分支结构，只能用于判断整数，可以根据一个整数表达式的不同值，从不同程序入口开始执行，需要和break配合使用，执行完相应的语句后则退出switch块，不执行下面的语句。如果不加break，则会在满足条件后，将该条件下面的其他条件的语句块一起按顺序输出，直到遇到break或}停止，如下案例2。default选项可以不写，也不是必须放在后一个(建议放最后)，默认匹配完所有条件后不匹配的情况下才会执行default语句，default可以不写break，如下：
语法：
switch(判断整数){
case 1:
语句块1;
break;
case 2:
语句块2;
break;
case 3:
语句块3;
break;
default:
语句块4;
break;
}
//
public class Test {
public static void main(String[] args){
int a = 4;
switch(a){
case 1:
System.out.println("A");
break;
case 2:
System.out.println("B");
break;
case 3:
System.out.println("C");
break;
default:
System.out.println("D");
break;
}
}
}
/*
运行结果：D
*/
//不加break的情况
public class Test {
public static void main(String[] args){
int a = 2;
switch(a){
case 1:
System.out.println("A");
break;
case 2:
System.out.println("B");
case 3:
System.out.println("C");
default:
System.out.println("D");
}
}
}
/*
运行结果:
B
C
D
*/
//default不写在最后，default需要加break，如下情况
public class Test {
public static void main(String[] args){
int a = 4;
switch(a){
default:
System.out.println("D");
case 1:
System.out.println("A");
break;
case 2:
System.out.println("B");
break;
case 3:
System.out.println("C");
break;
}
}
}
/*
运行结果：
D
A
*/
优点：常常和break语句配合使用实现分支的功能；与if...else的主要区别在于switch-case结构的效率高、结构更清晰；从JDK7.0开始，switch-case支持字符串表达式，
缺点：只能判断整数(字符串)相等
8.循环
1)循环：循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。
2)循环语句的组成
初始化语句：一条或者多条语句，这些语句完成一些初始化操作。
判断条件语句：这是一个boolean 表达式，这个表达式能决定是否执行循环体。
循环体语句：这个部分是循环体语句，也就是我们要多次做的事情。
控制条件语句：这个部分在一次循环体结束后，下一次循环判断条件执行前执行。通过用于控制循环条件中的变量，使得循环在合适的时候结束
3)循环结构
(1)for:应用率最高，固定次数循环
语法：for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}
1.求出1-100之间偶数和
/*
需求：
A:求1-100之和。
B:求出1-100之间偶数和
*/
class ForTest1 {
public static void main(String[] args) {
//求1-100之和。
int sum1 = 0;
for(int x=1; x<=100; x++) {
sum1 +=x;
}
System.out.println("1-100之和是："+sum1);
System.out.println("------------------");
//求出1-100之间偶数和
//方式1
int sum2 = 0;
for(int x=1; x<=100; x++) {
if(x%2 == 0) {
sum2 += x;
}
}
System.out.println("1-100偶数之和是："+sum2);
System.out.println("------------------");
//方式2
int sum3 = 0;
for(int x=0; x<=100; x+=2) {
sum3 += x;
}
System.out.println("1-100偶数之和是："+sum3);
System.out.println("------------------");
}
}
2.求5的阶乘
/*
需求：求5的阶乘。
什么是阶乘呢?
n! = n*(n-1)! 规则
n! = n*(n-1)*(n-2)*...*3*2*1
求和思想。
求阶乘思想。
*/
class ForTest2 {
public static void main(String[] args) {
//定义最终结果变量
int jc = 1;
//这里的x其实可以直接从2开始
//for(int x=1; x<=5; x++)
for(int x=2; x<=5; x++) {
jc *=x;
}
System.out.println("1-5的阶乘是："+jc);
}
}
(2)while:先判断后执行，有可能一次都不执行
语法：
初始化语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}
例如：我国最高山峰是珠穆朗玛峰：8848m，我现在有一张足够大的纸张，厚度为：0.01m。请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?
/*
我国最高山峰是珠穆朗玛峰：8848m，我现在有一张足够大的纸张，厚度为：0.01m。
请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?
分析：
A:定义一个统计变量，默认值是0
B:最高山峰是珠穆朗玛峰：8848m这是最终的厚度
我现在有一张足够大的纸张，厚度为：0.01m这是初始厚度
C:我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?
折叠一次有什么变化呢?就是厚度是以前的2倍。
D:只要每次变化的厚度没有超过珠穆朗玛峰的高度，就折叠，统计变量++
E:输出统计变量。
*/
class WhileTest01 {
public static void main(String[] args) {
//定义一个统计变量，默认值是0
int count = 0;
//最高山峰是珠穆朗玛峰：8848m这是最终的厚度
//我现在有一张足够大的纸张，厚度为：0.01m这是初始厚度
//为了简单，我把0.01变成1，同理8848就变成了884800
int end = 884800;
int start = 1;
while(start
//只要每次变化的厚度没有超过珠穆朗玛峰的高度，就折叠，统计变量++
count++;
//折叠一次有什么变化呢?就是厚度是以前的2倍。
start *= 2;
System.out.println("第"+count+"次厚度是"+start);
}
//输出统计变量。
System.out.println("要叠"+count+"次");
}
}
(3)do...while:先执行后判断，至少执行一次 要素1与要素3相同时，首选do...while
语法：
初始化语句;
do {
循环体语句;
控制条件语句;
} while((判断条件语句);
写程序优先考虑for循环，再考虑while循环，最后考虑do…while循环
break 跳出单层循环continue 跳出一次循环，进入下一次的执行；return 返回
9. 循环的嵌套
要点：循环中套循环，一般多行多列时使用，外层控制行，内存控制列
执行规则:外层循环走一次，内层循环走所有次
建议:嵌套的层数越少越好，能一层就不用两层，能两层就不用三层 若业务必须要通过三层以上的循环才能解决，说明设计有问题
break只能跳出一层循环
案例代码：
请输出一个4行5列的星星(*)图案：
/*
需求：请输出下列的形状
*
**
***
****
*****
提示：外循环控制行数，内循环控制列数
*/
class ForForTest01 {
public static void main(String[] args) {
//通过简单的观察，我们看到这是一个行是5，列数是变化的形状
//我们先打印出一个5行5列的形状
for(int x=0; x<5; x++) {
for(int y=0; y<=x; y++) {
System.out.print("*");
}
System.out.println();
}
}
在控制台输出九九乘法表：
注意：
'\x' x表示任意，这种做法叫转移字符。
'\t' 一个制表符的位置(tabtab键)
'\r' 回车
'\n' 换行
*/
class ForForTest02 {
public static void main(String[] args) {
for(int x=1; x<=9; x++) {
for(int y=1; y<=x; y++) {
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
10.程序=算法+数据结构
1)算法，解决问题的流程/步骤(任何程序我们都可以用顺序、分支、循环三种结构实现)；
2)数据结构，将数据按照某种特定的结构来保存，即数怎么存。设计良好的/合理的数据结构会导致好的算法。
11.数组
1)相同数据类型元素的集合
2)数组是一种数据类型(引用类型)
3)数组的定义:
int[] arr = new int[10];
4)数组的初始化:
//2.数组的初始化
int[] arr1 = new int[4]; //0,0,0,0
int[] arr2 = {1,4,7,9}; //1,4,7,9
int[] arr3 = new int[]{1,4,7,9}; //1,4,7,9
int[] arr4;
//arr4 = {1,4,7,9}; //编译错误，此方式只能声明同时初始化
arr4 = new int[]{1,4,7,9}; //正确
5)数组的访问:
(1)通过(数组名.length)来获取数组的长度
//3.数组的访问:
int[] arr = new int[3];
System.out.println(arr.length); //3
arr[0] = 100; //给arr中的第1个元素赋值为100
arr[1] = 200;
arr[2] = 300;
//arr[3] = 400; //数组下标越界异常
System.out.println(arr[arr.length-1]); //300
(2)通过下标/索引来访问数组中的元素
//下标从0开始，最大到(数组名.length-1)
int[] arr = new int[3];
arr[0] = 100; //给arr中第1个元素赋值为100
arr[1] = 200;
arr[2] = 300;
arr[3] = 400; //数组下标越界异常
System.out.println(arr[arr.length-1]); //输出最后一个元素的值
6)数组的遍历
//4.数组的遍历:
int[] arr = new int[10];
for(int i=0;i
arr[i] = (int)(Math.random()*100);
}
for(int i=0;i
System.out.println(arr[i]);
}
7)数组的复制
1、System.arraycopy()方法：
例如： System.arraycopy(a,1,a1,0,4);
2、Arrays.copyOf()方法
int[] a1 = Arrays.copyOf(a,6);
a = Arrays.copyOf(a,a.length+1); //扩容
8)数组的排序
(1)Arrays.sort(arr); //升序 Arrays类中的sort()使用的是“经过调优的快速排序法”; 比如int[]，double[]，char[]等基数据类型的数组，Arrays类之只是提供了默认的升序排列，没有提供相应的降序排列方法。
(2)冒泡排序算法：( 四个数冒三轮；每一轮都是从第1个元素开始冒； 每一次都是和它的下一个元素比；冒出来的就不带它玩了)
基本思想：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。在第二趟：仍从第一对数开始比较(因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数)，将小数放前，大数放后，一直比较到倒数第二个数(倒数第一的位置上已经是最大的)，第二趟结束，在倒数第二的位置上得到一个新的最大数(其实在整个数列中是第二大的数)。如此下去，重复以上过程，直至最终完成排序。
//冒泡排序算法
public class BubbleSort {
public static void main(String[] args) {
/*
* 要求:
* 1)声明整型数组arr，包含10个元素
* 遍历数组，给每个元素赋值为0到99的随机数
* 遍历数组，输出每个元素的值
* 2)冒泡方式对arr进行排序----升序
* 3)输出arr排序后的结果
*/
int[] arr = new int[10];
for(int i=0;i
arr[i] = (int)(Math.random()*100);
System.out.println(arr[i]);
}
for(int i=0;i
for(int j=0;j
if(arr[j]>arr[j+1]){ //每次都和它下一个元素比
int t = arr[j];
arr[j] = arr[j+1];
arr[j+1] = t;
}
}
}
System.out.println("排序后:");
for(int i=0;i
System.out.println(arr[i]);
}
}
}
12.方法
1)方法： 1)封装一段特定的业务逻辑功能 2)方法尽可能的独立，一个方法只干一件事 3)方法可以被反复调用多次 4)减少代码的重复，有利于代码的维护，有利于团队的协作
2)方法的定义:
修饰词 返回值类型 方法名(参数列表){
方法体
}
(1)当方法需要结果时设计返回值的类型(2) 当不需要结果时候，设计反回自的类型为void (3)返回结果通过通过return关键字
3)方法的调用
(1)无返回值: 方法名(有参传参);
(2)有返回值: 数据类型 变量 = 方法名(有参传参);
4)return的用法:(1)return 值; //1.1)结束方法的执行 1.2)返回结果给调用方 (2)return; //2.1)结束方法的执行(只能用在无返回值的方法中)
//**方法的演示
//1.有参有返回值
public static double plus(double num1,double num2){
double num = num1+num2;
return num; //返回的是num中的那个数
//return num1+num2; //返回num1与num2的和
}
//2.无参有返回值
public static int getNum(){
//return; //编译错误，return后必须跟一个值
//return 8.88; //编译错误，return的值必须与返回值类型匹配
return 88; //1)结束方法的执行 2)返回一个值给调用方
}
//3.有参无返回值
public static void sayHi(String name){
System.out.println("大家好，我叫"+name);
if(boolean){
return; //1)结束方法的执行
}
}
//4.无参无返回值
public static void say(){
System.out.println("大家好，我叫WKJ");
}
}
//**猜字符小游戏
import java.util.Scanner;
//猜字符小游戏
public class Guessing {
//主方法
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
char[] chs = generate(); //获取随机字符数组
System.out.println(chs);
int count = 0; //猜错的次数
while(true){ //自造死循环
System.out.println("猜吧!");
String str = scan.next().toUpperCase(); //获取用户输入的字符串，并转换为大写字母
if(str.equals("EXIT")){
System.out.println("下次再来吧!");
break;
}
char[] input = str.toCharArray(); //将字符串转换为字符数组
int[] result = check(chs,input); //对比随机字符数组与用户输入的字符数组
if(result[0]==chs.length){ //猜对了
int score = 100*chs.length-10*count; //1个字符100分，猜错一次扣10分
System.out.println("恭喜你，猜对了!，得分为:"+score);
break;
}else{ //猜错了
count++; //猜错次数增1
System.out.println("字符对个数为:"+result[1]+"，位置对个数为:"+result[0]);
}
}
}
//生成随机字符数组
public static char[] generate(){
char[] chs = new char[5]; //随机字符数组
char[] letters = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
'W', 'X', 'Y', 'Z' }; //随机字符范围数组
boolean[] flags = new boolean[letters.length]; //开关数组(与letters相对应)
for(int i=0;i
int index;
do{
index = (int)(Math.random()*letters.length); //随机下标(0到25)
}while(flags[index]==true); //当下标index对应的开关为true时，表示已存过，则重新生成下标index
//当下标index对应的开关为false时，表示未存过，则字符可存，循环结束
chs[i] = letters[index]; //基于下标index到letters中获取字符，并赋值给chs中的每一个元素
flags[index] = true; //将下标index对应的开关修改为true，表示已存过
}
return chs;
}
//对比:随机字符数组与用户输入的字符数组
public static int[] check(char[] chs,char[] input){
int[] result = new int[2]; //对比的结果，假设result[1]为字符对个数，result[0]为位置对个数
for(int i=0;i
for(int j=0;j
if(chs[i]==input[j]){ //字符对
result[1]++; //字符对个数增1
if(i==j){ //位置对
result[0]++; //位置对个数增1
}
break; //剩余input元素不再参与比较了
}
}
}
return result;
}
}
扫一扫
1241
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
