Java基础学习

特殊方法

生成随机数

生成随机整数

Random r = new Random();
int num = r.nextInt();

scanner输入

        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        Byte b = sc.nextByte();
//        sc.next()扫描字符串时遇到空白符会停止扫描
        String string = sc.toString();
        String str = sc.next();
        //在使用nextLine方法前不能使用非nextLine类型 
        String str2 = sc.nextLine();
        String str3 = new BufferedReader(new InputStreamReader(System.in)).readLine();
//        关闭资源
        sc.close();

Arrays类对数组的操作

 *      类的特点
 *          针对数组进行操作的工具类
 *      类的位置
 *          java.util
 *      类的构造器
 *          构造器私有化
 *      类的方法
 *          public static String toString(int[] a)
 *              返回指定数组内容的字符串表示形式。
 *          public static int[] copyOf(int[] original,int newLength)
 *              复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。
 *          public static int binarySearch(int[] a,int key)
 *              使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。
 *          public static void sort(int[] a)
 *              对指定的 int 型数组按数字升序进行排序。
 *          public static <T> void sort(T[] a,Comparator<? super T> c)
 *              根据指定比较器产生的顺序对指定对象数组进行排序
 *
 * 注意事项:
 *      如果使用Arrays.sort()进行自定义对象数组排序,需要手动给其指定比较规则(定义比较器)
 *          比较器实现方式分类:
 *              自然顺序比较器:
 *                  实现Comparable<T>接口,重写compareTo(To)
 *              定制顺序比较器
 *                  实现Comparator<? super T>接口,重写compare(To1,To2)

BigInteger类

 * BigInteger类
 *      类的特点
 *          针对不可变精确的整数进行封装的工具类
 *      类的位置
 *          java.math
 *      类的构造器
 *          public BigInteger(String val)将 BigInteger 的十进制字符串表示形式转换为 BigInteger。
 *      类的方法

关键字

import关键字

含义：导包
位置：package后面，class前面
格式

• import 包名.类名；
• import 包名.*；

this关键字

• 用法1
  • 使用场景：子类的构造器中或子类的实例方法
  • 格式：this.实例方法名（实参）/实例变量名
  • 作用：用来区分同一个类中同名的实例变量和局部变量
  • 含义：那个对象调用了this关键字所在的构造器，this对象就代表这个构造器
• 用法2
  • 适用场景：在构造器中
  • 格式：this（实参）
  • 作用：调用本类中其他的构造器完成对象成员的初始化操作
  • 注意事项：
    • this（实参）必须在构造器中的第一行，否则编译报错
    • 一旦构造器中含有this（），该构造器不会进行实例成员的初始化操作（构造器中第一阶段和第二阶段的内容不执行）

static关键字

含义：静态的，共享的
修饰内容：成员变量，成员常量，成员方法，成员内部类，成员代码块
特点

• 被static关键字修饰的内容不在属于对象，二十归属于类，会被这个类创建的所有对象所共享
• 被static关键字修饰的内容会随着类的加载而加载，只会加载唯一的一次

静态变量

含义：被static修饰的成员变量
格式：static 变量类型 变量名；
特点：被static关键字修饰的成员变量不属于对象，而是归属于类本身，会被这个类创建的所有对象共享

静态方法

含义：被static修饰的成员方法
格式：修饰符 static 返回类型 方法名（）{
}
特点

• 被static关键字修饰的方法不属于对象，而是归属于类本身，会被这个类创建的所有对象共享
• 当创建一个对象只是为了使用里面大量的实例方法进行操作，和对象本身无关，导致对象本身在堆内存中一直驻留，良妃内存空间，在实际用过程中可以将这些实例方法修饰成静态的，被static修饰的方法不再属于对象，而是归属于类本身，使用里面的工具方法

调用方法：new.方法名（）
静态方法注意事项

• 静态方法随着类的加载而加载，而且只加载唯一的一次
• 静态方法可以通过类名调用也可以通过对象名调用，建议通过类名进行调用
• 静态方法中不可以使用非静态成员
• 静态方法中不可以使用this关键字和super关键字

静态代码块

含义：被static修饰的代码块
格式：static{代码}
作用

• 封装工具类，提高部分代码加载实际
• 类和实例成员初始化过程的笔试题
• 给静态常量进行初始化赋值操作

注意事项

• 静态代码块随着类的加载而加载，只加载一次
• 静态代码块中不可以使用非静态成员
• 静态代码块中不可以使用this和super关键字

java基础概念

关键字

关键字：被赋予特殊含义的单词
关键字都是小写的

特殊字符

1. \t：制表符，在打印的时候，把前面字符串的长度补齐到8，或者8的整数倍。最少补1个空格，最多补8个空格

计算机存储规则

数字进制表示

二进制:由0和1组成，代码中以ob开头
十进制:由0~9组成，前面不加任何前缀
八进制:由0~7组成，代码中以0开头
十六进制:由0-9还有a~f组成，代码中以0x开头

数据类型

整数：byte（8位），short，int（默认类型），long（定义的时候数值后需要加L）
浮点型：float（定义时数值后缀需要加F），double
字符型：char
布尔型：false，true

取值范围：byte < short <int < long < float < double

标识符

给类，变量等起的名字

1. 由数字、字母、下划线和$组成
2. 不能以数字开头
3. 不能是关键字
4. 区分大小写

小驼峰命名法：方法名，变量名

1. 标识符是一个单词时全部小写
2. 标识符为多个单词组成时，第一个单词首字母小写，其他单词首字母大写

大驼峰命名法：类名
3. 标识符为一个单词时首字母大写
4. 标识符为多个单词时，每个单词的首字母大写

API

提供的类和接口
Java API：Java系统中共提供的类和接口

键盘输入

import java.util.Scanner;

public class dome1 {
    public static void main(String[] args) {
//        创建一个scanner对象
        Scanner sc = new Scanner(System.in);
        /*
        接收数据，并赋值给i
            
         */
        int i = sc.nextInt();
    }
}

运算符

对自变量或变量进行操作的符号
表达式：通过运算符把自变量和变量连接起来，符合Java语法的式子称为自变量，例如a+b

算术运算符

+：加()
-：减
*：乘
/：除（整数除法结果取整）
%：取模，取余

小数进行计算时计算结果可能不精确
当“”操作中出现字符串时，这个“+” 是字符串连接符，而不是算术运算符了会将前后的数据进行拼接，并产生一个新的字符串。(例如：“1”+234的结果为”1234“)

隐式转换

把一个取值范围小的数值转成取值范围大的数据，然后进行运算

1. 取值范围小的，和取值范围大的进行运算，小的会先提升为大的，再进行运算
2. byte short char 三种类型的数据在运算的时候，都会直接先提升为int，然后再进行运算

强制转换

//将int型强制转换为byte型
int(a)

自增自减运算符

表示把i+1

i++

表示把i-1

i--

赋值运算符

+=：表示将左边和右边相加然后将相加的结果赋值给等号左边的变量
-=：表示将左边和右边相减然后将相减的结果赋值给等号左边的变量
*=：表示将左边和右边相乘然后将相乘的结果赋值给等号左边的变量
/=：表示将左边和右边相除然后将相除的结果赋值给等号左边的变量

三元运算符

关系表达式？表达式1：表达式2
如果关系表达式为真，运行表达式1，否则运行表达式2

int a = 10;
int b = 20;
int max = a>b?a+b:a-b;（运行a-b）

switch

switch (5){
            case 1:
                System.out.println(1);
                break;
            case 2:
                System.out.println(2);
                break;
            case 3:
                System.out.println(3);
                break;
            case 4:
                System.out.println(4);
                break;
            default:
                System.out.println(5);
                break;
        }

数组

数组只能存储同一种数据类型的数据

数组存储时可以发生隐式类型转换

数组的定义

格式1：数据类型 [] 数组名
格式2：数据类型 数组名[]

数组的初始化

静态初始化

完整格式:数据类型[] 数组名 = new 数据类型[][ 元素1，元素2，元素3…};

 int[] array = new int[]{11，22，33 1};

简化格式:数据类型[] 数组名 ={ 元素1，元素2，元素3…};

 int[] array ={11，22，33 };

动态初始化

数据类型[] 数组名 = new 数据类型[数组的长度];

int[] array = new int[50];

整数类型:默认初始化值0
小数类型:默认初始化值o.0
字符类型:默认初始化值’/ugooe’空格
布尔类型:默认初始化值 false
引用数据类型:默认初始化值 nu11

内存分配

栈：方法运行时使用的内存，比如main方法运行，进入方法栈中执行
堆：存储对象或者数组，new来创建的，都存储在堆内存
方法区：存储可以运行的class文件
本地方法栈：JVM在使用操作系统功能的时候使用，和我们开发无关
寄存器：给CPU使用，和我们开发无关

方法

方法：程序中最小的执行单元
适用场景：重复使用且有独立功能的代码
优点：可以提高代码的可维护性和复用性

方法的定义

public static 返回值类型 方法名(参数类型 形参) {
方法程序
return 返回值；
}

public static int play(int num){
        System.out.println(num);
        return num;
    }

方法的调用

返回值数据类型 接收返回值的变量 = 方法名（实参）;

int num = play(2);

方法的重载

同一个类内的多个方法，同一个名但传输的参数不一样，可以构成重载
方法重载的好处
1: 定义方法的时候可以不用那么多的单词了
2: 调用方法的时候也不需要那么麻烦了。

面向对象

面向对象三大特征

• 封装：在程序中给不同的声明内容添加不同的权限访问级别，提高程序的安全性和访问型

权限访问的四种级别
private<缺省（什么都不写）<protected(受保护的)<public

• private：
  • 含义：私有的
  • 修饰：实例变量，静态变量，实例常量，静态常量，实例方法，静态方法，实例成员，静态成员，实例成员内部类，静态成员内部类，构造器
  • 特点：被private修饰的内容，只能在本类中进行访问和使用，在本类之外无法使用，否则编译报错

• 继承
• 多态

类和对象

类：

含义：事物在程序中抽象的表现形式（例如：人类,猫类）
属性：事务的属性信息
行为：事务的行为动作

对象

含义：某一类事物的具体体现

类和对象的关系

类是对象的抽象，模板
对象是类的实例，实体

类的设计

步骤：

1.根据事物的病性和行为设计最基础的”横版类" 2。在模版类的基础上添加封装思想
3.根据实际需求,加入构造器, 完成最基础的avabean 标准类的设
4.根据实际需求，加入静态的概念
5.根据实际需求,加入继承思想
6.根据实际需求，加入抽象疆念
7.根据实际需求,加入"最终"概念
8.根据实际需求，加入接口疆念
9.根据实际需求,加入内部类的概念
10.根据实际需求，加入放举类的概念
11.根据实味需灭,加入注解概念
12.根据文际需尖,加入构造器代码块
13.根据实际需，加入静态代码块

• 类的成员：类作为模板的一部分
  • 字段（成员量）：类中成员变量和成员常量的统称
    • 声明在类中代码块外的变量,包含"实例变量"和”静态变量"
      • 实例变量: 声明在类中代码块外,且没有static关键字修饰的成员变量,实例变量归属于"对象”
      • 静态变量:声明在类中代码块外,且含有static 关键字修饰的成员变量,静态变量归属于"类”(暂不涉及)
    • 成员常量: 声明在类中代码块外的常量,包含”实例常量”和”静态常量”( 暂不涉及)
      • 实例常量:声明在类中代码块外,且没有static 关键字修饰的成员常量，实例常量归属于"对象”(暂不涉及
      • 静态变量: 声明在类中代码块外,且含有statc 关健字修饰的成员变量,静态变量归属于"类”(暂不涉及)
  • 成员方法：类中实例方法和静态方法的统称
    • 实例方法:声明在类中且没有static 关键字修饰的成员方法,实例方法归属于"对象( 暂不涉及)
    • 静态方法：声明在类中且含有static 关键宇修饰的成员方法,静态方法归属于"类"
  • 成员内部类

三种变量的区别（实例变量和局部变量，静态变量）的区别

实例变量: 声明在类中代码块外,且没有static关键字修饰的成员变量,实例变量归属于"对象”
静态变量:声明在类中代码块外,且含有static 关键字修饰的成员变量,静态变量归属于"类”
局部变量：生命在代码块内或者方法声明上的变量

• 代码中的位置不同
  • 实例变量: 类中代码块外
  • 局部变量: 代码块内或方法声明上(形参列表)
  • 静态变量：类中代码块外
• 内存中的位置不同:
  • 实例变量: 堆内存
  • 局部交量: 栈内存
  • 静态变量：在jdk7.0之前在方法区，在jdk7.0及以后存放在堆内存
• 变量是否含有默认值不同:
  • 实例变量: 含有默认值
  • 局部变量: 没有默认值
  • 静态变量：含有默认值
• 代码中的作用域不同
  • 实例变量：所属类中
  • 局部变量：所属方法中
  • 静态变量：所属类中
• 内存中的周期不同
  • 实例变量：随着对象的创建而加载，随着对象的回收而消失
  • 局部变量：随着方法的调用而加载，随着方法的出栈而消失
  • 静态变量：随着类的加载而加载，随着类的回收而消失
• 加载方式和次数不同
  • 静态变量：随着类的加载而加载，因为类只会加载一次，所以静态变量也只会加载一次
  • 实例变量：随着对象的创建而加载，没创建一次对象而加载一次
  • 局部变量：随着方法的调用而加载，每次调用一次方法就会加载一次
• 修饰符的使用不同
  • 实例变量：程序中的各种修饰符都可以根据需求修饰
  • 局部变量：只能使用final进行修饰

成员方法

内容：写在类中，但不会作为模板的一部分，只作为工具进行使用

• 构造器
  • 构造器的含义
    • 关键字new会通过构造器对对象进行堆内存区域的开辟
    • 针对对象的成员进行实例初始化
    • 如果是有参的构造器可以对对象的属性进行赋值操作
  • 构造器的特点
    • 构造器的名字必须和类名一样
    • 构造器没有返回值类型（void也不写）
    • 构造器和方法类似，也叫做构造方法，但是构造器有别于方法
  • 构造器中内容（共三部分）
    • 第一部分：隐式或显式的super（实参）或显式的this（实参）
    • 第二部分：隐式加载实例成员和构造器代码块
    • 第三部分：构造器中除this（实参）或super（实参）的显示代码
  • 当一个类没有构造器时，JVM的编译器在编译时会自动补全一个public的无参构造器，供其创造对象
  • 构造器支持方法重载
• 构造器代码块
• 静态代码块

JavaBean标准类

含义：在实际开发中没有上级的特殊说明的情况下，程序员间约束类的约定俗成的规范

内容

1. 类的声明必须有public修饰
2. 一个.java文件只能有一个类
3. 必须有无参构造器
4. 所有的成员变量必须进行私有化
5. 每一个成员变量必须有get，set方法
6. 可以根据实际需求添加有参构造器
7. 可以根据需求添加构造器代码块
8. 可以根据实例需求添加静态代码块
9. 可以根据需求添加toString，hashCode，equals
10. 可以根据需求添加内部类

匿名对象

没有名字的对象
格式：new 类名（实参）；
优点：降低对象在内存中的时间，提高内存的使用率
弊端：匿名对象只能使用一次

对象数组

含义：存储对象的数组

初始化

• 动态初始化：类名[] 数组名 = new 类名[数组长度];
• 静态初始化：类名[] 数组名=new 类名[]{对象名1，对象名2…}

类的私有方法

被private修饰的方法
特点：只能在本类中进行调用，不能再本类外进行调用

private void stu(){}

构造器代码块

位置：再类中代码块外
格式：{构造器中相同的内容}
特点

• 构造器代码块优先于构造器中的显示代码执行
• 将所有构造器中相同的内容抽取到构造器代码块中，在初始化过程中的第二阶段调用构造器代码块

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

		public student(String name) {
		在一个参数的构造器中调用两个参数的构造器
		        this(name,0);
		    }
		
		    public student(String name, int age) {
		        this.name = name;
		        this.age = age;
		    }

设计模式和框架

设计模式：解决某一类问题的固定的解决方案
框架：半成品项目
单例设计模式：创建唯一对象的解决方案
分类

• 立即加载模式
  • 将创建唯一对象的类构造器进行私有化
  • 创建唯一对象的类中声明并初始化唯一对象
  • 为了可以在外界进行访问，将其进行static修饰
  • 为了唯一对象安全性，将其进行private
  • 为了可以在外界进行访问，提供公共的访问方式
  • 弊端：部分场景中，不需要使用对象，但是可能加载该类，导致对象的创建，在一段时间内浪费堆内存中空间
• 延迟加载模式
  • 将创建唯一对象的类构造器进行私有化
  • 创建唯一对象的类中声明唯一对象变量
  • 为了可以在外界进行访问，将其进行static修饰
  • 为了唯一对象安全性，将其进行private
  • 为了可以在外界进行访问，提供公共的访问方式，并且在第一次获取时创建唯一对象

立即加载模式
public class student{
    private static student stu = new student();
    private student(){

    }

    public static student getStu() {
        return stu;
    }
}

延迟加载模式
public class student{
    private static student stu;
    private student(){

    }

    public static student getStu() {
        if(stu==null){
            stu=new student();
        }
        return stu;
    }
}