目录
一、计算机基础
1.计算机：
1.1硬件系统
1.2软件系统
2.常见的dos命令：
cd（切换目录）、dir（列出当前目录下的文件和文件夹）、mkdir（新建文件夹）、rmdir（删除空文件夹）、exit（退出dos命令行）、cls（清屏）
二、JAVA语言概述
1.JAVA语言的发展史：
詹姆斯▪高斯林java之父；
java是由Sun Microsystems公司于1995年5月推出的Java面向对象程序设计语言和Java平台的总称；
后被oracle（甲骨文）公司收购。
2.JAVA语言的版本:
JavaSE(J2SE)(Java2 Platform Standard Edition，java平台标准版）
JavaME(J2ME)(Java2 Platform Micro Edition，java平台微型版)。
JavaEE(J2EE)(Java2 Platform,Enterprise Edition，java平台企业版)
3.JAVA语言的特性:
简单性、高性能编译性、解释性、面向对象、分布式处理、健壮性、安全性、开源、跨平台
java语言的跨平台原理：
java源程序（.java文件）通过编译器编译成为.class字节码文件，而它的class文件是基于字节码（以byte为单位存储的文件）的，而字节码文件是描述程序要运行的的虚指令的集合，这些虚指令的集合与任何的平台无关，Java虚拟机认识它（只要在不同的平台下配置相应的jre运行jvm就实现了java的跨平台）。
4.jdk：
JDK是java的软件开发工具包JDK包含JRE是整个Java的核心,JRE包含了JVM是运行JAVA程序所必须的环境的集合,JVM是java虚拟机,整个java实现跨平台最核心的部分。
1.1安装：
1.2检验是否安装成功：
打开dos窗口输入：java -version
三、编辑器eclipse：
四、Java语法
1.语法：
创建项目Javaproject--》创建包package（域名倒写）--》创建类class（首字符大写，见名知意）--》创建方法（驼峰命名，见名知意）
class HelloWorld{ //类
public static void main(String [] args){//main方法又称主方法，程序入口
System.out.println(“Hello World”); //打印输出语句
}
}
2.注释：
① //---》单行注释
② /*多行注释*/
③ /**文档（段落）注释*/
3.Java的命名规则：
①标识符可以由字母、数字、下划线（_）、美元符（$）组成，但不能包含 @、%、空格等其它特殊字符。
②不能以数字开头。
③标识符是严格区分大小写的。
④标识符的命名最好能反映出其作用，做到见名知意。
4.Java中关键字和保留字：
1.1关键字：
在编辑器中标红的单词皆为关键字不可用来命名。
2.2保留字：
const、goto
5.常量与变量：
常量：固定不变的或者被final修饰的变量。
变量：定义的可变的值。
6.数据类型：
1.1基本数据类型:
整型：
byte、short、int、long
浮点型：
float、double
字符型：
char
布尔值：
boolean
1.2引用类型：
除8大基本数据类型以外的类型。
基本数据类型：byte、short、int、long、float、double、char、boolean
包装类：Byte、Short、Integer、Long、Float、Double、Character、Boolean
1.3基本数据类型转换：
低 ------------------------------------> 高
byte,short,char—> int —> long—> float —> double
规则：
1.由低转高自动转；
2.由高转低强制转；
7.运算符：
1.1算数运算符：
+ 加 - 减 * 乘 / 除 % 取余
++ 自增【符号在前，先变化再使用】
-- 自减【符号在后，先使用再变化】
1.2关系运算符：
== 恒等于 != 不等于 < 大于 > 小于
1.3 逻辑运算符
& 与 | 或 !非 && 逻辑与（短路与） || 逻辑或（短路或） + 连接符
1.4三元运算符（条件运算符）：
？: A?B:C 如果A为真则取B，如果A为假则取C。
1.5赋值运算符：
= 赋值运算符
+= 加和赋值操作符：将左操作数和右操作数的值相加赋值给左操作数（a+=b相当于a=a+b）
-= 减和赋值操作符：将左操作数和右操作数的值相减赋值给左操作数（a-=b相当于a=a-b）
*= 乘和赋值操作符：将左操作数和右操作数的值相乘赋值给左操作数（a*=b相当于a=a*b）
/= 除和赋值操作符：将左操作数和右操作数的值相除赋值给左操作数（a/=b相当于a=a/b）
8.if分支结构（判断语句）：
单分支：
if（判断条件）{
执行语句;
}
多分支：
if（判断条件）{
执行语句1;
}else{
执行语句2;
}
嵌套分支：
if（判断条件1）{
执行语句1;
}else if（判断条件2）{
执行语句2;
}else if（判断条件3）{
执行语句3;
}else{
执行语句4;
}
2.分支结构switch
2.1概述：
当一个case成立，从这个case向后穿透所有case，包括default，直到程序结束或者遇到break程序才结束。
2.2形式：
import java.util.Scanner;
public class Demo {
public static void main(String[] args) {
System.out.println("请输入所选的季节：");
int i = new Scanner(System.in).nextInt();
switch (i) {
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("春夏秋冬");
break;
}
}
}
3.for循环
3.1形式
for(开始条件；循环条件；更改条件){
循环体代码…
}3.2for循环运行流程
public class Demo {
public static void main(String[] args) {
for (int i = 0; i <=10; i++) {
System.out.println(i);
}
}
}
面试题：
当一个&表达式在求值的时候，两个操作数都会被求值，&&更像 是一个操作符的快捷方式。当一个&&表达式求值的时候，先计算第一个操作数，如果它返回true才会计算第二个操作数。如果第一个操作数 取值为fale,第二个操作数就不会被求值。
面试题：
byte a = 1;
// a=(byte) (a+4);//右侧int，左侧byte，大转小，强转。
// a=(byte) (a+4);//右侧int，左侧byte，大转小，强转。
a+=4;//会自动完成数据类型的转换
//注意：a=a+4和a+=4是有区别的！！
System.out.println(a);
4.嵌套循环for：
4.1概述：
根据外层的条件，判断里层能否执行，如果能执行，就把里层代码都循环完毕后，再继续执行外层，继续判断。
4.2形式：
for(开始条件；循环条件；更改条件){
for(开始条件；循环条件；更改条件){
循环体代码…
}
}4.3嵌套for运行流程
public class Demo {
public static void main(String[] args) {
for (int i = 0; i <=10; i++) {
for (int j = 0; j <=i; j++) {
System.out.print("*"+" ");
}
System.out.println();
}
}
}4.4break和continue
面试题：
break和continue的区别：
break是指终止本循环（跳出循环）。
continue是指终止本次循环，继续下一次循环。
5.while循环
5.1格式：
while(执行条件){
代码…
}6.do-while循环
6.1格式：
do{
代码…
}while(执行条件);面试题：
while和do-while的区别：
while循环：先判断，后执行。
do-while循环：先执行，后判断，最少执行一次。
7.变量
7.1局部变量
定义在方法里，或者局部代码块中。
注意：必须手动初始化，来分配内存。如：int i=5;
作用域也就是方法里或者局部代码块里，方法运行完内存就释放了。
7.2成员变量
定义在类里。
注意：不用初始化，也会自动被初始化成默认值。
作用域是整个类中，类消失了，变量才释放。
| 基本类型 | 默认值 |
| byte | 0 |
| short | 0 |
| int | 0 |
| long | 0L |
| float | 0.0f |
| double | 0.0d |
| boolean | false |
| char | /u0000 |
| 引用类型 | null |
8.方法
8.1形式
修饰符 返回值 方法名(【参数】){
方法体;
}8.2方法重载
在同一类中定义多个同名方法；
方法名相同，参数列表不同。
public class Demo {
public static void main(String[] args) {
new Demo().play();
new Demo().play(10);
new Demo().play(20,"tom");
}
public void play() {
System.out.println("方法1");
}
public void play(int a) {
System.out.println("方法2");
}
public void play(int a,String b) {
System.out.println("方法3");
}
}9.数组
9.1创建数组：
动态初始化：
int[] a = new int[5];静态初始化：
int[] a ={1,2,3,4,5,6,7,8};
int[] a =new int[]{1,2,3,4,5};9.2数组长度：
Ø length属性获取数组长度
Ø 数组一旦创建，长度不可变
Ø 允许0长度的数组
9.3数组遍历：
public class Demo {
public static void main(String[] args) {
int a[] = {1,5,5,8,6};
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]+",");
}
}
}
9.4数组工具类Arrays：
把数组里的数据，用逗号连接成一个字符串。
import java.util.Arrays;
public class Demo {
public static void main(String[] args) {
int a[] = { 1, 5, 5, 8, 6 };
System.out.println(Arrays.toString(a));
}
}
对数组排序，对于基本类型的数组使用优化后的快速排序算法，效率高。
对引用类型数组，使用优化后的合并排序算法。默认为升序。
import java.util.Arrays;
public class Demo {
public static void main(String[] args) {
int a[] = { 1, 5, 5, 8, 6 };
Arrays.sort(a);
System.out.println(Arrays.toString(a));
}
}3. Arrays.copyOf(数组，新的长度)：复制数组
把数组复制成一个指定长度的新数组。
新数组长度大于原数组，相当于复制，并增加位置。--数组的扩容
新数组长度小于原数组，相当于截取前一部分数据。--数组的缩容
import java.util.Arrays;
public class Demo {
public static void main(String[] args) {
int a[] = { 1, 5, 5, 8, 6 };
int b[] = Arrays.copyOf(a, 7);
System.out.println(Arrays.toString(b));
}
}
10.算法了解
10.1冒泡排序
原理：比较两个相邻的元素，将值大的元素交换至右端。
思路：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复第一趟步骤，直至全部排序完成。
举例说明：要排序数组：int[] arr={6,3,8,2,9,1};
第一趟排序：
第一次排序：6和3比较，6大于3，交换位置： 3 6 8 2 9 1
第二次排序：6和8比较，6小于8，不交换位置：3 6 8 2 9 1
第三次排序：8和2比较，8大于2，交换位置： 3 6 2 8 9 1
第四次排序：8和9比较，8小于9，不交换位置：3 6 2 8 9 1
第五次排序：9和1比较：9大于1，交换位置： 3 6 2 8 1 9
第一趟总共进行了5次比较， 排序结果： 3 6 2 8 1 9
---------------------------------------------------------------------
第二趟排序：
第一次排序：3和6比较，3小于6，不交换位置：3 6 2 8 1 9
第二次排序：6和2比较，6大于2，交换位置： 3 2 6 8 1 9
第三次排序：6和8比较，6大于8，不交换位置：3 2 6 8 1 9
第四次排序：8和1比较，8大于1，交换位置： 3 2 6 1 8 9
第二趟总共进行了4次比较， 排序结果： 3 2 6 1 8 9
---------------------------------------------------------------------
第三趟排序：
第一次排序：3和2比较，3大于2，交换位置： 2 3 6 1 8 9
第二次排序：3和6比较，3小于6，不交换位置：2 3 6 1 8 9
第三次排序：6和1比较，6大于1，交换位置： 2 3 1 6 8 9
第二趟总共进行了3次比较， 排序结果： 2 3 1 6 8 9
---------------------------------------------------------------------
第四趟排序：
第一次排序：2和3比较，2小于3，不交换位置：2 3 1 6 8 9
第二次排序：3和1比较，3大于1，交换位置： 2 1 3 6 8 9
第二趟总共进行了2次比较， 排序结果： 2 1 3 6 8 9
---------------------------------------------------------------------
第五趟排序：
第一次排序：2和1比较，2大于1，交换位置： 1 2 3 6 8 9
第二趟总共进行了1次比较， 排序结果： 1 2 3 6 8 9
---------------------------------------------------------------------
最终结果：1 2 3 6 8 9
---------------------------------------------------------------------
冒泡排序的优点：每进行一趟排序，就会少比较一次，因为每进行一趟排序都会找出一个较大值。如上例：第一趟比较之后，排在最后的一个数一定是最大的一个数，第二趟排序的时候，只需要比较除了最后一个数以外的其他的数，同样也能找出一个最大的数排在参与第二趟比较的数后面，第三趟比较的时候，只需要比较除了最后两个数以外的其他的数，以此类推……也就是说，没进行一趟比较，每一趟少比较一次，一定程度上减少了算法的量。
public class Case01 {
public static void main(String[] args) {
int a[] = { 5, 8, 2, 4, 9, 1 };
for (int i : a) {
System.out.print(i + " ");
}
System.out.println();
int temp;// 定义一个临时变量
// 第一层循环i表示排序的轮数，第二层循环j表示比较的次数。
for (int i = 0; i < a.length - 1; i++) {
for (int j = 0; j < a.length - 1 - i; j++) {
if (a[j] > a[j + 1]) {
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
System.out.println(Arrays.toString(a));
}
}
559
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
