java基础学习笔记

最新推荐文章于 2024-07-12 14:17:28 发布

Hly8521

最新推荐文章于 2024-07-12 14:17:28 发布

阅读量109

点赞数

文章标签：学习

本文链接：https://blog.csdn.net/qq_59467431/article/details/127934600

版权

第一部分

1.IDEA快捷键介绍

如下

psvm、ctrl+alt+L（格式化代码）、alt+shift+上方向键（上下移动当前代码）

ctrl+/（注释）、ctrl+shift+/（注释）

2.注释

单行注释

// 注释内容，只能写一行

多行注释

/*

注释内容1

注释内容2

*/

文档注释

/**

注释内容

注释内容

*/

第二部分

1.“+”做连字符

实例：

int a=5;

System.out.println（“abc”+“a”）;

System.out.println（“abc”+a）;

2.三目运算符

int score = 90;
System.out.println(score > 60 ? "鸡哥":"不及格");

3.键盘录入功能

1.导包 import java.util.Scanner;

2.写一行代码得到键盘扫描对象 Scanner sc = new Scanner(System.in);

3.等待用户输入数据 int age = sc.nextInt(); String name = sc.next();

第三部分

1.分支结构

分支结构：if、switch

2.switch穿透性

定义：

如果代码执行到没有写break的case块，执行完后将直接进入下一个case块执行代码（而且不会进行任何匹配），直到遇到break才会跳出分支，这就是switch的穿透性。

3.随机数Random类

1.导包 import java.util.Random;

2.写一行代码得到随机数 Random r = new Random();

3.调用随机数的功能获取0~9的随机数 int number = r.nextInt(10);

第四部分

1.数组

静态初始化数组的定义

数据类型[ ] 数组名 = new 数据类型[ ]{元素1，元素2，元素3...}

动态初始化数组的定义

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

2.数组的遍历

for循环遍历：

int[] st = new int[]{1, 2, 3, 4, 5, 6, 7};
        for(int i = 0; i < st.length; i++){
            System.out.println(st[i]);
        }

foreach遍历：

int[] st = new int[]{1, 2, 3, 4, 5, 6, 7};
for (int item : st) {
            System.out.println(item);
        }

第四部分

1.方法

传值、重载

第五部分

1.面向对像

构造器

方便赋值

封装

什么方法就封装的什么类里

JavaBean

可以称为实体类，其对象可以用于在程序中封装数据

第六部分

1.String

string字符不可变

Stirng变量每次的修改其实都是产生并指向了新的字符串对象

原来的字符串对象都是没有改变的，所以称不可变字符串

2.字符串的比较

使用String提供的equlas方法

只关心内容一样就返回true

3.开发中什么时候用“==”比较数据

基本数据类型比较时使用

4.String常用API

5.集合

ArrayList list = new ArrayList(); 创建对象

list.add(); 添加数据

6.泛型

ArrayList<String> list = new ArrayList();

ArrayList<Integer> list = new ArrayList();

7.ArrayList集合常用方法

第七部分

1.static修饰成员变量

1.静态成员变量：有static修饰，属于类，加载一次，可以被共享访问

public static int onLineNumber = 161;

2.实例成员变量：无static修饰，属于每个对象

private String name;

private int age;

2.static修饰成员方法

和成员变量类似

3.static访问注意事项

静态方法只能访问静态的成员，不可以直接访问实例成员。

实例方法可以访问静态的成员，也可以访问实例成员。

静态方法中是不可以出现this关键字的。

4.static工具类

1.由于工具类无需创建对象所以把其构造器私有化会显得很专业

2.内部都是一些静态方法，每个方法完成一个功能

3.一次编写处处可用

5.static代码块

1.静态代码块

格式：static{}

特点：优先加载，需要使用static关键字修饰，随着类的加载而加载，自动触发，只执行一次

使用场景：在类加载的时候做一些静态数据初始化的操作，以便以后继续的使用

6.static单例设计模式

1.设计模式的定义

开发中经常遇到一些问题，一个问题通常有n种解决方法的，但其中肯定有一种解法是z，这个最优的解法被人总结出来了，称之为设计模式。

2.单例模式定义

可以跟保证系统的这个类永远只有一个实例，即一个类永远只能创建一个对象。

3.饿汉单例设计模式--设计步骤

1.定义一个类，把构造器私有

2.定义一个静态变量存储一个对象

代码：

# 定义一个单例类

public class SingleInstance{

# 定义一个静态变量存储一个对象即可：属于类，与类一起加载一次

public static SingleInstance instance = new SingleInstance();

# 单例必须私有构造器

private SingleInstance(){

System.out.println("创建了一个对象");

}

}

4.饿汉单例设计模式--设计步骤

1.定义一个类，把构造器私有

2.定义一个静态存储一个对象

3.提供一个返回单例对象的方法

代码：

# 定义一个单例类

class SingleInstance{

# 定义一个静态变量存储一个对象即可：属于类，与类一起加载一次

private static SingleInstance instance;

# 单例必须私有构造器

private SingleInstance(){}

# 必须提供一个方法返回一个单例对象

public static SingleInstance getInstance(){}

...

return ...;

}

7.继承

1.继承的作用与使用

使用：public class Student extends People{}

Student称为子类（派生类），People称为父类

作用：当子类继承父类后，就可以直接使用父类公共的属性和方法了

2.继承的特点

1.子类可以继承父类的属性和行为，但是子类不能继承父类的构造器

2.java是单继承模式：一个类只能继承一个直接父类

3.java不支持多继承、但是支持多层继承

4.java所有的类都是Object类的子类

3.在子类方法中访问满足：就近原则

先子类局部范围找

然后子类成员范围找

然后父类成员范围找，如果父类范围还没有找到则报错

4.注意

如果父类中出现重名的成员，会优先使用子类的成员

5.super关键字

格式：super.父类成员变量/方法

指定访问父类成员

6.方法重写

应用场景：当子类需要父类的功能，但父类的该功能不完全满足自己的需求时。、

子类可以重写父类中中的方法

7.子类构造器的特点

子类中所有的构造器默认都会先访问父类中无参的构造器，再执行自己

8.super（）调用父类构造器的作用

通过调用父类有参构造器来初始化继承来自父类的数据

第八部分

1.包

导包：import 包名.类名

2.权限修饰符

1.定义

用来控制一个成员能够被访问的范围

可以修饰成员变量，方法，构造器，内部类

2.权限修饰符的分类和具体作用范围

3.final

1.final关键的字作用

final关键字是最终的意思，可以修饰（类，方法，变量）

修饰类：表明该类是最终类，不能被继承

修饰方法：表明该方法是最终方法，不能被重写

修饰变量：表示该变量第一次赋值后，不能再次被赋值（有且仅赋值一次）

4.常量

1.常量的定义

常量是使用了public static final修饰的成员变量，必须有初始化值，而且执行的过程中其值不能被改变。

2.常量的作用

可以用于做系统的配置信息，方便程序的维护，同时也能提高可读性。

3.命名规范

英文单词全部大写，多个单词要用下划线连接起来

4.常量的执行原理

在编译阶段会进行“宏替换”，把使用常量的的地方全部替换成真是的字面量

5.枚举

1.枚举的定义

枚举是java中的一种特殊的类

2.枚举的作用

做信息的标志和信息的分类

3.定义枚举的格式

修饰符 enum 枚举名称{

第一行都是罗列枚举实例的名称。（建议全部大写）

}

4.枚举的特征

1.枚举类都是最终类，不能被继承

2.构造器都是私有的，对外不能创建对象

3.枚举类的第一行默认都是罗列枚举对象的名称的

4.枚举类相当于多例模式

5.枚举的使用

枚举类型做信息标志和分类

代码可读性好，入参约束严谨，代码优雅，是最好的信息分类技术

表示具体

6.抽象类

在java中abstract是抽象的意思，可以修饰类、成员方法

1.格式

修饰符 abstract class 类名{

修饰符 abstract 返回值类型方法名称（形参列表）；

}

2.注意事项

抽象方法只有方法签名，不能声明方法体

一个类中如果定义了抽象方法，这个类必须声明称抽象类，否则报错

3.抽象的使用场景

抽象类可以理解成不完整的设计图，一般作为父类，让子类来继承

4.注意事项

一个类继承了抽象类必须重写完抽象类的全部方法

不能用abstract修饰变量、代码块、构造器

最重要的特征：得到了抽像方法，失去了创建对象的能力（有得有失）

5.模板方法模式

Test06

7.接口

1.接口的定义格式

接口用关键字interface来定义

public interface 接口名{

// 常量

// 抽象方法

}

2.注意事项

1.接口体现规范思想，规范默认都是公开的，所以代码层面，public static final 可以省略不写，public abstract 也可以省略不写。

2.接口不能创建对象

3.一个类实现多个接口，多个接口中有同学样的静态方法不冲突（因为接口静态犯法只能由接口调用）

4.一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认使用父类的

5.一个类实现了多个接口，多个接口中存在同名方法，不冲突，这个类重写该方法即可

6.一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承

3.接口的使用

接口是用来被类实现的，实现接口的类称为实现类。实现类可理解成所谓的子类。

使用格式：

修饰符 class 实现类 implements 接口1，接口2，接口3，...{}

实现的关键字是 implements

4.基本小结

类和类的关系：单继承

类和接口的关系：多实现。

接口和接口的关系：多继承，一个接口可以同时集成多个接口

5.新增方法

1.默认方法，必须default修饰，默认用public

2.静态方法，使用static修饰，默认用public

第九部分

1.多态

1.多态的定义

同类型的对象，执行同一个行为，会表现出不同的行为特征

2.多态的常见形式

父类类型对象名称 = new 子类构造器

接口对象名称 = new 实现类构造器

3.多态成员访问特点

方法调用：编译看左边，运行看右边

变量调用：编译看左边，运行也看左边（多态侧重行为多态）

4.多态的前提

有继承/实现关系；有父类引用指向子类对象；有方法重写。

2.匿名内部类

1.内部类就是定义在一个类里面的类，里面的类可以理解成（寄生），外部类可以理解成（宿

2.本质上是一个没有名字的局部内部类，定义在方法中，代码块，等。

1.匿名内部类作用

方创建子类对象，最终目的为了简化代码编写

3.匿名内部类的格式

Employee a = new Employee(){

public void work(){

}

}；

a.work（）；

3.常用API（Object）

9.Object的toString方法：

public String toString() 默认返回当前对象在堆内存中的地址信息：类的权限名@内存地址

让子类重写，以便返回子类对象的内容

10.Object的equals方法：

比较当前对象与一个对象的地址是否相同

4.StirngBuilder

1.StringBuilder定义

StringBuilder是一个可变的字符串类，我们可以把它看成是一个对象容器

2.StringBuilder作用

提高字符串的操作效率，如拼接，修改,最终目是要恢复成String类型

3.构造器

StringBuilder常用方法

4.用法

1.append添加

2.reverse反转

3.length返回字符串长度

System.out.println(sb1.length());

4.将StringBuilder类型转换成String

String rs = StringBuilder对象.toString()

5.Math类常用方法

6.System类的常用方法

7.BingDecimal常用API

1.创建对象BigDecimal 封装浮点型数据（最好的方式是调用方法）

public static BigDecimal valueOf(double val): 包装浮点数为BigDecimal对象

第十部分

1.Date类概述

1.使用方法

形式1：日期对象

Date d = new Date();

System.out.println(d);

形式2：时间毫秒值

long time = d.getTime();

System.out.println(time);

2.SimpleDateFormat解析字符串时间成为日期对象

3.Calendar常用方法

4.包装类

1.包装类的定义

包装类就是8种基本数据类型对应的引用类型

5.正则表达式

1.正则表达式的定义

正则表达式可以用一些规定的字符来制定规则，并用来校验格式的合法性

实例：校验qq号码，必须全部数字 6 - 20位

package com.dzxy.hello;

public class RegexDemo1 {
    public static void main(String[] args) {
        System.out.println(checkQQ1("342254235454"));
        System.out.println(checkQQ1("342254fg5454"));
        System.out.println(checkQQ1("342254dfgf5454"));
        System.out.println(checkQQ1("34222345454"));
    }



    static boolean checkQQ1(String qq){
        return qq != null && qq.matches("\\d{6,20}");
    }
}

2.正则表达式的匹配规则

字符串对象提供了匹配正则表达式规则的API

sout("a".matches("[abc]"));

6.Arrays类

1.定义

专门用来操作数组

2.常用API

第十一部分

1.集合

1.Collection集合的体系

1.ArrayList（有序可重复有索引）

Collection list = new ArrayList();

2.HashSet（无序不重复无索引）

Collection list = new HashSet();

2.集合对于泛型的支持

集合都是支持泛型的，可以在编译阶段约束集合只能操作某种数据类型

Collection<String> list = new ArrayList();

注意：集合和泛型都只能支持引用类型，不支持基本数据类型，所以集合中存储的元素都认为是对象。

3.Collection集合常用API

Collection<String> list = new ArrayList();

list.add();添加元素

list.clear();清空集合

list.isEmpty();判断是否为空

list.contains("123");是否包含123

list.remove("java");删除第一个与java匹配的元素