JAVASE和JAVAEE的区别

JDK的安装路径

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-perPRPgq-1608641067105)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222001641906.png)]

卸载和安装JDK

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SYnXvbAn-1608641067107)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222001805046.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4KQ1Ie9x-1608641067110)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222002723760.png)]

第一个hello，word程序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B7ZO5eF5-1608641067111)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222094909864.png)]

Ctrl 加insert复制

shift加insert粘贴

public class hello{public static void main(String[] args){System.out.print("Hello,World!");}
}

JAVA的运行机制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3sucdYRf-1608641067112)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222095842464.png)]

标识符注意点

所有的标识符都应该以字母(A-Z 或者a-z) ,美元符($)、或者下划线( )开始
首字符之后可以是字母(A-Z 或者a-z) ,美元符($) 、下划线(或数字的任何字符组合
不能使用关键字作为变量名或方法名。
标识符是大小写敏感的
可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音,很Low

什么是字节

位(bit) :是计算机内部数据储存的最小单位，11001100是一个八位二进制数。
字节(byte) :是计算机中数据处理的基本单位，习惯上用大写B来表示,
1B (byte,字节) = 8bit (位)
字符:是指计算机中使用的字母、数字、字和符号

数据类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Gxmcm4g7-1608641067113)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222110344066.png)]

boolean不能进行数据转换其他数据类型为字节单位，boolean是以位为单位

浮点数拓展

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IVccue9F-1608641067114)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222110613641.png)]

银行中的应用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y7lZwlrj-1608641067115)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222110859787.png)]

类型转换

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fPdSKPrJ-1608641067116)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222111856239.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kMPPYrXB-1608641067117)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222112123644.png)]

低-------------------------------> 高 byte, short,char-> int -> long-> float -> double

String不是基本的数据类型

变量和常量

变量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o7i20k9e-1608641067118)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222112937451.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cdZh5cIA-1608641067119)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222113352348.png)]

变量的命名规范

所有变量、方法、类名：见名知义
类成员变量:首字母小写和驼峰原则: monthSalary
局部变量:首字母小写和驼峰原则
常量:大写字母和下划线: MAX_ VALUE
类名:首字母大写和驼峰原则: Man, GoodMan
方法名:首字母小写和驼峰原则: run(), runRun()

位运算

位运算符<<、>>效率极快

字符串连接符+

System . out .println("" +a+b);//""先和a拼接，在和b拼接，a+b不进行算术运算
System . out. println(a+b+"");//a+b先进行算术运算，在和""拼接

包机制

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。
包语句的语法格式为:
```
package pkg1[. pkg2[. pk...]];
```
一般利用公司域名倒置作为包名;com.wdl.base
为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用"import"语句可完成此功能
```
import package1[. package..].(classname |*);
```

Java Doc生成自己的帮助文档

javadoc命令是用来生成自己API文档的
参数信息
- @author作者名
- @version 版本号
- @since 指明需要最早使用的jdk版本
- @param参数名
- @return 返回值情况
- @throws 异常抛出情况
用IDEA构建javadoc

https://www.cnblogs.com/noKing/p/8006298.html

用户交互Scanner(获取用户的输入)

next()和hasNext()

public class Demo02_Scanner {public static void main(String[] args) {//创建一个扫描器对象，用于接收键盘数据Scanner scanner = new Scanner(System.in);System.out.println("使用next方式接收: ");//判断用户有没有输入字符串if (scanner.hasNext()){//使用next方式接收String str = scanner.next();//程序会等待输入内容，不输入会卡在这里System.out.println("输出的内容为: "+str);}//凡是属于IO流的类如果不关闭会一直占用资源.要养成好习惯用完就关掉scanner.close();}
}

nextLine()和hasNextLine()

public class Demo02_Scanner {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("使用nextLine方式接收: ");//判断是否还有输入if (scanner.hasNextLine()) {String str = scanner.nextLine();System.out.println("输出的内容为: " + str);}scanner.close();}
}

next()和nextline()的区别

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cKFAhLJ3-1608641067120)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222132536621.png)]

switch语句

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CphiOLXQ-1608641067121)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222134426179.png)]

do-while(注意while后面的分号)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mE7rVfxJ-1608641067121)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222142429380.png)]

break和continue的区别

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BlbOruhX-1608641067122)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222144458031.png)]

三角形的打印

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xhP1Pbis-1608641067123)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222145112027.png)]

方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数。
方法的重载的规则:
- 方法名称必须相同。
- 参数列表必须不同(个数不同、或类型不同、参数排列顺序不同等)。(必须满足)
- 方法的返回类型可以相同也可以不相同。
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AhDtFw7k-1608641067123)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222150754110.png)]
- 仅仅返回类型不同不足以成为方法的重载。
实现理论:

方法名称相同时,编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

命令行传参

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dZtREBGc-1608641067124)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222151531483.png)]

可变参数(本质是数组)

JDK 1.5开始，Java支持传递同类型的可变参数（不定项）给一个方法。
在方法声明中，在指定参数类型后加一个省略号(…)。
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

public class Demo08 {public static void main(String args[]) {//调用可变参数的方法printMax(15,22.0,36,25.3);printMax(new double[]{1, 2, 3});//本质为数组}public static void printMax(double... numbers) {if (numbers.length == 0) {System.out.println("No argument passed");return;}double result = numbers[0];//排序!for (int i = 1; i < numbers.length; i++) {if (numbers[i] > result) {result = numbers[i];}}System.out.println("The max value is " + result);}
}

递归的原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EpiDBUHQ-1608641067125)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222152846380.png)]

简易计算器

package com.kuang.scanner;
import java.util.Scanner;
public class hello {public static void main(String[] args) {Scanner s = new Scanner(System.in);System.out.print("请输入第一个数字：");int num1 = s.nextInt();System.out.print("请输入运算符：");String operator = s.next();System.out.print("请输入第二个数字：");int num2 = s.nextInt();int result = 0;switch (operator) {case "+":result = num1 + num2;break;case "-":result = num1 - num2;break;case "*":result = num1 * num2;break;case "/":result = num1 / num2;break;case "%":result = num1 % num2;break;default:System.out.println("你的输入不合法！！！");}System.out.println(num1 + operator + num2 + "=" + result);}
}

数组

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法:

dataType[] arrayRefVar; // 首选的方法
或
dataType arrayRefVar[]; // 效果相同，但不是首选方法

Java语言使用new操作符来创建数组，语法如下:(前后数据类型必须一致)
```
dataType[] arrayRefVar = new dataType[arraySize] ;
```
数组的元素是通过索引访问的,数组索引从0开始。

二维数组的输出

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RFkyoqjQ-1608641067126)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222164548450.png)]

内存分析—三种初始化

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8pA8ijqW-1608641067127)(D:\image-20201222155715184.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-98hEQl4e-1608641067128)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222155834796.png)]

冒泡排序(小升级)

package com.kuang.scanner;
import java.util.Arrays;
public class hello {public static void main(String[] args) {int[] a = {1, 4, 5, 6, 72, 2, 2, 2, 25, 6, 7};int[] sort = sort(a); //调用完我们自己写的排序方法以后，返回一个排序后的数组System.out.println(Arrays.toString(sort));}public static int[] sort(int[] array) {//临时变量int temp = 0;//外层循环，判断我们这个要走多少次;for (int i = 0; i < array.length - 1; i++) {Boolean flag = false;//内层循环，比价判断两个数，如果第一个数，比第二个数大,则交换位置(相邻两个数之间的比较)for (int j = 0; j < array.length - 1 - i; j++) {if (array[j + 1] > array[j]) {temp = array[j];array[j] = array[j + 1];array[j + 1] = temp;flag = true;}}if (flag == false){break;}}return array;}
}

稀疏数组(数组压缩)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8XN55TQL-1608641067128)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222165501101.png)]

package com.kuang.scanner;public class hello {public static void main(String[] args) {//创建一个元素的二维数组 11*11  0：没有棋子 1： 黑棋   2： 白棋int chessArry1[][] = new int[11][11];chessArry1[1][2] = 1;chessArry1[2][3] = 2;for (int [] row : chessArry1) {for ( int data : row) {System.out.printf("%d\t", data);}System.out.println();}int[][] paraseArr =  transformSparseArr(chessArry1);transformArry(paraseArr);}//二维数组 转 稀疏数组public static int[][] transformSparseArr( int[][] arry) {int sum =0;  // 有效值的个数int rowSize = 0;//1、计算出有效的个数for (int[] row :arry) {for ( int data :row) {rowSize = row.length;if (data != 0) {sum++;}}}//创建稀疏数组 并给稀疏数组赋值int [][] sparseArr= new int[sum+1][3];sparseArr [0][0] = arry.length;sparseArr [0][1] = rowSize;sparseArr [0][2] = sum;//count 计数器 计算放入的有效个数 即第几个非零数据int count = 0;for (int i = 0; i < arry.length; i++) {for (int j = 0; j < rowSize ; j++) {if (arry[i][j] != 0) {count++;sparseArr[count][0] = i;sparseArr[count][1] = j;sparseArr[count][2] = arry[i][j];}}}// 输出稀疏数组形式System.out.println("===========稀疏数组============");for (int i = 0; i < sparseArr.length; i++) {// %d 占位符 \t 制表符  \n 换行System.out.printf("%d\t%d\t%d\t\n", sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);}System.out.println();return sparseArr;}// 稀疏数组 转化为 二维数组public static int[][] transformArry(int[][] parseArr) {int row = parseArr[0][0]; //得到行int col = parseArr[0][1]; //得到列//数组恢复 并赋值int[][] arry = new int[row][col];for (int i = 1 ; i < parseArr.length; i++) {arry[parseArr[i][0]][parseArr[i][1]] = parseArr[i][2];}// 输出System.out.println("============二维数组恢复==============");for (int [] rows: arry) {for (int data : rows) {System.out.printf("%d\t", data);}System.out.println();}return arry;}
}

面向对象

面向对象编程的本质就是:以类的方式组织代码，以对象的组织(封装)数据

三大特性:

封装
继承
多态

方法调用

静态方法

可以通过类直接调用，在类加载时加载，不能调用非静态方法

public class Demo01Static {public static void main(String[] args) {Student.say();}
}public class Student {public static void say(){System.out.println("学生说话了");}
}

非静态方法

通过实例化对象调用

public class Demo01Static {public static void main(String[] args) {Student student = new Student();student.say();}
}public class Student {public void say(){System.out.println("学生说话了");}
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0UWi3Mdr-1608641067129)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222184401007.png)]

自动生成返回值

按快捷键ctrl+alt+v

构造器

类中的构造器也称为构造方法,是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:
- 必须和类的名字相同
- 必须没有返回类型,也不能写void

构造器必须要掌握

public class Person {//一个类即使什么都不写，它也会存在个方法//显示的定义构造器String name ;int age;//alt+ insert 可以快捷生成构造器//1.使new关键字， 本质是在调用构造器//2.用例初始化值public Person(){ }//有参构造:一旦定义 了有参构造。无参就必须显示定义，否则调用无参构造器时程序会报错public Person(String name){this.name = name ;}public Person(String name, int age) {this. name = name;this.age = age;}
}

构造器:
- 和类名相同
- 没有返回值
作用:
- new本质在调用构造方法
- 初始化对象的值
注意点:

定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造

Alt加insert

默认生成有参，select none生成无参

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2Fb1eqig-1608641067130)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222183536201.png)]

创建对象内存分析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XqzJnKlN-1608641067131)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222184200492.png)]

封装

属性私有，get/set

可以提高安全性

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GrVBgpI4-1608641067132)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222185047275.png)]

继承

extands的意思是“扩展”。子类是父类的扩展。
JAVA中类只有单继承，没有多继承!
被final修饰的类不能被继承。

object类

java中的所有类都直接或间接继承Object类

Ctrl加H

可以查看当前类的继承树

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bpOTtWOC-1608641067133)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222185819780.png)]

super

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YMs7rmIH-1608641067134)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222190340430.png)]

可以省略

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ibzw3KLw-1608641067134)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222190857594.png)]

super注意点:
- super调用父类的构造方法，必须在构造方法的第一个
- super 必须只能出现在子类的方法或者构造方法中!
- super和 this 不能同时调用构造方法!
Vs this:
- 代表的对象不同: this 本身调用者这个对象 super:代表父类对象的应用
- 前提 this:没有继承也可以使用 super:只能在继承条件才可以使用
- 构造方法 this() ; 本类的构造 super():父类的构造!

方法重写

父类静态方法

public class Demo04_A extends Demo04_B{public static void test(){System.out.println("A==>test()");}
}
//重写都是方法的重写，和属性无关
public class Demo04_B {public static void test(){System.out.println("B==>test()");}
}
public class Applications {public static void main(String[] args) {//Demo04//方法的调用只和左边，定义的数据类型有关Demo04_A a = new Demo04_A();a.test();//A==>test()//父类引用指向引用Demo04_B b = new Demo04_A();b.test();//B==>test()}
}

父类非静态方法

public class Applications {public static void main(String[] args) {//Demo04/*静态方法和非静态方法区别很大静态方法：方法的调用只和左边，定义的数据类型有关非静态方法：重写，父类方法只能是public*/Demo04_A a = new Demo04_A();a.test();//A==>test()//父类引用指向引用Demo04_B b = new Demo04_A();//子类重写了父类的方法b.test();//A==>test()}
}
//重写都是方法的重写，和属性无关
public class Demo04_B {public void test(){System.out.println("B==>test()");}
}
public class Demo04_A extends Demo04_B{@Overridepublic void test() {System.out.println("A==>test()");}
}

重写:需要有继承关系，子类重写父类的方法!

方法名必须相同
参数列表列表必须相同
修饰符:范围可以扩大但不能缩小:public>Protected >Default>private
抛出的异常:范围，可以被缩小，但不能扩大: ClassNotFoundException --> Exception(大)
重写，子类的方法和父类必要一致;方法体不同!

多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
- 注意:多态是方法的多态，属性没有多态性。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-v7cw29Ei-1608641067135)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222193111508.png)]

public class Person {public void run(){System.out.println("Person==>run()");}
}
public class Student extends Person{@Overridepublic void run() {System.out.println("Student==>run()");}public void stop(){System.out.println("Student==>stop()");}
}
public class Applications {public static void main(String[] args) {// 一个对象的实际类型是确定的:new Student();new Person();//可  以指向的引用类型就不确定了:父类的引用指向子类//Student 能调用的方法都是自己的或者继承父类的!Student s1 = new Student();//Person 父类型，可以指向子类，但是不能调用子类独有的方法Person s2 = new Student();Object s3 = new Student();//对象能执行哪些方法，主要看对象左边的类型，和右边关系不大!s2.run(); //子类重写了父类的方法。执行子类的方法 Student==>run()s1.run();//Student==>run()s1.stop();//Student==>stop()Person p1 = new Person();p1.run();//Person==>run()}
}

多态注意事项:

多态是方法的多态，属性没有多态
父类和子类，有联系类型转换异常! ClassCastException!
存在条件: 继承关系，方法需要重写，父类引用指向于类对象! Father f1 = new Son();
不能进行多态的方法：
- static 方法，属于类，它不属于实例
- final常量;
- private 方法;|

父子类强转

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XUuDcV9Z-1608641067136)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222194544016.png)]

父类转子类

public class Application {public static void main(String[] args) {//类型之间的转化:父子//高               低Person obj = new Student();//student将这个对象转换为Student类型，我们就可以使student类型的方法了!((Student) obj).go();}
}

子类转父类

public class Application {public static void main(String[] args) {//类型之间的转化:父           子//子类转换为父类，可能丢失自己的本来的一些方法!Student student = new Student();student.go();Person person = student;}
}

instanceof

(类型转换)引用类型，判断一个对象是什么类型~

public class Applications {public static void main(String[] args) {Object object = new Student();//System. out . println(X instanceof Y);//能不能编译通过! X,Y之间要存在父子关系//System. out . println(X instanceof Y);// X是Y之的子类，trueSystem.out.println(object instanceof Student); //trueSystem.out.println(object instanceof Person); //trueSystem.out.println(object instanceof Object); //trueSystem.out.println(object instanceof Teacher); //FalseSystem.out.println(object instanceof String); //FalseSystem.out.println("===========================");Person person = new Student();System.out.println(person instanceof Student); //trueSystem.out.println(person instanceof Person); //trueSystem.out.println(person instanceof Object); //trueSystem.out.println(person instanceof Teacher); //False//System.out.println(person instanceof String); //不能通过编译System.out.println("===========================");Student student = new Student();System.out.println(student instanceof Student); //trueSystem.out.println(student instanceof Person); //trueSystem.out.println(student instanceof Object); //true//System.out.println(student instanceof Teacher); //不能通过编译//System.out.println(student instanceof String); //不能通过编译}
}

static

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0W7YHhFH-1608641067136)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222195218953.png)]

静态导入包

import static java.lang.Math.random;
import static java.lang.Math.PI;
public class He {public static void main(String[] args) {System.out.println(random());System.out.println(PI);}
}