JAVA 基础自写01

注释

单行注释：//

多行注释：/* */

文本注释：/** */

标识符

标识符可以为字母（a-Z）美元符号($)或者下划线（_）开始

首字母之后可以是任何的字母美元符号下划线或者数字

不能使用关键字作为变量或者方法

标识符大小写很敏感

关键字

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

数据类型

java数据类型分为两大类：

基本类型（primitive type）：

​ 数值型：

​ 整数型：byte 1字节-128~127

​ short 2字节

​ int 四个字节

​ long 八个字节（定义之后会加一个L区分）

​ 浮点类型：

​ float 四字节

​ double 八个字节

​ 字符类型： char 占两个字节

​ boolean 值只有false 或者true （代表是非）

​

应用类型（reference type）：

类，接口，数组（除了基本类型以外都是引用类型）

字节

1bit 一位

1byte 表示一个字节 1byte=8bit

1024byte=1KB

1024KB=1M

1024M=1G

1024G=1TB

进制

二进制：0b

八进制：0

十六进制：0x

转义字符：

\t 制表符

\n 换行

\u 转十六进制

new关键字

类型转换

强制转换：（类型）需要转换的变量或者变量名

强制类型转换：

​ 低到高

​ byte char bool short int long double float

自动类型转换

​ 高到低

变量

变量是可以改变的量

语法：

​ 数据类型 变量名=值；

数据类型 变量名=值，变量名=值，…；

可以同时定义多个同一类型的变量，但是不推荐。

变量定义必须以分号结尾；

变量类型可以是值类型，也可以是引用类型

变量作用域

类变量

​ 在类内部定义的变量也可以称为属性

static 变量类型 变量名=变量值；

static静态的使用方法：类名.变量名;

实例变量

​ 在方法的外面和类的里面

​ 使用方法需要实例化该实例变量存在的类，语法： 实例化类名.实例变量名=实例变量值；（如果没有给值，基本类型默认是无限接近于零的值，bool默认值是false，引用类型值为null）

局部变量

​ 在方法之内或者大括号之内定义

​ 在定义开始到定义大括号结尾有作用，必须要声明并且初始化值；

常量

final 常量名=常量值；

注意常量定义就无法改变；

常量使用大写字母命名；

变量的命名规范

类成员变量：首字母小写，其他首字母大写（驼峰命名）

局部变量：首字母小写和符合驼峰原则

常量：字母全部大写，可以用_连接单词

类名：首字母大写驼峰命名规则

方法名：首字母小写并符合驼峰原则

运算符

算数运算符： + - * / % ++ –

赋值运算符：=

关系运算符：> < >= <= == !=

逻辑运算符：&& || !( 与或非)

扩展赋值运算符：+= -= *= /=

JavaDoc文档

命令：javadoc -encoding UTF-8 -charset UTF-8 文件名.java

JavaDoc：文档

encoding UTF-8 -charset UTF-8 ：把字符设置为utf-8的格式

与用户交互

scanner类：

语法：

Scanner s=new Scanner（System.in）；//声明一个scanner类

s.hasNext();//判断用户是否输入字符串，返回值为boolean类型

string inputs=s.next（）；获取用户输入的字符串（回车结束输入，如果输入空格在空格之后的文本则不会被next（）接收）

string input2=s.nextLine();//获取用户输入的一行字符串，不会被空格打断接收

int sum=s.nextInt();获取用户输入的整数类型

注意：scanner属于重类型，为了性能更高每次使用结束需要关闭，语法：

Scanner变量名.close（）；

s.close()；

顺序结构

Java的基本结构就是顺序结构，就是一句一句的从上往下执行；

选择结构

• if（判断条件）{方法体1；}else{方法体2；}

含义：如果判断条件返回值为true则执行方法体1，如果判断条件为false则执行方法体2；else不是必须的；

• if（判断条件1）{方法体1；}

else if（判断条件2）{方法体2；

}else if（判断条件n）{
方法体n；}

else{方法体；}

含义：当判断条件为true则执行方法体，如果所有的判断条件都为false则执行else方法体；在if语句之内可以嵌套if语句；

• switch（将要判断的变量）{
  case 值1:方法体1；
  break；
  case 值2：方法体2；

​ break；

​ case n；方法体n；

​ break；

​ default：方法体；}

含义：如果判断的变量的值等于case后边的值，则执行case对应的代码，注意：break是跳出当前判断；如果方法体1和方法体2的方法体一样，可以省略方法体1和方法体1的break语句；

循环结构

while循环：

while（循环条件）{

循环体；

}

含义：判断循环条件如果为真（true）则进入循环体；之后在进行循环条件判断；循环体内要有一个循环终止条件，

do …while循环

do{

循环体；

}while（循环条件）

含义：不论什么条件都会执行循环体一次，之后在进入while的循环条件判断，返回为真（true）则在执行循环体，循环体要有循环终止条件；

break，continue

break终止循环

continue终止循环并继续下一次循环

方法

方法是完成某些工作的就是方法

方法是解决一类问题的步骤的有序聚合

方法包含于类或者对象中

方法的命名规范

方法首字母小写，并符合驼峰命名。

修饰符 返回值类型 方法名（参数类型 参数列表）{

方法体；

return 返回值；

}

返回值类型要一致，方法不一定要有参数列表或者返回值（void)就是无返回值

static 修饰的静态方法可以直接调用方法，普通方法需要实例化对象之后用对象名.方法名使用。

方法重载

方法名相同方法的参数类型不同，方法的参数个数不同

可变参数

在方法中可以定义可变长参数

​ 1.可变长参数在类型的前面加…

​ 2.一个方法中只能有一个可变长参数

​ 3.可变长参数必须要在方法参数的末尾

例子：

public static void test(int… n1){

for(int i=0;i<n1.length;i++)

{System.out.println(n1[i]);}

}

实例化：

tese(10,20,30);//输出

10

20

30

方法的递归

递归就是方法自己调用自己，注意需要有结束方式

public static int fun(int num) {
    int nums=1;
    if (num > 0) {
        nums = num * fun(--num);//1
    }
    return nums;
}

public static void main(String[] args) throws Exception {
    int nums = fun(3);
    System.out.println(nums);
}

该方法就是自己调用自己，一定要有判断退出条件，不然会死循环，当方法进入语句1他就会先判断num是不是小于零，在执行，执行知道给出了第一个结果，他会把之前执行的语句在执行一边，进行挨个赋值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uL0tUp1d-1647587897786)(C:\Us在这里插入图片描述
ers\Administrator\Ap
pData\Roaming\Typora\typora-user-images\image-20220317201631800.png)]

数组

数据类型[] 变量名=new 数据类型[长度]；

数组是一个空间确定（可存数据长度确定）的一堆同一类型的数据的集合

数组的存和取都是有序的

数组的存入当超过他的最大的长度是，数据就不会再存入

实例：

//定义一个整数数组，并给定十个长度
int[] nums = new int[10];
//给数组的第一个元素赋值为0
nums[0] = 0;
//把数组的第一个元素的值改变
nums[0] = 5;
for (int j = 1; j < nums.length; j++) {
    nums[j] = j;
}//给集合赋值
for (int num : nums) {
    System.out.println(nums[num]);
}//遍历数组

多维数组

数据类型[] [] 变量名=new 数据类型[] []

多维数组就是由多个数组组成的数组的数组

示例：

int[][] list = new int[3][2];
//第三个数组的第一个元素的值为5；
list[2][0] = 5;
for (int i = 0; i < list.length; i++) {
    for (int j = 0; j < list[i].length; j++) {
        list[i][j] = i * 10 + j;
    }//向数组中添加元素
}
for (int i = 0; i < list.length; i++) {
    for (int j = 0; j < list[i].length; j++) {
        System.out.print(list[i][j]);
    }
    System.out.println();
}//输出数组元素

Arrays类

//对数组元素排序
Arrays.sort(list);
//二分查找返回被查找到的下标查询失败返回负数，查询数组要有序
Arrays.binarySearch(list, 3);
//把数组的第一个穿入的下标到第二个下标-1之间的值更改，不包括第二个下标
Arrays.fill(list, 1, 3, 5);
//对两个数组进行比较
boolean b = Arrays.equals(list, list);

冒泡排序

冒泡排序就是那一个元素和每个元素进行比较，如果第一个数比第二个数大（小）则把第一个数和第二个数更换位置，否则继续比较。

示例：

int[] list = {15, 16, 8, 5, 484, 522, 17, 143};
for (int i = 0; i < list.length; i++) {
    for (int j = i; j < list.length; j++) {
        if (list[i] > list[j]) {
            list[i] = list[i] + list[j];
            list[j] = list[i] - list[j];
            list[i] = list[i] - list[j];
        }
    }

}

面向对象

面向对象的本质就是以类的方式组织代码

定义一个类，给这个类实例化就是给这个类添加一个实例化的对象

1.声明一个类，该类中会有默认的构造方法

2.使用new 关键字给这个类实例化赋值给一个真实存在的变量。（new给类强制开辟了一个空间，并赋值）

封装

属性私有，get/set

属性私有就是用private修饰属性，需要给属性设置中转方法set（设置）get（返回）

意义：外部不能直接设置属性，需要用set方法操作属性，可以对set或者get的值进行判断

自动生成get/set：alt/insert

继承

语法：

public class 子类 extends 父类

{

}

1.子类会继承父类中的所有的protedected和publi和默认的修饰符修饰的属性和方法（但不包含构造方法）

2.子类可以重写父类的方法

3.子类在创建对象的时候会默认的执行父类的静态代码块和父类的无参构造

4.子类不能重写父类的静态方法（static）

5.子类只能有一个父类，父类可以有多个子类

示例：父类

import lombok.Data;

/**
 * @author Administrator
 */
@Data

public class Father {
    private String name;
    private Integer age;

    static {
        System.out.println("静态代码块");
    }

    {
        System.out.println("代码块");
    }

    public void fun() {
        System.out.println("父类对象");
    }

    public Father() {
        System.out.println("父类默认");
    }

    public Father(String name, Integer age) {
        this.name = name;
        this.age = age;
        System.out.println("父类有参");
    }
}

子类：

public class Son extends Father {


    public static void main(String[] args) {
        Son s = new Son();
        s.setAge(15);
        //调用父类的set方法
        s.setName("456");
        s.fun();
        System.out.println(s);
    }
}

多态

实例化子类对象可以赋值给父类对象；
父类 对象名=new 子类对象（）；

抽象

abstract修饰的类或者方法是抽象的方法

abstract修饰的类是抽象类不能直接实例化（new)抽象的方法是没有方法体的

子类继承抽象的父类需要继承父类所有的抽象方法

抽象类中可以有普通方法，但是普通类中不可以有抽象方法

public abstract void fun();//抽象方法

接口

interface 修饰的类是接口，接口不能直接实例化，接口中可以有常量属性，静态方法，默认方法，抽象方法，一个类可以有多个接口

implements用于实现接口

/**
 * 接口
 * @author Administrator
 */
public interface Persons {
   public static final String name="123";
	
    Integer age=20;
    
    /**
     * 抽象方法
     */
    public abstract void fun();

    /**
    *默认的添加public abstract
    */
    void fun2();
    /**
     * 抽象的
     */
    public static void fun1(){
        System.out.println("静态方法");
    }

    /**
     * 默认
     */
    public default void fun2(){
        System.out.println("默认的方法");
    }

    /**
     * 静态的
     */
    private static  void fun3(){
        System.out.println("静态的");
    }
}

内部类

注意：一个类中可以有外部类，静态内部类，局部内部类，匿名内部类，但是只能有和当前class文件名一样的类使用public修饰符。

外部类

在类外面定义的类
class 类名{
}

静态内部类

在类中定义的类
static class 类名{
}

成员内部类

在方法的内部创建的方法

class 类名{

}

一般会在外部类中定义一个方法返回值为内部类

匿名内部类

实例化类，但是不会保存直接使用

new 类名.方法（）；

不用接收，只能用单次；

异常

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

处理机制

抛出异常，捕获异常

try{

​ 监控区域；

}catch（异常类型）{

出现该异常处理方式；

catch可以有多个，对应多种的异常的多种的处理方式；

}

finally{

不是必须存在的语句；

在finally中的语句是一定会执行的；

}

关键字

try：监控区域，如果出现异常执行catch代码块

catch捕获异常：对代码快出现的异常的处理

finally：无论程序有没有异常都会执行的代码快

throw：在方法中抛出异常

throws：在方法上抛出异常的类型

自定义异常

自定义异常需要继承exception类

**
* 静态的
*/
private static void fun3(){
System.out.println(“静态的”);
}
}

## 内部类

### 成员内部类

在类的内部创建的方法

class 类名{

}

一般会在外部类中定义一个方法返回值为内部类

### 匿名内部类

实例化类，但是不会保存直接使用

new 类名.方法（）；

不用接收，只能用单次；

### 局部内部类

在类的内部的方法中声明的类

## 异常

[外链图片转存中...(img-xITNXvhB-1647587897787)]

### 处理机制

抛出异常，捕获异常

try{

​	监控区域；

}catch（异常类型）{

出现该异常处理方式；

catch可以有多个，对应多种的异常的多种的处理方式；

}

finally{

不是必须存在的语句；

在finally中的语句是一定会执行的；

}

关键字

try：监控区域，如果出现异常执行catch代码块 

catch捕获异常：对代码快出现的异常的处理 

finally：无论程序有没有异常都会执行的代码快

 throw：在方法中抛出异常

 throws：在方法上抛出异常的类型



## 自定义异常

自定义异常需要继承exception类

![在这里插入图![在这里插入图片描述](https://img-blog.csdnimg.cn/f826dcc16e4340d48b36bcd0c10ac001.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAY19jaHV4dWV6aGVf,size_12,color_FFFFFF,t_70,g_se,x_16#pic_center)



## 单例设计模式

### 饿汉式

1.需要有一个私有静态的返回实体类属性

2.构造方法私有化

3.声明一个静态的方法返回值为当前类对象，对其判断私有属性是否有值，如果有值则返回，无值则new创建实例化对象

```java
public class App {
    private static App app;//需要有一个私有静态的返回实体类属性
    private  App(){
        //构造方法私有化
    }
    public static App newApp(){
        if(app==null){
            app=new App();
        }
        return app;
    }
    public static void main( String[] args){
        App app = App.newApp();
        App app1 = App.newApp();
        System.out.println(app==app1);
    }

}

懒汉式

1.声明一个私有的静态的属性赋值为当前类对象，

2.构造方法私有化

3.声明一个静态的方法返回值为私有的属性

public class App {
    private static App app=new App();
    private  App(){
        //构造方法私有化
    }
    public static App newApp(){
      
        return app;
    }
    public static void main( String[] args){
        App app = App.newApp();
        App app1 = App.newApp();
        System.out.println(app==app1);
    }

}

如果有错误的请指出，初学者，请多多指教