Javase知识点

2024-03-05 17:37:20   13  举报





AI智能生成

Javase是Java平台的标准版，它提供了一套丰富的API供开发者使用。Javase的知识点包括基本语法、面向对象编程、异常处理、集合框架、多线程、网络编程、IO流等。其中，基本语法包括数据类型、运算符、流程控制语句等；面向对象编程包括类、对象、继承、封装、多态等；异常处理包括try-catch-finally语句块、自定义异常等；集合框架包括List、Set、Map等常用数据结构；多线程包括线程的创建、同步与互斥等；网络编程包括Socket编程和HTTP协议；IO流包括字节流和字符流等。掌握这些知识点可以帮助开发者更好地理解和运用Java语言进行软件开发。

java

八股文

思维导图

作者其他创作

大纲/内容

java对象和属性

线程

创建线程的方法

继承Thread类

步骤：
1.创建继承Thread类子类
2.重写run()方法
3.创建子类对象
4.调用start()方法

实现runnable接口

步骤：
1.创建实现runnable接口的实现类
2.重写run()方法
3.创建子类对象
4.把子类对象作为参数传入Thread类的构造器中，得到Thread类对象
5.用Thread类对象调用start()方法

实现callable接口

步骤：
1.创建实现callable接口的实现类
2.重写call()方法
3.创建实现类对象
4.把实现类对象作为参数传入到futuretask的构造器中，得到futuretask的对象
5.把futuretask对象作为参数传入Thread类的构造器中
6.Thread对象调用start()方法
7.futuretask对象调用get()得到call()方法的返回值

线程池

步骤：
1.提供指定线程数的线程池
2.设置线程池属性
3.执行指定线程操作，需要提供runnable接口实现类对象或者callable接口实现类对象
4.关闭线程池

好处：
1.减少资源消耗
2.提高效应速度
3.便于资源管理

线程安全问题

同步代码块

格式：
synchronozed(同步监视器){
同步代码
}

操作共享数据即为同步代码

同步监视器：俗称锁，任何一个类的对象都可以充当，多个线程共用一个同步监视器

共享数据：多个线程共同操作的数据

同步方法

同步方法仍然涉及同步监视器，只是我们没有显示的声明

好处解决了线程安全问题

坏处：效率低，操作同步代码时，只能有一个线程参与，其他线程只能等待，相当于单线程

非静态的同步监视器是this
静态的同步监视器是类本身

lock()

创建Reentranlock()对象
1.调用lock方法
2.关闭：调用unLock（）方法

出现线程安全的原因

有共享数据，并且当一个线程操作共享数据时，另一个线程也要操作线程中的共享数据

线程通信

指多个线程协调运行的过程

wait()

一旦执行线程就会进入阻塞状态，并且释放同步监视器

notify()

一旦执行就会唤醒wait的一个线程，如果有多个线程就唤醒优先级高的线程

notifyAll()

一旦执行就会唤醒所有wait的线程

三个方法都必须使用在同步代码块或者同步方法中，lock也不能用

这三个方法的调用者都必须是同步监视器调用

三个方法都是定义在object中的，便于所有对象作为同步监视器时都能够调用

wait()和sleep()有什么异同（面试题）

相同点

都能够让线程进入阻塞状态

不同点

1.wait()是定义在oject类中的，而sleep是定义在Thread类中的

2.wait()只能在同步代码块或者同步方法中使用，sleep()可以在任何位置使用

3.两者都在同步代码块或者同步方法中使用的时候，wait()会释放锁，sleep()不会释放锁

继承

用已存在的类的定义作为新的类的创建的基石
新的类可以增加新的数据或功能
也可以用父类的功能
提高了代码的复用性

子类可以继承父类的非static的属性和方法

子类继承父类，仍认为获得了父类的private的属性和方法
只是由于封装性的影响而无法直接调用父类的结构而已

子类可以有自己新的属性和方法，即子类对父类的扩展

子类可以重写父类的方法

好处

减少代码冗余

便于扩展功能

为多态的实现，提供了前提

抽象abstract

1.可以修饰类、方法

1.修饰类：抽象类

1.此类不可以被实例化

2.抽象类一定有构造方法，便于子类实例化时候调用

3.开发中通常会有子类，让子类去完成相应的操作

2.修饰方法：抽象方法

1.抽象方法只有方法声明，没有方法体

2.有抽象方法的类一定是抽象类，反之，抽象类中不一定由抽象方法

3.子类重写了所有的抽象方法，就可以实例化

4.若子类没有重写所有的抽象方法，则仍未抽象类

abstract不能用来修饰属性、构造器等结构

abstract不能用来修饰私有方法、final的方法、final的类

接口

1.使用interface来定义

2.接口与类是同级别的关系

3.如何定义接口：定义接口中的成员

1.jdk7以前只能定义全局常量和抽象方法方法

1，全局常量

public static final(可以省略不写，系统会默认加上)

2.抽象方法

public abstract(也可以省略不写)

2.jdk8出了jdk中的两种，新增默认方法、静态方法

1.静态方法，通过接口.方法进行调用

2.通过类对象调用接口中的默认方法

如果实现类的父类和接口方法同名同参数，则优先调用父类中的方法（类优先原则）

如果实现类实现了多个接口，接口中有相同的方法，则会报错

4.接口不能定义构造器，所以不能初始化

5.接口通过让类实现（implement）的方法来使用

1.如果类实现了接口中的所有方法，则可以实例化

2.若类没有实现接口中的所有方法，则仍为抽象类

6.类可以实现多个接口，弥补了类不能多继承的缺点

7.接口继承接口，而且可以多继承

8.接口的使用

1.接口的使用也满足多态

2.接口实际是定义了一种规范

3.开发中尽量面对接口编程

重写

重写的方法与被重写的方法必须同名同参数

权限修饰符不小于（大于或者等于）被重写的方法

子类不能重写父类的private方法

返回值类型：
1.若父类返回值类型为void则重写也需要是void
2.若父类返回值为A类型则重写也需要是A类型
3.若返回值类型为基本数据类型（如double），则子类也必须是基本数据类型

只有非static的方法才考虑重写

重写的方法抛出的异常不能大于被重写的方法抛出的异常

比如多态，在编译时候父类抛出的异常为ioException
编译可以通过，但在执行期间实际运行的是子类对象的方法
子类抛出的是Exception会导致运行时报错

代码块

1.作用：用于初始化类、对象

2.如果有修饰，只能用static修饰

3.分类

1.静态代码块

1.随着类的加载而加载，而且只执行一次

2.内部可以有输出语句

3.初始化类的信息

4.如果有多个静态代码块，则按照声明的先后顺序执行

5.静态代码块只能调用静态属性和方法，不能调用非静态结构

6.静态代码块优于非静态代码块执行

2.非静态代码块

1.内部可以有输出语句

2.随着对象的创建而执行

3.可以在创建对象时，对对象属性等进行初始化

对属性赋值的位置

1.默认初始化

2.显示初始化

3.代码块

4.构造器

5.有了对象，通过对象.属性，对象.方法进行赋值

执行顺序：1-->2/3-->4-->5

2,3看声明的先后顺序

内部类

一个类A声明在另一个类B中，称为内部类

成员内部类（静态、非静态）

作为类的成员

调用外部类的结构

可以被static修饰

可以被4中不同的权限修饰

作为类

类的内部可以定义属性、方法、构造器等

可以被final修饰

可以被abstract修饰

局部内部类（方法、代码块、构造器内）

成员内部类

异常

异常处理：抓抛模型

过程一：抛

程序运行过程中出现异常，就会生成异常对象，并且将对象抛出

异常的产生

1.系统自动生成一个异常对象

2.手动抛出一个异常对象,并抛出：throw+异常类型

异常处理的方式

1.try -catch-finally

1.解决的是编译时产生的异常，将异常延迟到运行时
异常处理一般考虑的是编译时异常，不考虑运行时异常

2.try将可能出现异常的代码包起来，catch在出现异常时进行匹配类型

3.异常一旦匹配到某个catch时找到对象的异常类型，就会进入catch中处理异常
异常处理完成就会跳出try-catch结构，继续执行后面的代码

4.catch异常类型如果没有子父类继承关系，则谁先后无影响
若有子父类关系，则必须要子类在前，否则报错

5.常用异常处理方式：1.string getmessage 2.e.printstacktrace

6.在try中声明的变量，出了try结构之后将不再再被调用

子主题

2.throws

类和对象

类只能调用静态属性和静态方法，不能调用非静态属性和方法

对象可以调用静态属性和静态方法，也可以调用非静态舒心和非静态方法

比较器

comparable

1.像String、包装类等都已经实现了comparable接口，重写了compareto方法，给出了两个对象比较的方法

2.像String、包装类重写了compareto方法后，进行了从小到大排序

3.compareto（object）方法的重写规则

1.如果当前this对象大于object对象，返回正整数

2.如果当前this对象小于object对象，返回负整数

3.如果当前this等于对象object对象，返回0

4.对于自定义类，如果需要进行排序，需要在类中实现comparable接口实现compareto方法，在方法内定义如何排序

comparator

1.背景

1.当元素的类型没有没有实现comparable接口，没有实现compareto方法，
或者实现了comparable接口，但排序方式不适用，就考虑适用comparator对象排序

2.重写compare（object o1 , object o2）,比较两者的大小

1.如果返回0，o1等于o2

2.如果返回1，o1大于o2

3.如果返回-1，o1小于o2

comparable和comparator比较

1.comparable接口一旦一定，保证comparable接口实现类对象在任何位置都可以调用

2.comparator只是临时性的比较

关键字

this

是自身的一个对象，代表对象本身
（哪个对象调用就是哪个对象的引用类型）

1.普通引用，只想对象本身

2.形参和成员变量重名时，可以用来区分

3.引用本类构造函数

调用语句必须放在构造函数的第一条

super

指向自己最近父类的一个指针

1.直接引用父类的成员

2.当子类和父类的属性或方法名相同时可以用来区分

3.可以直接调用父类的构造器

调用语句必须放在构造函数的第一条

是的每个构造函数最多也只能调用一个构造函数

this和super的区别

本质上this是指向对象本身的一个指针
super是java的一个关键字

this和super不能同时出现在一个构造器中

因为this必然会调用其他构造器，而其他构造器也必然辉有super()的存在

this和super都只能在非static的情况下使用

static

创建独立于具体对象的域变量和方法，独立于该类任何一个对象
因此，即使没有创建对象也可以调用属性和方法

可以优化程序性能

因为static只在类加载的时候加载，并且只会加载一次

static修饰属性：静态属性

实例变量

创建多个对象，每个对象都拥有自己的一套非静态属性，当修改其中一个对象的属性，其他对象相应的属性不会被修改

静态变量

创建多个对象，多个对象共享一套静态属性。当通过其中一个对象修改静态属性，其他对象调用的这个非静态属性也会被修改

随着类的加载而加载，可以通过类.属性进行调用

静态属性的加载早于对象的创建

类只会加载一次，所以静态属性只会加载一次，存在方法区的静态域里

static修饰方法

1.通过类.静态方法的方式进行调用

2.静态方法中只能调用静态的属性和方法

3.静态方法可以通过类调用，也可以通过对象调用
类不能调用非静态方法

4.静态方法中没有this和super

开发中

属性是被多个对象共享的，不随对象改变而改变可以选择静态属性和静态方法

可以修饰

属性

方法

构造器

代码块

final

1.可以修饰的结构：类、方法、属性

修饰类

表示类不可被继承

如：String类

修饰方法

表示方法不可被重写

如object类中的getclass()方法

修饰变量，也成为常量

修饰属性

可以考虑赋值的位置有

1.显示初始化

2.代码块初始化

3.构造器初始化

修饰局部变量

尤其是给形参赋值时，表明形参是一个常量了，方法内只能调用不能重新赋值

final修饰的属性不可以在方法内进行赋值，因为创建对象的时候确定属性的值了，但是那时候还没有调用方法

枚举类

枚举类：1.类的对象有限个、而且是确定的
2.如果需要定义一组常量时，强烈建议使用枚举类
3..如果枚举类只有一个对象，则可以作为单例模式的实现

jdk5.0之前

自定义枚举类

1.私有化构造器（可以保证外部不能创建对象）

2.可以定义属性，属性私有化

1.对属性赋值，可以有几种方式

1.显性赋值：所有对象的属性值都相同

2.构造器中赋值:每个对象拥有自己的独立属性值

3.代码块赋值

3.可以提供get()、tostring()方法供外部调用属性使用

具体实现代码：

jdk5.0以后

使用enum关键字定义枚举类

1.开始就需要提供枚举类的对象，多个对象之间用,号隔开，最后一个用;

2.定义私有化属性（与上面一样）

3.可以提供get()方法，通常不需要重写tostring()，因为enum是继承与Enum类的，不是object

Enum类的常用方法

1.tostring():输出对象名

2.vlues()：所有的对象

3.vlueof(String name)：查找指定名称的对象

enum关键字定义的枚举类继承接口

1.方式一：直接implement接口，实现抽象方法（这样的继承，每个对象实现方法中的内容都相同）

2.方式二：每个对象都重写接口中的抽象方法，这样的对象重写方法中的内容就可以不一样

jdk8之前

simpledateformat

解析:2022-11-24 01-38-02

格式化:Thu Nov 24 01:38:02 CST 2022

java.util.date

java.sql.date

new java.sql.date(Long date):得到时间格式为（2019-01-03）

java.util.date()和java.sql.date()的转换：new java.sql.date(date.gettime()):相当于把java.util.date()的gettime()获得的时间戳作为参数放进去

Date():无参构造器，可以获取当前系统时间（Thu Nov 24 13:16:39 CST 2022）

Date(long date):设置时间（输出结果为：Fri Jan 02 19:07:36 CST 1970）

gettime():获取1970/01/01到现在的毫秒数(1669266999957)

toString():把时间转化为这种格式（Wed Nov 23 16:41:53 CST 2022）

calendar

get()(calendar.get(Calendar.DAY_OF_MONTH);)

set():设置时间，无返回值，可变

add()

gettime():Mon Nov 28 13:27:05 CST 2022

settime():把当前时间转换为日历类时间

时间API

JDK8新增

localdatetime

of():设置指定时间，没有偏移量:2022-11-24T11:11:25

通过LocalDate类调用

now()获取当前时间、当前日期、当前时间日期:2022-11-24T13:28:23.902

with():设置时间，有返回值，体现不可变性:2022-01-22T13:28:23.902

通过localdatetime对象调用

plus():增减时间:2022-12-16T13:28:23.902

getxxx():获取时间日期:24

localdate

与localdatetime相同

loacatime

与localdatetime相同

Instance

now():获取本初子午线上的时间,输出格式为：2022-11-24T04:47:50.788Z

toEpochMilli(156456456486L):给定时间毫秒数获取时间，输出格式为：1974-12-16T20:07:36.486Z

toEpochMilli()：获取从1970年到现在的时间毫秒数，输出格式为：1669264888725

atoffset(zoneoffset.horse()):加上时间偏移量偏移量

DatetimeFormat(需要格式化和解析，可替代simpledateformat)

方式一，预定义：dateTimeFormatter.format(LocalDateTime.now());// 2022-11-24T13:42:47.119

方式二：dateTimeFormatter1.format(LocalDateTime.now());//2022年11月24日星期四

（常用）方式三：自定义：DateTimeFormatter.ofPattern("yyyy-MM-dd hh-mm-ss");

格式化：2022-11-24 01-58-59

解析：//{MilliOfSecond=0, MicroOfSecond=0, MinuteOfHour=58, NanoOfSecond=0, SecondOfMinute=59, HourOfAmPm=1},ISO resolved to 2022-11-24

 收藏

立即使用

Javase知识点

itsrea

职业：暂无

去主页





0 条评论

下一页

为你推荐

查看更多

