|
|
# Javase回顾
## 1.环境
jdk8及之前：jdk+jrejdk：java development kitjre: java runtime environmentjdk8以后：只有jdk环境变量配置只需要配置JAVAHOME和path里面指向JAVAHOME的bin## 2.开发工具
idea(目前最流行)eclipse(已经不常用)## 3.基础语法
### 3.1 java语言特点
简单，严谨，易读编译+解释### 3.2 8种基本数据类型
|数据类型 | 精度 | 范围||--|--|--|| byte | 1 |-2^7^ ~ 2^7^-1（-128～127）| short | 2|-2^15^ ~ 2^15^-1（-32768 ~ 32767）| int | 4|-2^31^ ~ 2^31^-1（约21亿多）|long| 8 |-2^63^~ 2^63^-1（-9223372036854775808 ～ 9223372036854775807）| float | 4 |约±3.4e38（± 3.4 × 10^38^ ）| double | 8 | 约±1.7e308（± 1.7 × 10^308^ ）| char | 2 |0 ~ 65535（Unicode）| boolean | 1(不一定，不同虚拟机不一样 ) | ### 3.3 运算符
> 算数运算符 ：+ - * / % 双目运算符
> 比较运算符 ： > , <, >= , <=, == , != 计算结果是boolean值
> 逻辑运算符:&& , ||, ! 运算结果是boolean值，存在短路运算
> 赋值运算符： = ,+=, -=, *= , /=
> 条件运算符 a?b:c 唯一的三目运算符
> 位运算符：基本用不到
> 其他运算符：instanceof (例：a instanceof b )
> 表达式（有值）
> ### 3.4语句
> java代码执行的基本单位
>流程控制语句：>1.顺序结构：>2.分支结构：>3.循环结构：
### 3.5 数组
>int[] a = new int[](1,2,3}>获取数组长度。.length属性，只读。>如果访问数组元素。索引（下标），整数，包括0，不能是负数，不能是小数，不能超>出边界。
```javapublic class Test1 { public static void main(String[] args) { int[] a = new int[5]; int[] b = new int[]{1, 2, 3, 4, 5}; int[] c = {1, 2, 3, 4, 5}; System.out.println(c.length); a[0] = 1; a[1] = 2; a[40] = 4; }}
```
```javaimport java.util.Arrays;
public class Test2 { public static void main(String[] args) { int[] arr = new int[20]; //存入随机数 for (int i = 0; i < arr.length; i++) { arr[i] = (int) (Math.random() * 100); } //输出随机数数组 System.out.println(Arrays.toString(arr));
boolean found = false; //判断生成的随机数数组中包不包含50并给出下标 for (int i = 0; i < arr.length; i++) { if (arr[i] == 50) { found = true; System.out.println(i); break; } } if (!found) { System.out.println("无此值"); }
}}
```
数组应用： 排序:冒泡，选择，快排
```javaimport java.util.Arrays;
public class Test3 { public static void main(String[] args) { int[] arr = {44, 64, 35, 66, 10, 67, 86, 32, 2, 44}; quickSort2(arr);//调用函数 System.out.println(Arrays.toString(arr)); }
//冒泡 static void bubbleSort(int[] arr) { for (int i = 0; i < arr.length - 1; i++) { for (int j = 0; j < arr.length - 1 - i; j++) { if (arr[j] < arr[j + 1]) { int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } }
static void bubbleSort2(int[] arr) { for (int i = 0; i < arr.length - 1; i++) { for (int j = 0; j < arr.length - 1 - i; j++) { if (arr[j] > arr[j + 1]) { int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } }
//选择 static void selectSort(int[] arr) { for (int i = 0; i < arr.length - 1; i++) { for (int j = i + 1; j < arr.length; j++) { if (arr[j] < arr[i]) { int temp = arr[j]; arr[j] = arr[i]; arr[i] = temp; } } } }
static void selectSort2(int[] arr) { for (int i = 0; i < arr.length - 1; i++) { for (int j = i + 1; j < arr.length; j++) { if (arr[j] < arr[i]) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } } }
//快排 static void quickSort(int[] arr) { quickSort(arr, 0, arr.length - 1); }
static void quickSort2(int[] arr) { quickSort2(arr, 0, arr.length - 1); }
//快排实现 static void quickSort(int[] arr, int low, int high) { if (low >= high) { return; } int pivot = arr[low];//基准值 int left = low;//左指针 int right = high;//右指针
while (left < right) { //右指针不断左移 while (left < right && arr[right] >= pivot) { right--; } //左指针不断右移 while (left < right && arr[left] <= pivot) { left++; }
if (left < right) { int temp = arr[left]; arr[left] = arr[right]; arr[right] = temp; } }
//二者相遇 if (left != low) { arr[low] = arr[left]; arr[left] = pivot; }
//递归 quickSort(arr, low, left - 1);//对左区递归 quickSort(arr, left + 1, high);//对右区递归 }
static void quickSort2(int[] arr, int low, int high) { if (low > high) { return; } int target = arr[low]; int left = low; int right = high;
while (left < right) { while (left < right && arr[right] >= arr[low]) { right--; } while (left<right &&arr[left]<=arr[low]){ left++; } if(left<right){ int temp = arr[left]; arr[left]=arr[right]; arr[right]=temp; }
} //left和right相遇 if(left!=low){ arr[low]=arr[left]; arr[left]=target; } quickSort2(arr,low,left-1); quickSort2(arr,left+1,high);
}}
```
查找：二分查找
```javapublic class Test4 { public static void main(String[] args) { int[] arr = {2, 10, 32, 35, 44, 44, 64, 66, 67, 86}; int idx = find2(arr, 0, arr.length - 1, 67); System.out.println(idx); }
static int find(int[] arr, int low, int high, int target) { if (low >= high) { return -1; } int mid = (low + high) / 2; if (target == arr[mid]) { return mid; } else if (target < arr[mid]) { return find(arr, low, mid - 1, target); } else { return find(arr, mid + 1, high, target); } }
static int find2(int[] arr, int low, int high, int target) { if (low >= high) { return -1; } int mid = (low + high) / 2; if (target == arr[mid]) { return mid; } else if (target < arr[mid]) { return find2(arr, low, mid - 1, target);
} else { return find2(arr, mid + 1, high, target); } }}
```
### 3.6 函数（方法）
### 3.7 面向对象
类：类型，将很多实例抽取共性，总结归纳对象：独一无二的实例，在java中，对象通过类创建
创建对象：new 构造方法（）
### 3.8封装
将成员属性和成员方法包含到一个类中，选择性的对外开放成员。
成员访问修饰符：对外开放程度public：公开，公有的，任何位置都可访问。protected：受保护的，包内及后代可以访问。<空>：包内访问。private：当前类内部访问。### 3.9 继承
单继承，默认继承自object,顶级根类1.非私有成员可以被继承2.构造函数不能被继承
protect:super:父对象this:当前对象
```javapackage com.situ.chapter1;
public class Person { public int age;//年龄 private String name;//姓名//无参构造方法 public Person() {
}//有参构造 public Person(String name) { this.name = name; System.out.println("创建Person对象"); }
//行为 protected void sayHello() { System.out.println("父亲sayHello"); }
void wang() { System.out.println("aaa"); sayHello(); }}
```
```javapackage com.situ.chapter1;
public class Teacher extends Person {
public Teacher() { super(); }
@Override protected void sayHello() { System.out.println("儿子sayHello"); }
public void sayBye() { this.sayHello(); super.sayHello();
//System.out.println(super.name); }}```
```javapackage com.situ.chapter1;
public class Test1 { public static void main(String[] args) { Person person = new Person(); person.sayHello(); person.wang(); System.out.println("---------------"); Teacher teacher = new Teacher(); teacher.sayHello(); teacher.sayBye();
}}```
访问构造函数：this（xxx）：调用当前类的构造函数 super(xxx)：调用父类的构造函数
构造函数：对对象的成员属性进行初始化1.与类同名2.无返回值3.如果一个类没有显式定义构造函数，会自动创建一个公有的无参的构造函数,如果显式指定了构造函数，就不会再自动创建无参构造函数4.构造函数是类成员，可以指定修饰符5.创建对象时，使用new<构造函数>（xxx）6.创建子类对象时，必须先调用父类的构造函数7.一个构造函数的第一句代码必须是this(xxx)或者super（xxx）,有且只有一次调用8.如果没有显式调用this(xxx)或super(xxx),默认调用super()### 3.10 多态（非常重要）
在程序运行期间，同一行为，表现出多种形态1.继承或接口2。重写3.使用一个父类型（祖先类型）的引用指向一个子类（后代类）的实例
```javapackage com.situ.chapter2;
public class Animal { public void run() { System.out.println("动物在跑"); }}
```
```javapackage com.situ.chapter2;
public class Cat extends Animal { private static String name;
@Override public void run() { System.out.println("猫在跑"); }}
```
```javapackage com.situ.chapter2;
public class Fish extends Animal { @Override public void run() { System.out.println("鱼在跑"); }}
```
```javapackage com.situ.chapter2;
public class Test1 { static int a = 10; public static void main(String[] args) { Animal animal = new Cat(); run(animal); }
static void run(Animal animal) { animal.run(); }}```### 3.11 static和final
static成员即类成员，属于类的，不属于某个对象，通过类名称直接访问
final：表示最终的，不变的1.修饰类，表示类不能被继承2.修饰方法：表示方法不可被重写3.修饰变量：表示变量为不可变的变量（常量）
### 3.12 抽象类和接口
抽象方法：只有方法定义，没有实现的方法，叫抽象方法抽象类：使用abstract关键字1.使用abstract关键字2.不能创建实例（对象）3.除此之外，和普通类没有区别。4.可以有构造函数。5.抽象类中允许有抽象方法(也可以没有)，普通类中一定没有抽象方法。6.一个类中只要有抽象方法，则必须是抽象类
接口：1.接口不是类。2.接口中只能有抽象方法()，jdk1.8之后新增：静态方法（static）和默认方法(default)3.接口中的方法默认是public abstract修饰，不写也行4.接口中的静态方法和类中的静态方法类似可直接接口名调用5.接口中的默认方法可被继承到实现类中，在默认方法中可以使用this关键字，由实现类来调用
接口提供一定的规范和约束，不提供实现实现类去实现接口 implements实现接口实现类必须对接口中的方法提供实现，如果不能，则只能为抽象类
### 3.13 常用类
1.Object：所有类的终极父类。没有父类hashCode:用于生成对象的唯一(尽量唯一)标识码默认返回对象的内存地址。equals:用于判定两个对象是否逻辑上相等，逻辑是由程序员决定的，重写。默认比较是否同一个内存地址toString:将一个对象以字符串的形式展示clone():克隆一个对象getClass:获取对象的类型实例（Class）
2.String:表达式字符串，不可继承。内容不可变3.Math：数学相关方法4.Date：日期相关。LocalDate,LocalTime,LocalDateTime
### 3.14 集合相关类：
1.List:ArrayList，LinkedList.列表：有序，可重复。2.set:HashSet 集合,无序，不重复3.Map:HashMap 映射：存储键-值对，键无序，不重复
### 3.15 泛型
<T> 类型变量
### 3.16异常
程序出错时的处理方式.挽救或补回措施try...catch...finallycaatch可以已有多个分支，第一个分支，捕获某一个类型的异常finally分支中的代码一定会执行，无论是否出现异常
异常是有类型的
异常分两种：异常分成两种：1.编译时异常，检查异常 ，checkedException。在编译期就要求处理异常。2.运行时异常。RuntimeException。
### 3.17 IO
Input & Output 流对象完成输入输出的
流动的方向分为输入流和输出流
流动的单位：字节流和字符流
介质类型：文件流，网络流，数组流
以Stream结尾的是字节流以InputStream结尾的是输入流流在使用完之后必须关闭，如果忘记，容易内存泄漏
throws：写在方法后面，表示此方法向上抛出异常throw:原地抛出（触发，引发）异常
### 3.18 多线程
进程：Process,操作系统管理的独立的分配资源的单位，依靠端口进行通信一个程序至少有一个进程。如：QQ此时6个进程
线程：Thread。一个进程中可以包含至少一个线程。所有线程共享进程的资源。线程是cpu可调度的最小单位
cpu:单核。一个核心。多核。真正的并行。web开发程序都是并行的，多线程。
### 3.18 反射
反射：java的灵魂,在程序运行期间，在无法直接使用目标类的情况下，以一种间接的方式，去操作对象。Reflect: 镜像。
常用类：Class: 描述其他类，描述类的类Field: 描述字段的类。描述成员属性Method:描述成员方法的。Constructor:描述构造函数的。Parameter:描述方法的参数的。Annotation:描述注解的。
获取Class类型实例三种方式：
|
