JavaSE
JavaSE
冯诺依曼体系结构
计算机软件可以分为系统软件和应用软件。系统软件：DOS、Windows、Linux、Unix、Mac、Android、iOS；应用软件：WPS、QQ、微信…
快捷键：ALT+F4：关闭窗口；shift+delete：永久删除；Windows+R：输入cmd，打开控制台，；WIndows+E：直接打开文件资源管理器；ctrl+shift+esc：打开任务管理器；Windows+Tab：切换应用程序
常见的DOS命令
#盘符切换
#查看所有文件
dir
# 切换目录
cd /d f:
cd /d E:\DingDing
cd .. 返回上一级目录
#清理屏幕 cls
#退出 exit
#IP地址 ipconfig
#打开计算器 clac
#ping命令
#创建文件夹 md xx ;创建文件 cd>a.txt
#删除文件 del a.txt;
#删除文件夹 rd xx
关键词
JAVA强类型语言：所有变量都必须先定义后才能使用
基本数据类型：数值类型（整数类型(byte,short,int,long)，浮点类型(float,double)，字符类型(char)）；Boolean类型
引用数据类型：类；接口；数组
int i=10;
int i2=010;//八进制0
int i3=0x11;//十六进制0x
float是有限的、离散的、有舍入误差、是大约、接近但不相等的
最好不使用浮点数进行比较
所有的字符本质还是数字
类型转换时可能存在内存溢出，或者精度问题
数字之间可以用下划线分割：10_0000_0000
变量作用域：类变量、实例变量、局部变量
public class Variable{
static int allClicks=0; //类变量
String str="hello world"; //实例变量
public void method(){
int i=0; //局部变量
}
}
int类型变量的默认初始值是0，String类型变量的默认初始值是null，布尔值的默认初始值是false
修饰符，不存在前后顺序
常量(Constant)：初始化后不能再改变的值。定义常量一般用大写字符
final double PI=3.14;
int b=a++; //先赋值，再自增
int c=++a; //先自增，再赋值
位运算：
A^B(异或)：相同为0，不同为1
A&B(与)：全为1是1，其余都是0
A|B(或)：全为0是0，其余都是1
左移<<：*2 ；右移>>：/2
int score=80;
String type=score<60?"不及格":"及格";
JavaDoc:
javadoc命令是用来生成自己API文档的，命令行生成文档
javadoc -encoding UTF-8 -charset UTF-8 Doc.java
凡是属于IO流的类如果不关闭会一直占用资源scanner.close()
//创建一个扫描器对象，用于接收键盘数据
Scanner scanner=new Scanner(System.in);
//判断用户有没有输入字符串
if(scanner.hasNext()){
//使用next方式接收，不能得到有空格的字符串,以空白作为结束符或分隔符
String str=scanner.next();
System.out.println(str);
}
if(scanner.hasNextLine()){
//使用nextLine方式接收，以回车作为结束符
String str1=scanner.nextLine();
System.out.println(str1);
}
scanner.close();
println输出换行；print输出不换行
增强for for(int i:num){}
break用于强行退出循环；continue用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定
形式参数：用来定义作用的；实际参数：实际调用传递给他的参数
return 0；终止方法
值传递（JAVA）和引用传递
值传递：是指在调用函数时，将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，就不会影响到实际参数
public class Test01 {
public static void main(String[] args) {
int number = 10;
new Test01().change(number);
System.out.println(number);
}
public void change(int a){
a+=1;
}
}
引用传递：是指在调用函数时，将实际参数的地址传递到函数中，那么在函数中对参数进行修改，将会影响到实际参数
public class Test01 {
public static void main(String[] args) {
User user = new User("小明", 12);
new Test01().change(user);
System.out.println(user);//"小张"，12
}
public void change(User a){
a.setName("小张");
}
}
重载：
在同一个类中，参数列表不同
方法的名称必须相同
可变参数：
public void test(int j,int... i){
System.out.println(i[0]);
}
递归结构包括俩个部分：
递归头：什么时候不调用自身方法。如果没有头，将陷入死循环
递归体：什么时候需要调用自身方法。
数组是相同类型数据的有序集合。
int[] num;//声明一个数组um=new int[10];//创建一个数组
反转操作
for(int i=0,j=result.length-1;i<arrays.length;i++,j--){
result[j]=arrays[i];
}
冒泡排序
public class Demo {
public static void main(String[] args) {
int[] array={1,23,3,4,5,51,2,2,3,5};
int[] sort = sort(array);
System.out.println(Arrays.toString(sort));
}
public static int[] sort(int[] arr){
boolean flag=false;//使用flag来减少无意义的排序
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;
flag=true;
}
}
if(flag==false){
break;
}
}
return arr;
}
}
稀疏矩阵：当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。
记录数组一共有几行几列，有多少个不同值
把具有不同值的元素和行列及值记录在一个小规模的数组中。可 以缩小程序得规模。
面相对象编程
面向过程思想：
步骤清晰简单，第一步做什么，第二步做什么…
面向过程适合处理一些较为简单的问题
面向对象思想：
分类的思维模式，思考问题首先会解决问题需要哪些分类，然后 对这些分类进行单独思考。最后，才对某个分类下的细节进行面 向过程的思索。
面向对象适合处理复杂的问题。适合处理需要多人协作的问题
面向对象编程（Object-Oriented Programming，OOP）
面向编程的本质就是：以类的方式组织代码，以对象的形式封装数据。
抽象
三大特性：封装、继承、多态
封装的好处：提高程序得安全性，保护数据；隐藏代码的实现细 节；统一接口；系统可维护增加了。
静态方法是和类一起加载的，非静态方法在类实例化之后。
对象是具体的事物。类是抽象的，是对对象的抽象。类是对象的模板。
继承
构造器(构造方法)，是在进行创建对象的时候必须要调用的：
必须和类的名字相同
必须没有返回类型，也不能写void.
私有的东西无法被继承
子类的无参构造会调用父类的无参构造。
父类必须要有有参构造
super：
- super调用父类的构造方法，必须在构造方法的第一个
- super必须只能出现在子类的方法或构造方法中
- super和this不能同时调用构造方法
Vs this:
-
代表的对象不同：
this：本身调用者这个对象
super：代表父类对象的应用
-
前提
this：没有继承也可以使用
super：只能在继承条件才可以使用
-
构造方法：
this();本类的构造
super();父类的构造
重写：需要有继承关系，子类重写父类的方法
- 方法名必须相同
- 参数列表必须相同
- 修饰符：范围可以扩大但不能缩小 public>protected>default>private
- 抛出的异常：范围可以缩小，但不能扩大。ClassNotFoundException–>Exception
- 子类的方法和父类的必须要一致，方法体可以不同
为什么需要重写：父类的功能，子类不一定需要，或者不一定满足。Alt+Insert:override.
父类引用指向子类对象 Person s=new Student();
对象能执行哪些方法，主要看对象左边的类型，和右边关系不大。
静态方法：方法的调用只和左边定义的数据类型有关。
非静态方法：重写。子类重写了父类的方法，执行子类的方法
多态
多态：同一方法可以根据发送对象的不同而采用多种不同的行为方式。
- 多态是方法的多态，属性没有多态
- 父类和子类，转换必须要有联系
- 存在条件：继承关系，方法需要重写，父类引用指向子类对象。
- static方法，属于类，不属于实例
- final 常量，没有子类
- private方法
instanceof(类型转换) 引用类型，判断一个对象是什么类型，判断是否存在父子关系。
Object object=new Student();
System.out.println(object instanceof Student);
System.out.println(object instanceof Person);
类型转换
- 父类引用指向子类对象
- 把子类转换为父类，向上转型
- 把父类转换为子类，向下转型，强制转换
- 方便方法的调用，减少重复的代码
static：
public class Person{
{
System.out.println("匿名代码块");
}
// 只执行一次
static {
System.out.println("静态代码块");
}
public Person(){
System.out.println("构造方法");
}
}
先执行静态代码块，再执行匿名代码块，之后执行构造方法。静态代码块只执行一次。可以在匿名代码块赋初值。
抽象类（abstract）：
- 抽象类的所有的方法，继承了他的子类必须重写所有的方法，除非子类也是抽象类。
- 不能new这个抽象类，只能靠子类去实现
- 抽象类可以写普通方法，抽象方法必须在抽象类中
类是单继承，接口是多继承
接口
接口：只有规范。是约束。Interface
- 接口中的定义都是抽象的 public abstract，所有的常量 public static final
- 接口都需要有实现类。implement
- 实现了接口的类，需要重写接口中的方法
- 接口可以多继承
- 接口不能被实例化，接口中没有构造方法
内部类：
public class Outer{
private int id=10;
public void out(){
System.out.println("这是外部类的方法");
}
public class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
//获取外部类的私有属性
public void getID(){
System.out.println(id);
}
}
}
Outer outer=new Outer();
Outer.Inner inner=outer.new Inner();
inner.getID();
一个java类中可以有多个class类，但只能有一个public class
异常
检查性异常:
最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
运行时异常:
运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
错误︰
错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。
ctrl+alt+T快捷键生成try\catch代码