JavaSE基础

　　通过这几天的网络学习，对于老师们的耐心讲解与引导，对Java这门课程有了新的认识。

　　首先是三个学习：1.该技术是什么？　　2.该技术该如何使用？　　3.该技术的特点是什么？之后是三个编写：1.明确需求　　2.分析思路　　3.代码实现

　　以下便是最近几天的学习心得。

Java的三大版本

JAVASE:标准版（一般用于桌面程序，控制台开发...）

JAVAME:嵌入式开发（一般用于手机，小家电...）

JAVAEE:企业开发（web端，服务器开发...）

JDK：java开发者工具

JRE：java运行环境

JVM：java虚拟机

Dos命令

- ipconfig：查看ip信息
- dir ：查看当前目录所有信息
- cls ：清除屏幕
- exit：退出终端
- cd..：返回上一个级目录
- 打开应用：（calc：计算机）（ mspaint：画图）（notepad：记事本）
- ping命令：ping www.baidu.com
- 文件命令：md 目录名=创建目录
-  cd>文件名=创建文件
-  rd 目录名=删除目录
-  del 文件名=删除文件

标识符中的关键字

java所有组成的部分都需要名字，类名，变量名以及方法名都被成为标识符

标识符的构造规则：只能由字母数字和下划线组成，数字不能再第一个位置上，不能使用java的关键字

数据类型

1. 整数类型：int，long，byte，short

2. 浮点类型：double,f\'loat

3. 字符类型：char

4. boolean类型：只有true与false

拓展：（进制表达）

int a=10;//十进制
int b=010;//八进制：0
int c=0x10;//十六进制0x   A~F 10~15

（面试题）银行业务怎么表示？钱

答：银行业务使用的是BigDecimal 数学工具类表示，flat与double虽然也可以表示浮点数，但是它们的特点是：舍入误差，大约接近，但不等于。

拓展：（字符类型）

所有的字符本质都是数字，由Uincode编码，取值范围在：U0000~UFFFF.

类型转换

强制转换：（类型）变量名由高---到低

　　　　int a=120;

　　　　byte b=(byte)a;

自动转换：由低---到高

　　　　int a=120;

　　　　double b=a;

注：不能对boolean类型转换

　　不能把类型转换为不相干的类型

　　转换的过程中可能会出现内存溢出，精度误差问题

变量

类变量：在main方法体外，用static修饰

实例变量：在main方法体外，从属于对象，如果没给初始值，将自动设为默认值（0或者0.0或者null）

　　　　　　boolean默认值为：false

局部变量：在main方法体内，必须声明和初始化这个值

命名规范：

常量

关键字：final

final（类型）变量=值

运算符

逻辑运算：和（&&）或（||）非（取反）

位运算符：与（&） 或（|）异或运算（^）取反（~）左移（>>）右移（<<）

**面试题：2*8 怎么运算最快？**

答：使用二进制位运算，因为在计算机中所有的运算均需要二进制，所以采用二进制最快。将2右移3位(2<<3)，相当于2*3的平方计算结果。

字符串连接符：+

面试题：

　在以下案例中，输出结果有何不同？

int a=10;
int b=20;
System.out.println(""+a+b);
System.out.println(a+b+"");

答：+起到了拼接的作用，字符串在前，将会先于后面的a做拼接，在做计算。字符串在后，将会先计算前面a+b的值，再去做拼接。

三元运算符：？：

例：int a=60;

　　String arr=a<60?"成绩不及格":"成绩及格";

Scanner的定义与使用

Scanner：相当于键盘扫描仪，可以将用户输入的内容扫描，并打印在控制台

Scanner scanner = new Scanner：创建一个变量名为scanner的扫描仪

String arr = scanner.next（）;空格之前的所有字符

String arr2 =scanner.nextInt();回车之前的所有字符

注：输入输入为IO流特点：使用完资源以后一定要释放资源。变量名.close;释放资源

if语句判断

if语句+if嵌套：if(判断语句){

　　　　}else if(判断语句){

　　　　}else{

　　　　}

switch多选择结构

switch语句：switch（匹配一个具体的值）{

　　　　　　case 变量：

　　　　　　　　break;

　　　　　　case 变量:

　　　　　　　　break;

　　　　　　default:

}　　

循环

　　while循环：只要循环表达式为布尔类型，且为true，则无限循环。条件不满足无法进入循环（先执行后判断）

　　do while循环：至少执行一次。（先判断后执行）

　　for循环：for循环语句是支持迭代的一种通用结构，是最灵活最有效的循环结构。

　　增强for：for（声明语句：表达式）{代码句子} 主要用于数组与集合遍历。

九九乘法表：

public class JJfor {
    public static void main(String[] args) {
        for (int j = 0; j <= 9; j++) {
            for (int i = 1; i <=j; i++) {
                System.out.print(j+"*"+i+"="+i+"\t");
            }
            System.out.println();
        }
    }
}
分析：
1.先打印第一列for（int i=1;i<=9;i++）
2.把固定的1，再用循环包裹起来
3.去掉重复项：i<=j
4.调整样式

JAVA方法

java方法：1.是语句的集合，他们在一起执行一个功能。

　　　　　2.再程序中创建，在其他地方引用。

　　　　　3.一个方法只做一个功能！

如果返回值是类型参数，需要return返回值

方法的调用：1.如果这个方法返回的是一个值，那么这个方法一般当作一个值使用。

　　　　　　2.如果这个方法返回的是一个void，那么这个方法一定是条语句。

方法重载规则：1.方法名必须相同

　　　　　　　　2.参数列表必须不同

递归

递归：指的就是自己调用自己方法，它可以用简单的程序来解决复杂的问题，大大减少程序的代码量。

　　　　递归的结构包含了：1.递归头：什么时候不调用自己方法（如果没有头，将陷入死循环）

　　　　　　　　　　　　　　2.递归体：什么时候调用自己方法

数组

数组：是一个相同类型数据的有序集合，有一定的先后顺序，每一个数据，称为数组的元素，每个数组元素可通过一个下标来访问它们。

　　　数组变量属于引用类型，在使用的时候用.（点）给引用出来。

静态数组：静态初始化 = 创建 + 赋值

　例：　　　　int[] arr = new {1,2,3}　　//直接赋值

　　　　　　　　arr [0];

　　　　　　　　arr [1];

动态数组：

例：　　　　int[] arr = new[10];　　//手动赋值

　　　　　　　　arr [0] = 1;

　　　　　　　　arr [1] = 2;

java内存

堆：存放new出来的对象和数组

栈：存放基本变量类型

方法区：可以被所有的线程共享

冒泡排序

这个算法的时间复杂度为：O（n2）：n的2次方

代码为：

import java.util.Arrays;

public class Q4 {
    public static void main(String[] args) {
        int[] arr={3,432,65,4,54,5,63};
        System.out.println(Arrays.toString(tp(arr)));//调用并打印数组
    }
//下面是编写的方法体
    public static int[] tp(int[]arr){
        int p=0;//声明一个第三方的变量，并且初始化
        for (int i = 0; i < arr.length-1; i++) {//第一层循环数组
            for (int j = 0; j < arr.length-1-i; j++) {//第二层比较大小
                if (arr[j+1]<arr[j]){//如果后一个的值比前面的大
                    p=arr[j];//首先把前一个值给第三方
                    arr[j]=arr[j+1];//再把后一个的值给前一个
                    arr[j+1]=p;最后把第三方的值给后一个，实现两者数组的交替
                }
            }
        }
        return arr;
    }
}

优化代码：加入Boolean判断

import java.util.Arrays;

public class Q4 {
    public static void main(String[] args) {
        int[] arr={3,432,65,4,54,5,63};
        System.out.println(Arrays.toString(tp(arr)));
    }
    public static int[] tp(int[]arr){
        int p=0;
        boolean flag=false;
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j+1]<arr[j]){
                    p=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=p;
                    flag=true;
                }
            }
            if (flag==false){
                break;
            }
        }
        return arr;
    }
}

面向对象编程

本质就是以类的方式组织代码，以对象的组织（封装）数据

三大特性：1.封装 2.继承 3.多态

创建与初始化对象

使用new关键字创建对象，会默认初始化值，还会调用类中的构造方法

类中的构造器又称构造方法，在创建对象的时候是必须要调用的，构造方法有两个特点，1.必须和类的名字相同，2.必须没有返回类型，也不能使用void

无参构造默认就有，一旦定义了有参构造，无参就不存在。想要使用必须重新生成。

一旦定义有参构造以后，还想要使用无参构造，就必须再定义一个无参构造。

this. 代表这个类，必须放在第一行

类是一个模板，类是抽象的

对象是一个具体的实例

引用类型：对象是通过引用来操作的，说白了就是指向对象的一个地址

高内聚：类的内部数据由自己完成，不允许外部干涉。

低耦合：仅暴漏少量的方法给外部使用。

封装：1.提高程序的安全性 2.隐藏代码的实现细节 3.统一接口 4.增加程序的可维护性

GET：获取 SET：设置

继承：extends

super：调用父类构造方法，必须放在第一行,只能出现再字类方法中，并且与this只能有一个调用。

面试题

super与this的区别：

1.前提不同：super必须在有继承的情况下才可以使用。

　　　　　　this 再没有继承的情况下也可以使用。

2.代表的对象不同：super代表的是父类的对象引用。

　　　　　　　　　　this代表的是本身调用者这个对象。

3.构造方法不同：super是父类构造。

　　　　　　　　this是本类构造。

重写（override）：父类的功能，字类不一定需要，或者不一定满足

　　 1.需要有继承关系，字类重新父类的方法

　　　2.方法名必须相同

　　　3.修饰符：范围可以扩大，不能缩小：public>protected>Default>private

　　　4.抛出的异常：范围可以缩小，不能扩大：ClassNotFoundException------>Exception（大）。

总结：重写，字类的方法与父类的方法必须一致，方法体不同！

如果方法是（static：静态　　finl：常量　　private：私有）是无法重新方法的

多态

1.多态是方法的多态，属性是没有多态的

instanceof：类型转换（自动转换/强制转换）--->引用类型

2.存在的条件：有继承关系，并且方法重新，父项指向字类对象

abstract 抽象类

抽象方法只有方法名，没有方法的实现。

例：

不能new这个抽象类，只能靠字类去实现它，就是一个约束

抽象的抽象就是约束

接口（interface）

接口就是规范：定义的是一组规则，比如：你是什么...就必须...的思想！

　　　　　　接口的本质就是契约，定义好了以后大家都去遵守它

利用接口可以实现多继承

作用：1.约束　　2.定义一些方法让不通过的人实现　　3.隐藏的public static final 常量　　4.隐藏的public abstract 抽象的　　5.接口不能被实例化，接口中没有构造方法　　7.必须重新接口

内部类

内部类：就是再一个类里面再定义一个新的类，比如再A类里面定义一个B类，那么B类就是A的内部类

内部类分为：1.成员内部类：再一个类里面再写进另外一个calss就是内部类

　　　　　　2.静态内部类：加上static就是一个静态的内部类　

　　　　　　3.局部内部类：再方法里写入另一个class就是局部内部类　　

　　　　　　4.匿名内部类：没有名字的初始化类，不将实例保存到变量中

异常：（Error / Exception）

Throwable:最高异常--->包含了Error异常与Exception异常

Error：通常是灾难性的致命错误。是程序无法处理和处理的，当出现这种异常时，java虚拟机（JVM）就会终止线程。

Exception：一般情况下是可以被程序处理，应尽可能的再程序中处理这些异常。　

Error异常报错：　Virtual MachineError：java虚拟机运行错误

　　　　　　　　　OutOfMemoryError：JVM不在执行所需的内存资源时　　

Exception异常报错：RuntimeException：运行时异常

　　　　　　　　　　ArraylndexOutOfBoundsException：数组下标越界

　　　　　　　　　　NullpointerException：空指针异常

　　　　　　　　　　ArithmeticException：算术异常

　　　　　　　　　　MissingResourceException：丢失资源

　　　　　　　　　　ClassNotFoundException：找不到类

异常处理机制

快捷键：选择可能出现异常的语句 ctrl+alt+T 自动捕获异常

抛出异常：

案例1：在方法内抛出异常

    public static void main(String[] args) {
    }
    public void arr(int a,int b) throws ArithmeticException{　　//throws 在方法上抛出异常（如果throw解决不了就用throws）
        if (b==0){
            throw new ArithmeticException();　　//throw 在方法内抛出异常
        }
    }
}

捕获异常：捕获多个异常，要从小到大。

案例：

    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        try {
            System.out.println("执行语句a/b"+a/b);
        }catch (Throwable i){
            System.out.println("程序捕获到异常，执行该语句");
        }finally {
            System.out.println("无论有没有异常，我都会执行");
        }
    }
}

关键字：try　　catch　　finally　　throw 　　throws