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：

1. super调用父类的构造方法，必须在构造方法的第一个
2. super必须只能出现在子类的方法或构造方法中
3. super和this不能同时调用构造方法

Vs this:

1. 代表的对象不同：

   ​ this：本身调用者这个对象

   ​ super：代表父类对象的应用

2. 前提

   ​ this：没有继承也可以使用

   ​ super：只能在继承条件才可以使用

3. 构造方法：

   ​ this();本类的构造

   ​ super();父类的构造

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

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大但不能缩小 public>protected>default>private
4. 抛出的异常：范围可以缩小，但不能扩大。ClassNotFoundException–>Exception
5. 子类的方法和父类的必须要一致，方法体可以不同

为什么需要重写：父类的功能，子类不一定需要，或者不一定满足。Alt+Insert:override.

父类引用指向子类对象 Person s=new Student();

对象能执行哪些方法，主要看对象左边的类型，和右边关系不大。

静态方法：方法的调用只和左边定义的数据类型有关。

非静态方法：重写。子类重写了父类的方法，执行子类的方法

多态

多态：同一方法可以根据发送对象的不同而采用多种不同的行为方式。

1. 多态是方法的多态，属性没有多态
2. 父类和子类，转换必须要有联系
3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象。
   1. static方法，属于类，不属于实例
   2. final 常量，没有子类
   3. private方法

instanceof(类型转换) 引用类型，判断一个对象是什么类型，判断是否存在父子关系。

Object object=new Student();
System.out.println(object instanceof Student);
System.out.println(object instanceof Person);

类型转换

1. 父类引用指向子类对象
2. 把子类转换为父类，向上转型
3. 把父类转换为子类，向下转型，强制转换
4. 方便方法的调用，减少重复的代码

static：

public class Person{
    {
        System.out.println("匿名代码块");
    }
    // 只执行一次
    static {
        System.out.println("静态代码块");
    }
    public Person(){
        System.out.println("构造方法");
	}
}

先执行静态代码块，再执行匿名代码块，之后执行构造方法。静态代码块只执行一次。可以在匿名代码块赋初值。

抽象类（abstract）：

1. 抽象类的所有的方法，继承了他的子类必须重写所有的方法，除非子类也是抽象类。
2. 不能new这个抽象类，只能靠子类去实现
3. 抽象类可以写普通方法，抽象方法必须在抽象类中

类是单继承，接口是多继承

接口

接口：只有规范。是约束。Interface

1. 接口中的定义都是抽象的 public abstract，所有的常量 public static final
2. 接口都需要有实现类。implement
3. 实现了接口的类，需要重写接口中的方法
4. 接口可以多继承
5. 接口不能被实例化，接口中没有构造方法

内部类：

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代码