B站学习JAVA学习笔记

Java特性和优势

简单性
面向对象
可移植性
高性能
分布式
动态性
多线程
安全性
健壮性

Java三大版本

JavaSE：标准版（桌面程序，控制台开发…)
JavaME：嵌入式开发（几乎已死）
JavaEE：E企业级开发（web端，服务器开发…)

JDK、JRE、JVM

JDK：Java Development Kit
JRE：Java Runtime Environment
JVM：JAVA Virtual Machine

JDK包括JRE、JVM，JRE包括JVM

JAVA关键字


abstract	asssert	boolean	break	byte
case	catch	char	calss	const
continue	default	do	double	else
enum	extends	final	finally	float
for	goto	if	implements	import
instanceof	int	interface	long	native
new	package	private	protected	public
return	strictfp	short	static	super
switch	synchronized	this	throw	throws
transient	try	void	volatile	while

所有的标识符都应该以字母（A-Z或者a-z），美元符号（$)、或者下划线（_)开始
首字母之后可以是字母（A-Z或者a-z），美元符号（$)、或者下划线（_)或数字的任何字符
不能使用关键字作为变量名或方法名
标识符是大小敏感的
合法的标识符举例：age、$salary、_value

数据类型

基本类型

byte	short	int	long	float	double	char	boolean
1个字节	2字节	4字节	8字节	4字节	8字节	2字节	1位

long类型要在数字后面加个L，float类型要在数字后面加个F

位（bit）是计算机内部数据储存的最小单位，11001100是一个八位二级制数

字节（byte）：是计算机中数据处理的基本单位，习惯上用大写B来表示

1B(byte，字节) = 8bit（位）

字符：是指计算机中使用的字幕、数字、字和符号

引用类型

类接口数组枚举标注

*String是类，引用类型

类型转换

强制转换：（类型）变量名高—>低

自动转换：低—>高

1. 不能对布尔值进行转换

2. 不能把对象类型转换为不相干的类型

3. 在把高容量转换为低容量的时候，强制转换

转换的时候可能存在内存溢出，或者精度问题

变量

实例变量：从属于对象；如果不自行初始化，这个类型的默认值 0, 0.0
布尔值：默认是false
除了基本类型，其余的默认值都是null

类变量 static ，从属于类，会和类一起出来一起消失。

常量：final 常量名=值（final double PI=3.14）

修饰符不存在先后顺序

变量名的命名规范

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

位运算

A = 0011 1100

B = 0000 1101

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~B = 1111 0010

Scanner对象

基本语法：

package com.ljb;
import java.util.Scanner;
public class Main {
    
    
    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(); 
    }   
}
输出结果：
    使用next方式接收：
    Hello world
    输入内容为：Hello
  -------------------------------------------------------------------------
package com.ljb;
import java.util.Scanner;
public class Main {
    
    

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

next():
- 一定要读取到有效字符后才可以结束输入。
- 对输入有效字符之前遇到的空白，next（）方法会自动将其去掉。
- 只有输入有效字符后才将其后面输入空白作为分隔符或者结束符。
- next（）不能得到带有空格的字符串
nextLine():
- 以Enter为结束符，也就是说nextLine（）方法返回的是输入回车之前的所有字符。
- 可以获得空白。

println 输出完会换行

print 输出完不会换行。

break 在任何循环语句的主体部分，均可用break控制循环流程。break用于强行退出循环，不执行循环中剩余的语句。

continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

打印三角形

package com.ljb;
public class test1 {
    
    
    public static void main(String[] args) {
    
    
        //打印三角形
        for (int i = 0; i <= 5; i++) {
    
    
            for (int j = 5; j >= i; j--) {
    
    
                System.out.print(" ");
            }
            for (int j = 1; j <= i; j++){
    
    
                System.out.print("*");
            }
            for(int j = 1; j < i; j++){
    
    
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

九九乘法表

package com.ljb;
public class addTet {
    
    
    public static void main(String[] args) {
    
    
        int sum = 0;
        for (int i = 1; i < 10; i++) {
    
    
            for (int i1 = 1; i1 <= i; i1++) {
    
    
                sum = i * i1;
                System.out.print(i1 + "*" + i + "=" + sum+ "\t");
            }
            System.out.println();
        }
    }
}

方法重载

- 重载就是在一个类中，有相同的函数名称，但形参不同的函数。

方法的重载的规则
- 方法名称必须相同
  - 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）。
    - 方法的返回类型可以相同也可以不相同
  - 仅仅返回类型不同不足以成为方法的重载。
实现理论
- 方法名称相同是，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

递归

递归就是A方法调用A方法，就是自己调用自己。
- 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
- 递归体：什么时候需要调用自身方法。

package com.ljb;
public class test2 {
    
    
    public static void main(String[] args) {
    
    
        System.out.println(f(3));
    }

    //阶乘方法
    public static int f(int n){
    
    
        if (n==1){
    
    
            return 1;
        }else {
    
    
            return n*f(n-1);
        }
    }
}

数组

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

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

Java语言使用new操作符来创建数组，语法如下：

dataType[] arrayRefVar = new dataType[arraySize];
//类似
dataType[] arrayRefVar;   //1.声明一个数组
arrayRefVar = new dataType[arraySize];   //创建一个数组
arrayRefVar[0] = 1;   //赋值

数组的元素是通过索引访问的，数组索引从0开始。
获取数组长度：arrays.length

三种初始化

静态初始化（创建 + 赋值）

int[] a = {
      
      1,3,4};  //不可改变了
Man[] mans = {
      
      new Man(1,1), new Man(2,2)};

动态初始化（包含默认初始化）

int[] a = new int[2];
a[0] = 1;
a[1] = 2;

多维素组

二维数组：
int a[][] = new int[2][5]

int[][] array = {
      
      {
      
      2,3},{
      
      2,2},{
      
      123,213}}

稀疏数组

package com.ljb;
public class test3 {
    
    
    public static void main(String[] args) {
    
    
        //1.创建一个二维数组11*11  0：没有棋子   1：黑棋   2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始的数组
        System.out.println("输出原始数组");

        for (int[] ints : array1) {
    
    
            for (int anInt : ints) {
    
    
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
        System.out.println("-------------------------------");

        //转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
    
    
            for (int j = 0; j < 11; j++) {
    
    
                if (array1[i][j] != 0){
    
    
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数：" +sum);

        //1.创建一个稀疏数组的数组
        int[][] array2 = new int[sum+1][3];

        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //遍历二维数组，将非零的值，存在稀疏数组中
        int count = 0;
        for (int i = 0 ; i <array1.length; i++){
    
    
            for (int j = 0; j < array1[i].length; j++) {
    
    
                if (array1[i][j] != 0){
    
    
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];

                }
            }
        }
        //输出稀疏数组
        System.out.println("稀疏数组");

        for (int i = 0; i < array2.length; i++) {
    
    
            System.out.println(array2[i][0] + "\t"
                    + array2[i][1] + "\t"
                    + array2[i][2] + "\t");
        }
        System.out.println("-------------------------------");
        System.out.println("还原");
        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];

        //2.给其中的元素还原它的值
        for (int i = 1; i < array2.length; i++) {
    
    
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //输出还原的数组
        System.out.println("输出还原数组");

        for (int[] ints : array3) {
    
    
            for (int anInt : ints) {
    
    
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }
}

面向对象（OOP）

面向对象思想：物语类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
面向对象编程的本质：以类的方式组织代码，以对象的组织（封装）数据。
三大特性：封装、继承、多态

对象：具体的事物类：是抽象的，是对对象的抽象

类与对象的关系

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
- 动物、植物、手机、电脑…
- Person类、Pet类、Cat类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
对象是抽象概念的具体实例。
- 张三就是人的一个具体实例，张三加的里的旺财就是狗的一个具体实例。
- 能够体现出特点，展示出功能的是具体的实例，而不是一个抽象的概念。

类是对象的一个抽象，而对象是类的一个具体实例化

类是抽象的，类实例化后悔返回一个自己的对象

构造器

类中的构造器也称为构造方法，是在进行创建杜旭的时候必须要调用的。并且构造器有以下两个特点：
- 1.必须和类的名字相同
- 2.必须没有返回类型，也不能写void

自动生成构造器快捷键：alt+ insert

package com.ljb;
public class test4 {
    
    
    public static void main(String[] args) {
    
    
        Person person = new Person("lujiebin",18);
        System.out.println(person.name + "\n" + person.age);

    }
}

package com.ljb;
public class Person {
    
    
    //一个类即使什么都不写，它也会存在一个方法
    //显示定义的构造器
    String name;
    int age;
    //构造器作用：1.使用new关键字，必须要有构造器 2.用来初始化值

    //无参构造
    public Person(){
    
    

    } 
    //有参构造:一旦定义了有参构造，无参构造就必须显示定义
     public Person(String name){
    
    
        this.name = name;
    }
    public Person(String name, int age){
    
    
        this.name = name;
        this.age =age;
    }
}

封装

“高内聚，低耦合”；属性私有，get/set

package com.ljb;
public class test5 {
      
      
    public static void main(String[] args) {
      
      
        Student s1 = new Student();
        s1.setName("lujiebin");
        System.out.println(s1.getName());

        s1.setAge(999);
        System.out.println(s1.getAge());
    }
}

package com.ljb;
public class Student {
      
      
    private String name;    //名字
    private int id;   //学号
    private char sex;   //性别
    private int age;    //年龄

    //提供一些可以操作这些属性的方法，提供一些public的get、set 方法
    //get 获得这个数据
    public String getName(){
      
      
        return this.name;
    }
    //set 给这个数据设置值
    public void setName(String name){
      
      
        this.name = name;
    }
    
    public int getAge() {
      
      
        return age;
    }
    public void setAge(int age) {
      
      
        if (age > 120 || age < 0) {
      
      
            System.out.println("年龄不合法");
        } else {
      
      
            this.age = age;
        }
    }
}

提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口
系统可维护性增加了

继承

继承的本质是都某一批类的抽象，从而实现世界更好的建模
extands的意思是“扩展”。子类是父类的扩展。
Java中类只有单继承，没有多继承！
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
子类和父类之间，从意义上讲应该具有“is a” 的关系。
私有private的无法继承。

package com.ljb.demo;

public class demo {
      
      
    public static void main(String[] args) {
      
      
        Student student = new Student();
        student.say();
        System.out.println(student.money);
    }
}

package com.ljb.demo;
//父类
public class Person {
      
      

    public int money = 100_0000;
    public void say(){
      
      
        System.out.println("说了一句话");
    }
}

package com.ljb.demo;
//学生  is  人
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{
      
      

}

super

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

和this相比较：

代表的对象不同
- this：本身调用者这个对象
- super：代表父类对象的应用
前提
- this：没有继承也可以使用
- super：只能在继承条件下可以使用
构造方法
- this（）：本类的构造
- super（）：父类的构造！

方法重写

重写都是方法的重写
需要有继承关系，子类重写父类的方法
- 方法名必须相同
- 参数列表必须相同
- 修饰符：范围可以扩大： public>protected>default>private
- 抛出异常：范围，可以被缩小，但不能扩大。
子类的方法和父类的方法必须保持一致，方法体不同
子类重写了父类的方法，执行子类的方法

为什么要重写：

父类功能，子类不一定需要，或者不一定满足！

多态

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

类型转换

父类引用指向子类的对象
把子类转换为父类，向上转型
把父类转换为子类，向下转型；需要强制转换，
方便方法的调用，减少重复的代码。

Static

static和类一起加载

package com.ljb.demo;
public class Student{
      
      
    private static int age; //静态的变量
    private double score;  //非静态的变量
    
    public void run(){
      
      
        
    }
    
    public static void go(){
      
      
      
    }

    public static void main(String[] args) {
      
      
        
        Student s1 = new Student();
        
        System.out.println(Student.age);
        System.out.println(s1.age);
        System.out.println(s1.score);
        Student.go();  
    }
}

接口

普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有！
接口：只有规范
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须…”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你是好人，则必须干掉坏人；如果你是坏人，则必须欺负好人
接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守
OOD的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都值针对具备了抽象能里的语言（比如c++、java等），就是因为设计模式所研究的，实际上就是如何合理去抽象。

内部类

内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了
1. 成员内部类
2. 静态内部类
3. 局部内部类
4. 匿名内部类

package com.ljb.demo;
public class demo1 {
        
        
    public static void main(String[] args) {
        
        
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.getID();
    }
}

package com.ljb.demo;
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);
        }
    }
}

异常机制

快捷键：ctrl+alt+t

package com.ljb.demo;
public class demo2 {
      
      
    public static void main(String[] args) {
      
      
        int a = 1;
        int b = 0;
        try{
      
      //try监控区域
            System.out.println(a/b);
        }catch (ArithmeticException e){
      
      //catch 捕获异常
            System.out.println("程序出现异常，变量b不能为0");
        }finally {
      
       //处理善后工作
            System.out.println("finally");
        }
    }
}
//finally 可以不要finally，假设IO，资源，关闭！