JAVA基础学习大全（笔记）_java学习笔记word-程序员宅基地

JAVASE和JAVAEE的区别

JDK的安装路径

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

卸载和安装JDK

在这里插入图片描述

第一个hello，word程序

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

Ctrl 加insert复制

shift加insert粘贴

public class hello{
    
	public static void main(String[] args){
    
		System.out.print("Hello,World!");
	}
}

JAVA的运行机制

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

标识符注意点

所有的标识符都应该以字母(A-Z 或者a-z) ,美元符($)、或者下划线( )开始
首字符之后可以是字母(A-Z 或者a-z) ,美元符($) 、下划线(或数字的任何字符组合
不能使用关键字作为变量名或方法名。
标识符是大小写敏感的
可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音,很Low

什么是字节

位(bit) :是计算机内部数据储存的最小单位，11001100是一个八位二进制数。
字节(byte) :是计算机中数据处理的基本单位，习惯上用大写B来表示,
1B (byte,字节) = 8bit (位)
字符:是指计算机中使用的字母、数字、字和符号

数据类型

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

boolean不能进行数据转换其他数据类型为字节单位，boolean是以位为单位

浮点数拓展

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

银行中的应用

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

类型转换

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

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

低-------------------------------> 高 byte, short,char-> int -> long-> float -> double

String不是基本的数据类型

变量和常量

变量

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

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

变量的命名规范

所有变量、方法、类名：见名知义
类成员变量:首字母小写和驼峰原则: monthSalary
局部变量:首字母小写和驼峰原则
常量:大写字母和下划线: MAX_ VALUE
类名:首字母大写和驼峰原则: Man, GoodMan
方法名:首字母小写和驼峰原则: run(), runRun()

位运算

位运算符<<、>>效率极快

字符串连接符+

System . out .println("" +a+b);//""先和a拼接，在和b拼接，a+b不进行算术运算
System . out. println(a+b+"");//a+b先进行算术运算，在和""拼接

包机制

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。
包语句的语法格式为:
```
package pkg1[. pkg2[. pk...]];
```
一般利用公司域名倒置作为包名;com.wdl.base
为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用"import"语句可完成此功能
```
import package1[. package..].(classname |*);
```

Java Doc生成自己的帮助文档

javadoc命令是用来生成自己API文档的
参数信息
- @author作者名
- @version 版本号
- @since 指明需要最早使用的jdk版本
- @param参数名
- @return 返回值情况
- @throws 异常抛出情况
用IDEA构建javadoc

https://www.cnblogs.com/noKing/p/8006298.html

用户交互Scanner(获取用户的输入)

next()和hasNext()

public class Demo02_Scanner {
    
    public static void main(String[] args) {
    
        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用next方式接收: ");
        //判断用户有没有输入字符串
        if (scanner.hasNext()){
    
            //使用next方式接收
            String str = scanner.next();//程序会等待输入内容，不输入会卡在这里
            System.out.println("输出的内容为: "+str);
        }
        //凡是属于IO流的类如果不关闭会一直占用资源.要养成好习惯用完就关掉
        scanner.close();
    }
}

nextLine()和hasNextLine()

public class Demo02_Scanner {
    
    public static void main(String[] args) {
    
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用nextLine方式接收: ");
        //判断是否还有输入
        if (scanner.hasNextLine()) {
    
            String str = scanner.nextLine();
            System.out.println("输出的内容为: " + str);
        }
        scanner.close();
    }
}

next()和nextline()的区别

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

switch语句

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

do-while(注意while后面的分号)

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

break和continue的区别

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

三角形的打印

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

方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数。
方法的重载的规则:
- 方法名称必须相同。
- 参数列表必须不同(个数不同、或类型不同、参数排列顺序不同等)。(必须满足)
- 方法的返回类型可以相同也可以不相同。
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AhDtFw7k-1608641067123)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222150754110.png)]
- 仅仅返回类型不同不足以成为方法的重载。
实现理论:

方法名称相同时,编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

命令行传参

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

可变参数(本质是数组)

JDK 1.5开始，Java支持传递同类型的可变参数（不定项）给一个方法。
在方法声明中，在指定参数类型后加一个省略号(…)。
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

public class Demo08 {
    
    public static void main(String args[]) {
    
        //调用可变参数的方法
        printMax(15,22.0,36,25.3);
        printMax(new double[]{
    1, 2, 3});//本质为数组

    }
    public static void printMax(double... numbers) {
    
        if (numbers.length == 0) {
    
            System.out.println("No argument passed");
            return;
        }
        double result = numbers[0];
        //排序!
        for (int i = 1; i < numbers.length; i++) {
    
            if (numbers[i] > result) {
    
                result = numbers[i];
            }
        }
        System.out.println("The max value is " + result);
    }
}

递归的原理

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

简易计算器

package com.kuang.scanner;
import java.util.Scanner;
public class hello {
    
    public static void main(String[] args) {
    
        Scanner s = new Scanner(System.in);
        System.out.print("请输入第一个数字：");
        int num1 = s.nextInt();
        System.out.print("请输入运算符：");
        String operator = s.next();
        System.out.print("请输入第二个数字：");
        int num2 = s.nextInt();
        int result = 0;
        switch (operator) {
    
            case "+":
                result = num1 + num2;
                break;
            case "-":
                result = num1 - num2;
                break;
            case "*":
                result = num1 * num2;
                break;
            case "/":
                result = num1 / num2;
                break;
            case "%":
                result = num1 % num2;
                break;
            default:
                System.out.println("你的输入不合法！！！");
        }
        System.out.println(num1 + operator + num2 + "=" + result);
    }
}

数组

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法:

dataType[] arrayRefVar; // 首选的方法
或
dataType arrayRefVar[]; // 效果相同，但不是首选方法

Java语言使用new操作符来创建数组，语法如下:(前后数据类型必须一致)
```
dataType[] arrayRefVar = new dataType[arraySize] ;
```
数组的元素是通过索引访问的,数组索引从0开始。

二维数组的输出

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

内存分析—三种初始化

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8pA8ijqW-1608641067127)(D:\image-20201222155715184.png)]

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

冒泡排序(小升级)

package com.kuang.scanner;
import java.util.Arrays;
public class hello {
    
    public static void main(String[] args) {
    
        int[] a = {
    1, 4, 5, 6, 72, 2, 2, 2, 25, 6, 7};
        int[] sort = sort(a); //调用完我们自己写的排序方法以后，返回一个排序后的数组
        System.out.println(Arrays.toString(sort));
    }
    public static int[] sort(int[] array) {
    
        //临时变量
        int temp = 0;
        //外层循环，判断我们这个要走多少次;
        for (int i = 0; i < array.length - 1; i++) {
    
            Boolean flag = false;
            //内层循环，比价判断两个数，如果第一个数，比第二个数大,则交换位置(相邻两个数之间的比较)
            for (int j = 0; j < array.length - 1 - i; j++) {
    
                if (array[j + 1] > array[j]) {
    
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    flag = true;
                }
            }
            if (flag == false){
    
                break;
            }
        }
        return array;
    }
}

稀疏数组(数组压缩)

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

package com.kuang.scanner;

public class hello {
    
    public static void main(String[] args) {
    
        //创建一个元素的二维数组 11*11  0：没有棋子 1： 黑棋   2： 白棋
        int chessArry1[][] = new int[11][11];
        chessArry1[1][2] = 1;
        chessArry1[2][3] = 2;
        for (int [] row : chessArry1) {
    
            for ( int data : row) {
    
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }
        int[][] paraseArr =  transformSparseArr(chessArry1);
        transformArry(paraseArr);
    }
    //二维数组 转 稀疏数组
    public static int[][] transformSparseArr( int[][] arry) {
    
        int sum =0;  // 有效值的个数
        int rowSize = 0;
        //1、计算出有效的个数
        for (int[] row :arry) {
    
            for ( int data :row) {
    
                rowSize = row.length;
                if (data != 0) {
    
                    sum++;
                }
            }
        }
        //创建稀疏数组 并给稀疏数组赋值
        int [][] sparseArr= new int[sum+1][3];
        sparseArr [0][0] = arry.length;
        sparseArr [0][1] = rowSize;
        sparseArr [0][2] = sum;
        //count 计数器 计算放入的有效个数 即第几个非零数据
        int count = 0;
        for (int i = 0; i < arry.length; i++) {
    
            for (int j = 0; j < rowSize ; j++) {
    
                if (arry[i][j] != 0) {
    
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = arry[i][j];
                }
            }
        }
        // 输出稀疏数组形式
        System.out.println("===========稀疏数组============");
        for (int i = 0; i < sparseArr.length; i++) {
    
            // %d 占位符 \t 制表符  \n 换行
            System.out.printf("%d\t%d\t%d\t\n", sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
        }
        System.out.println();
        return sparseArr;
    }
    // 稀疏数组 转化为 二维数组
    public static int[][] transformArry(int[][] parseArr) {
    
        int row = parseArr[0][0]; //得到行
        int col = parseArr[0][1]; //得到列
        //数组恢复 并赋值
        int[][] arry = new int[row][col];
        for (int i = 1 ; i < parseArr.length; i++) {
    
            arry[parseArr[i][0]][parseArr[i][1]] = parseArr[i][2];
        }
        // 输出
        System.out.println("============二维数组恢复==============");
        for (int [] rows: arry) {
    
            for (int data : rows) {
    
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }
        return arry;
    }
}

面向对象

面向对象编程的本质就是:以类的方式组织代码，以对象的组织(封装)数据

三大特性:

封装
继承
多态

方法调用

静态方法

可以通过类直接调用，在类加载时加载，不能调用非静态方法

public class Demo01Static {
    
    public static void main(String[] args) {
    
        Student.say();
    }
}

public class Student {
    
    public static void say(){
    
        System.out.println("学生说话了");
    }
}

非静态方法

通过实例化对象调用

public class Demo01Static {
    
    public static void main(String[] args) {
    
        Student student = new Student();
        student.say();
    }
}

public class Student {
    
    public void say(){
    
        System.out.println("学生说话了");
    }
}

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

自动生成返回值

按快捷键ctrl+alt+v

构造器

类中的构造器也称为构造方法,是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:
- 必须和类的名字相同
- 必须没有返回类型,也不能写void

构造器必须要掌握

public class Person {
      
    //一个类即使什么都不写，它也会存在个方法
    //显示的定义构造器
    String name ;
    int age;
    //alt+ insert 可以快捷生成构造器
    //1.使new关键字， 本质是在调用构造器
    //2.用例初始化值
    public Person(){
       }
    //有参构造:一旦定义 了有参构造。无参就必须显示定义，否则调用无参构造器时程序会报错
    public Person(String name){
      
        this.name = name ;
    }
    public Person(String name, int age) {
      
        this. name = name;
        this.age = age;
    }
}

构造器:
- 和类名相同
- 没有返回值
作用:
- new本质在调用构造方法
- 初始化对象的值
注意点:

定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造

Alt加insert

默认生成有参，select none生成无参

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

创建对象内存分析

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

封装

属性私有，get/set

可以提高安全性

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

继承

extands的意思是“扩展”。子类是父类的扩展。
JAVA中类只有单继承，没有多继承!
被final修饰的类不能被继承。

object类

java中的所有类都直接或间接继承Object类

Ctrl加H

可以查看当前类的继承树

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

super

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

可以省略

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

super注意点:
- super调用父类的构造方法，必须在构造方法的第一个
- super 必须只能出现在子类的方法或者构造方法中!
- super和 this 不能同时调用构造方法!
Vs this:
- 代表的对象不同: this 本身调用者这个对象 super:代表父类对象的应用
- 前提 this:没有继承也可以使用 super:只能在继承条件才可以使用
- 构造方法 this() ; 本类的构造 super():父类的构造!

方法重写

父类静态方法

public class Demo04_A extends Demo04_B{
    
    public static void test(){
    
        System.out.println("A==>test()");
    }
}
//重写都是方法的重写，和属性无关
public class Demo04_B {
    
    public static void test(){
    
        System.out.println("B==>test()");
    }
}
public class Applications {
    
    public static void main(String[] args) {
    
        //Demo04
        //方法的调用只和左边，定义的数据类型有关
        Demo04_A a = new Demo04_A();
        a.test();//A==>test()
        //父类引用指向引用
        Demo04_B b = new Demo04_A();
        b.test();//B==>test()
    }
}

父类非静态方法

public class Applications {
    
    public static void main(String[] args) {
    
        //Demo04
        /*
            静态方法和非静态方法区别很大
            静态方法：方法的调用只和左边，定义的数据类型有关
            非静态方法：重写，父类方法只能是public
         */
        Demo04_A a = new Demo04_A();
        a.test();//A==>test()
        //父类引用指向引用
        Demo04_B b = new Demo04_A();//子类重写了父类的方法
        b.test();//A==>test()
    }
}
//重写都是方法的重写，和属性无关
public class Demo04_B {
    
    public void test(){
    
        System.out.println("B==>test()");
    }
}
public class Demo04_A extends Demo04_B{
    
    @Override
    public void test() {
    
        System.out.println("A==>test()");
    }
}

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

方法名必须相同
参数列表列表必须相同
修饰符:范围可以扩大但不能缩小:public>Protected >Default>private
抛出的异常:范围，可以被缩小，但不能扩大: ClassNotFoundException --> Exception(大)
重写，子类的方法和父类必要一致;方法体不同!

多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
- 注意:多态是方法的多态，属性没有多态性。

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

public class Person {
    
    public void run(){
    
        System.out.println("Person==>run()");
    }
}
public class Student extends Person{
    
    @Override
    public void run() {
    
        System.out.println("Student==>run()");
    }
    public void stop(){
    
        System.out.println("Student==>stop()");
    }
}
public class Applications {
    
    public static void main(String[] args) {
    
        // 一个对象的实际类型是确定的:new Student();new Person();
        //可  以指向的引用类型就不确定了:父类的引用指向子类
        
        //Student 能调用的方法都是自己的或者继承父类的!
        Student s1 = new Student();
        
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        
        Object s3 = new Student();
        
        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大!
        
        s2.run(); //子类重写了父类的方法。执行子类的方法 Student==>run()
        s1.run();//Student==>run()
        s1.stop();//Student==>stop()
        Person p1 = new Person();
        p1.run();//Person==>run()
    }
}

多态注意事项:

多态是方法的多态，属性没有多态
父类和子类，有联系类型转换异常! ClassCastException!
存在条件: 继承关系，方法需要重写，父类引用指向于类对象! Father f1 = new Son();
不能进行多态的方法：
- static 方法，属于类，它不属于实例
- final常量;
- private 方法;|

父子类强转

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

父类转子类

public class Application {
    
	public static void main(String[] args) {
    
        //类型之间的转化:父子
        //高               低
        Person obj = new Student();
        //student将这个对象转换为Student类型，我们就可以使student类型的方法了!
        ((Student) obj).go();
	}
}

子类转父类

public class Application {
      
    public static void main(String[] args) {
      
        //类型之间的转化:父           子
        //子类转换为父类，可能丢失自己的本来的一些方法!
        Student student = new Student();
        student.go();
        Person person = student;
    }
}

instanceof

(类型转换)引用类型，判断一个对象是什么类型~

public class Applications {
    
    public static void main(String[] args) {
    
        Object object = new Student();
        //System. out . println(X instanceof Y);//能不能编译通过! X,Y之间要存在父子关系
        //System. out . println(X instanceof Y);// X是Y之的子类，true
        System.out.println(object instanceof Student); //true
        System.out.println(object instanceof Person); //true
        System.out.println(object instanceof Object); //true
        System.out.println(object instanceof Teacher); //False
        System.out.println(object instanceof String); //False
        System.out.println("===========================");
        Person person = new Student();
        System.out.println(person instanceof Student); //true
        System.out.println(person instanceof Person); //true
        System.out.println(person instanceof Object); //true
        System.out.println(person instanceof Teacher); //False
        //System.out.println(person instanceof String); //不能通过编译
        System.out.println("===========================");
        Student student = new Student();
        System.out.println(student instanceof Student); //true
        System.out.println(student instanceof Person); //true
        System.out.println(student instanceof Object); //true
        //System.out.println(student instanceof Teacher); //不能通过编译
        //System.out.println(student instanceof String); //不能通过编译
    }
}

static

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

静态导入包

import static java.lang.Math.random;
import static java.lang.Math.PI;
public class He {
    
    public static void main(String[] args) {
    
        System.out.println(random());
        System.out.println(PI);
    }
}

抽象类

abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方;如果修饰类，那么该类就是抽象类。
抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。
抽象类,不能使用new关键字来创建对象, 它是用来让子类继承的。
抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法, 否则该子类也要声明为抽象类。

接口

方法public abstract 按口中的所有定义的方法其实都是抽象的public abstract
常量public static final 常量~ pubsic static final,一般不在接口中定义常量
接口不能被实例化_{，接口中没有构造方法}
implements 可以实现多个接口
必须要重写接口中的方法~

异常

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

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

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

Ctrl加Alt加T

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

本文链接：https://blog.csdn.net/qq_45783660/article/details/111566530

原作者删帖不实内容删帖广告或垃圾文章投诉

智能推荐

【转】多核处理器的工作原理及优缺点_多核处理器怎么工作-程序员宅基地

文章浏览阅读8.3k次，点赞3次，收藏19次。【转】多核处理器的工作原理及优缺点《处理器关于多核概念与区别多核处理器工作原理及优缺点》原文传送门　　摘要：目前关于处理器的单核、双核和多核已经得到了普遍的运用，今天我们主要说说关于多核处理器的一些相关概念，它的工作与那里以及优缺点而展开的分析。1、多核处理器　　多核处理器是指在一枚处理器中集成两个或多个完整的计算引擎（内核），此时处理器能支持系统总线上的多个处理器，由总..._多核处理器怎么工作

个人小结---eclipse/myeclipse配置lombok_eclispe每次运行个新项目都需要重新配置lombok吗-程序员宅基地

文章浏览阅读306次。1. eclipse配置lombok 拷贝lombok.jar到eclipse.ini同级文件夹下，编辑eclipse.ini文件，添加: -javaagent:lombok.jar2. myeclipse配置lombok myeclipse像eclipse配置后，定义对象后，直接访问方法，可能会出现飘红的报错。如果出现报错，可按照以下方式解决。 ..._eclispe每次运行个新项目都需要重新配置lombok吗

【最新实用版】Python批量将pdf文本提取并存储到txt文件中_python批量读取文字并批量保存-程序员宅基地

文章浏览阅读1.2w次，点赞31次，收藏126次。#注意：笔者在2021/11/11当天调试过这个代码是可用的，由于pdfminer版本的更新，网络上大多数的语法没有更新，我也是找了好久的文章才修正了我的代码，仅供学习参考。1、把pdf文件移动到本代码文件的同一个目录下，笔者是在pycharm里面运行的项目，下图中的x1文件夹存储了我需要转换成文本文件的所有pdf文件。然后要在此目录下创建一个存放转换后的txt文件的文件夹，如图中的txt文件夹。2、编写代码（1）导入所需库# coding:utf-8import ..._python批量读取文字并批量保存

【C语言初阶】内存管理（内存的分配方式、常见的内存错误即对策、杜绝”野指针“）_函数造成的内存错误怎么解决-程序员宅基地

文章浏览阅读646次。内存的分配方式、常见的内存错误即对策、指针与数组的对比、free、杜绝“野指针“、内存耗尽怎么办、malloc/free 的使用要点_函数造成的内存错误怎么解决

6.UE4的多维数组_ue 二维数组-程序员宅基地

文章浏览阅读4.2k次。一. 多维数组的概念1. 一维像线，array[0]，索引2. 二维像表格（面），array[0][0]，行列3. 三维像立方体，array[0][0][0]，行列厚度二. 三维数组在虚拟漫游中的应用使用三维数组表示一栋楼的数据设定结构体 RoomInfo属性变量名称数据类型面积 RoomAreaF 单价 Price_ue 二维数组

读取csv(excel类相关文件)常见bug，及解决办法统计__csv.error: line contains nul-程序员宅基地

文章浏览阅读2.5k次，点赞2次，收藏2次。bug1:UnicodeDecodeError: ‘gbk’ codec can’t decode byte 0xb1 in position 5: illegal multibyte sequence解决办法1：上面报错的意思就是，默认以gbk的方式读取数据，但是文本数据是utf-8类型的，这是需要用到另一个参数encoding，也就是把它编码成与文本一样类型的格式，下面的代码encoding="utf-8"就是要修改的地方，如果不写编码格式，默认是encoding="gbk"的#open(“.__csv.error: line contains nul

随便推点

NPOI 在 System.IO.FileNotFoundException 中第一次偶然出现的“mscorlib.dll”类型的异常_在system.io.filenotfund 第一次偶现的 mscorlib-程序员宅基地

文章浏览阅读6.1k次。本人环境是：VS2008 64位系统。报错的版本是NPOI 2.1.3 binary(2.1.3之前都不可以) 。之后换上NPOI binary 2.1.3.1版本错误消失，正常启动！NPOI官网： https://npoi.codeplex.com/..._在system.io.filenotfund 第一次偶现的 mscorlib

A survey of Large Lanuage models_a survey of large language models-程序员宅基地

文章浏览阅读720次。Reddit link：高赞链接，知乎或者贴吧类似的；2.预训练数据的数量，随着大语言模型参数规模的增加，需要增加更多数据，chinchilla表明，现有许多大语言模型由于缺乏足够的预训练数据而受到次优训练的影响，llama表明，随着更多数据和更长时间的训练，较小的模型可以实现良好的性能。LLM，语言建模目标是通过单词预测对模型参数进行预训练，但缺乏对人类价值观和偏好的考虑，提出人类对齐，使大语言模型行为能够符合人类的期望，但是与初始的预训练和适应微调不同，语言模型的对齐需要考虑不同的标准。_a survey of large language models