Java基础的杂七杂八（未完成）

1.Java基础的杂七杂八（未完成）2024-07-31

2.Java基础面向对象学习笔记（未完成）2024-07-31 3.Java的异常处理2024-10-31

java特点

1、面向对象性：两大要素：类、对象三大特征：封装、继承、多态
2、健壮性：去除了c/c++的指针；添加了垃圾回收机制--->但Java依旧可能出现内存的溢出和泄漏
3、跨平台性：write once ， run anywhere “一次编译，到处运行”-->JVM
不同的操作系统需要安装不同的JVM

为什么要配置环境变量

保障文件在任何目录下都可以执行Java的开发指令。比如 javac.exe java.exe
path环境变量： windows操作系统在执行命令时所要搜寻的路径

关键字

定义：被Java语言赋予了特殊含义，用作专门用途的字符串（单词）
特点：Java中的关键字都是小写

保留字

形势上是关键字，但并无实际用途，如goto const

Java中的名称命名规范

包名：多单词组成时，所有字母都要小写
类名、接口名：多单词组成时，所有单词的首字母都要大写
变量名、方法名：第一个单词首字母小写，从第二个单词开始，所有单词首字母大写
常量名：所有字母大写。多单词组成时，每个单词用下划线_隔开

long (8个字节）相较于float（4个字节）算容量小的

使用强转符可能会损失精度

String：字符串

1、String属于引用数据类型中的类，不是基本数据类型
2、使用一对“”（英文引号）引号来引用

关于进制

二进制：0，1。满二进一，以0b或0B开头
十进制：0-9。满十进一
八进制：0-7。满八进一以数字0开头
十六进制：0-9及A-F满十六进一，以0x或0X开头表示，A-F不区分大小写

如何使用Scanner类

1、导包：import java.util.Scanner
2、scanner类的实例化 Scanner scan = new Scanner(System.in);
3、调用Scanner类提供的方法，获取不同类型的变量

例

import java.util.Scanner;
public class test {
- public static void main(String[] args) {
- Scanner scan = new Scanner(System.in);
- int age=scan.nextInt();
- System.out.println("age= "+age);
- String name=scan.next();
- System.out.println("name= "+name);
- double len=scan.nextDouble();
- System.out.println("length= "+len);
- double stature=scan.nextDouble();
- System.out.println("stature= "+stature);
- }
}

说明：

1、不能使用Scanner来获取char类型变量，可以用String型来代替
2、如果要求获取的类型与用户输入的类型不匹配，则报错：InputMisMatchException

数组

概念（what）

多个相同类型的数据按照一定顺序排列的集合，并使用一个名字命名，并通过编号的方式进行统一管理

数组的声明和初始化

int[] arr1;//声明

静态初始化:数组初始化和数组元素的赋值同时进行

arr1= new int[]{1,2,3,4};//初始化
int[] name = new int[]{1,2,3,4};//合并声明和初始化

动态初始化：数组初始化和数组元素的赋值分开进行

String[] arr = new String[5];

不同数组的默认初始化值

整型：0
浮点型：0.0
字符型：’\0’(‘\u0000’)
布尔型：false
引用类型：null（空）

二维数组

随机数的产生

查找

方法一：线型查找（暴力）直接比较是否相等 O（n）
方法二：二分法查找O （log10n）前提：数组有序

arrays类

成员变量与局部变量

相同点：

声明变量的结构：数据类型变量名 = 变量值;
先声明后使用
都有对应的作用域
不同点：
类中声明的位置不同成员变量：直接声明在类中。局部变量：方法的形参、方法的内部、构造器的内部、构造器的形参、代码块的内部.....
权限修饰符的使用成员变量使用前可以用权限修饰符修饰，局部变量不可以常见的权限修饰符有 public｜private｜缺省
针对变量值的说明成员变量有默认初始化值，局部变量没有默认初始化值，在调用前必须显式初始化
内存中加载位置不同成员变量声明在栈空间中局部变量声明在堆空间中

this关键字的使用

理解：当前对象，或当前正在创建的对象
使用范围：this可以使用在方法或构造器的内部
可以调用的结构：属性、方法、构造器
在方法中使用this

我们可以在方法内，调用当前类的属性或方法，属性或方法前可以使用”this.“表明调用的当前对象的属性或方法。通常情况下我们都习惯省略此this关键字
但是如果方法的形参和类的属性名相同了，则必须使用“this.变量”的方式表明我们调用的变量是当前对象的属性，而非形参

如果在构造器中使用this：

我们可以在当前构造器中，调用当前类的属性或方法，属性或方法前可以使用“this.”的方式，表明调用的是当前对象的属性或方法。通常情况下我们都习惯省略此this关键字
但是如果构造器的形参和类的属性名相同了，则必须使用“this.变量”的方式表明我们调用的变量是当前对象的属性，而非形参

this来调用构造

可以在构造器中使用“this.(形参列表)”方式，调用当前类中的指定构造器
构造器中不可以使用“this.(形参列表)”方式，调用本身的构造器
如果类中声明了n个构造器，则最多可以有n-1个构造器中使用了使用“this.(形参列表)”方式调用其他构造器
规定要求将使用“this.(形参列表)”声明写在首行
一个构造器中最多只有一个声明“this.(形参列表)”方式

super关键字的使用

为什么需要super？

子类继承父类以后，对父类的方法进行了重写，那么在子类中，是否还可以对父类中被重写的方法进行调用？
```
！！！可以
```
子类继承父类以后，发现子类和父类中定义了同名的属性，是否可以在子类中区分两个同名的属性？
```
 ！！！可以
```

如何调用？使用super关键字即可。

super的理解：父类的

super可以调用的结构：属性、方法、构造器

super调属性、方法

子类继承构造器以后，我们就可以在子类的方法或构造器中调用父类的属性或方法。（满足封装性的前提下）调用时使用super.的结构表示调用父类属性或方法

super调用构造器

子类继承父类时，不会继承父类的构造器。只能通过“super（形参列表）”的方式调用父类指定的构造器。
规定：“super（形参列表）”，必须声明在构造器的首行。
我们前面讲过，构造器的首行可以使用“this（形参列表）”的方式，调用本类中的构造器，结合2，结论：在构造器的首行，“this（形参列表）”和“super（形参列表）”只能二选一。
如果在子类构造器的首行既没有显示调用“this（形参列表）”，也没有显示调用“super（形参列表）”，则子类此构造器默认调用“super（）”，即调用父类中空参的构造器。
由3和4得出结论：子类的任何一个构造器中，要么调用本类中重载的构造器，要么调用父类中的构造器，只能是这两种情况之一。
由5可得，一个类中声明有n个构造器，最多有n-1个使用“this（形参列表）”，则剩下的那个一定使用“super（形参列表）”

我们在通过子类的构造器构造对象时，一定在调用子类构造器的过程中，直接或间接的调用到父类的构造器。也正因为调用过父类的构造器，我们才会将父类中的属性或方法加载到子类中，供子类对象使用。

Object类

明确：java.lang.Object
任何一个Java类（除Object类）都直接或间接的继承于Object类
Object类被称为Java类的根父类
Object类中声明的结构（属性、方法）就具有通用性
Object类中没有声明属性
Object类提供了一个空参构造器
重点关注：Object类中声明的方法

Object常用方法

常用方法

重点方法：equals() \ toString()
了解方法：clone() \ finalize()
目前不需要关注：getclass() \ hashcode() \ notify() \ notifyAll() \ wait() \ wait(xx) \ wait(xx,yy)

equals()的使用

适用性：

任何引用数据类型都可以使用

java.lang.Object类中equals方法的定义

public boolean equals（Object obj）{

 return(this == obj);

}

子类使用说明

自定义的类在没有重写Object中equals()方法的情况下，调用的就是Object类中声明的equals()，比较两个对象的引用地址是否相同。（或比较两个对象是否指向了堆空间中的同一个实体对象）
对于像String、File、Date、和包装类等他们都重写了Object类中的equals()方法，用于比较两个对象的实体内容是否相等。

开发中的使用说明：

实际开发中，针对自定义的类，常常会判断两个对象是否equals()，而此时主要判断是两个对象的属性值是否相等。所以，我们要重写Object类的equals()方法
如何重写：
手动自己实现
调用IDEA自动实现

toString()的使用

Object类中toSring()的定义：

public String toString(){
return getClass().getName() + “@“ +Integer.toHexString(hashcode())

}

开发中使用的场景

平时我们在调用System.out.println()打印对象引用变量时，其实就调用了对象的toString()

子类使用说明：

自定义的类，在没有重写Object类的toString类的情况下，默认返回的是当前对象的地址值。
像String、File、Date、或包装类等Object子类，他们都重写了Object类的toString(),在调用toString时，返回当前对象的实体内容。

开发中使用说明：

习惯上，开发中对于自定义的类在调用toString()时，也希望显示其对象的实体内容，而非地址值。这时候需要重写Object类中的toString()方法

向下转型

在向下转型之前，使用instanceof进行判断，避免出现类型转换异常
格式：a instanceof A :判断对象a是否是类A的实例
如果a instanceof A 返回 true，则：
a instanceof superA返回值也是true。其中，A是superA的子类。

static关键字

如果想要一个成员变量被类的实例所共享，就用static修饰即可，被称为类变量（或类属性）

static：静态的
static 用来修饰的结构：属性、方法、代码块、内部类；
static修饰属性：
对比静态变量与实例变量
1）、个数

静态变量：在内存空间中只有一份，被类的多个对象共享
实例变量：类的每一个实例（或对象）都保存着一份实例变量

2）、内存位置

静态变量：jdk6及之前存放在方法区，jdk7及之后存放在堆空间
实例变量：存放在堆空间的对象实体

3）、加载时机

静态变量：随着类的加载而加载，由于类的加载只会加载一次，所以静态变量只会加载一次
实例变量：随着类的创建而加载，每个对象拥有一份实例变量

4）、调用者

静态变量：可以使用类直接调用，也可以使用对象调用
实例变量：只能使用对象调用

5）、消亡时机

静态变量：随着类的卸载而消亡
实例变量：随着对象的消亡而消亡

static修饰方法：（类方法、静态方法）

随着类的加载而加载
可通过"类.静态方法"的方式，直接调用静态方法
静态方法内可以调用静态的属性和方法，属性和方法的前缀是当前类
不可以调用非静态的结构，如属性和方法
在类的非静态方法中可以调用当前类的静态结构（属性、方法）或非静态结构（属性、方法）
static修饰的方法内不能使用this和super

开发中什么时候需要把属性声明为静态的？

判断当前类的多个实例是否能共享此成员变量，且此成员变量的值是相同的。
开发时常将一些常量声明为静态的，例如Math类中的PI

什么时候需要将方法声明为静态的？

方法内操作的变量为静态，建议将此方法声明为静态的方法
开发中，常常将工具类中的方法，声明为静态方法

单例（Singleton）设计模式

设计模式概述

设计模式是在大量的实践总结中和理论化之后优选的代码结构、编程风格以及解决问题的思考方式。设计模式免去我们再思考和摸索。就像是经典的棋谱，不同的棋局，我们用不同的棋谱。
经典的设计模式有23种。每个设计模式均是特定环境下特定问题的处理方法。

创建型模式 5+1 ：简单工厂模式、工厂方法模式、抽象工厂模式、创建者模式、原型模式、单例模式
结构型模式 7：外观模式、适配器模式、代理模式、装饰模式、桥接模式、组合模式、享元模式
行为模式 11 ：模版方法模式、观察者模式、状态模式、策略模式、责任链模式、命令模式、访问者模式、调停者模式、备忘录模式、迭代器模式、解释器模式

何为单例模式
所谓的类的单例模式，就是采取一定的方法在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只存在一个取得对象实例的方法
实现思路
我们要让类在虚拟机中只能产生一个对象，我们必须将类的构造器访问权限设定为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类内部仍可以产生类的对象。因为在类的外部开始还无法得到类的对象，只能调用类的某个静态方法，以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向该类内部产生的该类对象的变量也必须定义成静态的。
如何实现单例设计模式

饿汉式

class student{
    private static String name;
    private static String ID;
    private student(){

    }
    public static student getStudent(){
        student s1 = new student();
        return s1;
    }
}
> 直接创建对象

懒汉式

class student{
    private static String name;
    private static String ID;
    private student(){

    }
    private static student s1 = null;
    public static student getStudent(){
        if(s1 == null)
            s1 = new student();
        return s1;
    }

}
> 调用时创建对象

对比两种模式
特点：

饿汉式：“立即加载”，随着类的加载，当前的唯一实例就加载了
懒汉式：“延迟加载”，在需要时进行创建
优缺点：
饿汉式：（优点）写法简单，由于内存中加载较早，使用更加方便、更快。线程安全（缺点）内存中占用时间较长。
懒汉式：（优点）在需要的时候进行创建，节省内存空间。（缺点）线程不安全。

final关键字的使用

final的理解：最终的
final可以用来修饰的结构：类、方法、变量

具体说明：
3.1 final修饰类：表示此类不能被继承
比如：String、StringBuffer、StringBuilder类
3.2 final修饰方法：表示此方法不能被重写
比如：Object类中的getClass()
3.3 final修饰变量：既可以修饰成员变量，也可以修饰局部变量。
此时的"变量"其实就是常量，意味着一旦被赋值，不可被修改

final修饰成员变量：有哪些位置可以给成员变量赋值
> 显示赋值、构造器赋值、代码块赋值

final修饰局部变量：一旦赋值就不能更改
> 方法内声明的局部变量：在调用局部变量前，一定需要赋值，一旦赋值就不能更改
> 方法的形参，在调用此方法时，给形参进行赋值，而且一旦赋值就不可更改

final与static搭配：修饰成员变量时，此成员变量称为“全局变量”
比如：Math中的PI

posted on 2024-07-31 16:35 侯广阅读(8) 评论(0) 编辑收藏举报