java部分基础知识

最新推荐文章于 2024-07-01 20:57:37 发布

J-J♃

最新推荐文章于 2024-07-01 20:57:37 发布

阅读量506

点赞数

分类专栏： java基础知识学习文章标签： java 编程语言

本文链接：https://blog.csdn.net/JJ_Jxian/article/details/106751249

版权

java基础知识学习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1、比特（bit）和字节（byte）

一个字节有八个比特构成

文档注释的注释内容可以被JDK提供的工具javadoc解析，生成一套以网页文件形式提现的该程序的说明文档

3、Java的数据类型

包括基本数据类型和引用数据类型（类calss（String），接口interface，数组array）

自动类型提升：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果会自动提升为容量大的

byte 、char、 short < int < long < float < double 容量指：数据类型的取值范围

byte、char和short之间做运算结果为int 类型

4、String（引用数据类型）和8种基本数据类型做运算为，连接运算+

5、java运算符

算术运算符：+（正）、-、±*/、%、++、–、+（字符串连接）

赋值运算符：=、+=、-=、*=、/=、%=

比较运算符：==、！=、<、>、<=、>=、instanceof（检查是否是类的对象）

逻辑运算符：&逻辑与（有一个false就为flase）、&&短路与（有一个false就为flase）、|逻辑或、||短路或、!逻辑非、^逻辑异或

只能操作boolean类型的变量

位运算符：<<、>>、>>>（无符号右移，被移位二进制最高位不论是0或者是1，空缺位都用0补）、&、|、^、~（取反）；；；二进制运算

三元运算符：（条件表达式）？表达式1：表达式2；

运算符的优先级：

在这里插入图片描述

&与&&的区别同|与||

a&b：当a=true时，执行b，，当a=false时，执行b。

a&&b：当a=true时，执行b，，当a=false时，不执行后边的操作

6、switch-case

switch结构中的表达式（），只能是这6种数据类型之一：byte、shot、char、int、枚举、String类型

凡是可以使用switch-case的结构，都可以转换为if-else。反之，不成立。
如果都可以使用（switch中的情况不太多时），优先选择switch-case，因为sc的执行效率稍高

7、break和continue的区别

	使用范围	循环中的作用
break	switch-case 和循环结构	结束当前循环
continue	循环结构	结当次循环

break：跳出离他最近的一层循环

配合标签使用：


	label:for(int i =0; i<10; i++){
        
        for(int j =0; j<10; j++){
            break label;
        } 
    }

10、二维数组的正确写法

		int [][] arr = new int[5][3];
        int [][] arr2 = new int[5][];
        int [] arr4[] = new int[5][];
        int [][] arr3 = new int[][]{{1,2,3},{1,2,3}};
        int [][] arr5 ={{1,2,3},{1,2,3}};

11、java的类

类的成员：

属性=成员变量=field=域、字段

方法=成员方法=函数=method

构造器

代码块

内部类

局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

在这里插入图片描述

12、javc内存解析

堆：存放对象实例

栈：存储局部变量

方法区：类信息、常量、静态变量、即时编译器编译后的代码

13、继承性的好处

子类继承父类，并且子类会获取父类中的所有属性和方法。由于封装性的原因，父类有private修饰的属性和方法，只不过是不能调用，而不是没有继承到。
子类继承父类之后可以有自己的特有属性和方法：可以实现功能的扩展。

单继承

减少了代码的冗余，提高了代码的复用性
便于功能的拓展
3.为多态性提供前提

14、java的方法重写

方法的声明：权限修饰符返回值类型方法名（参数列表） throws 异常的类型 {

方法体

}

1）子类重写的方法的方法名和参数列表与父类的方法名和参数列表相同

2）子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符

		>：子类不能重写父类中声明为private权限的方法

3）返回值类型

	1. 父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
	2. 父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
    3. 父类被重写的方法的返回值类型是基本数据类型，则子类重写的方法的返回值类型必须是相同的基本数据类型

4）子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型

父类static类型的方法不可以被重写

14.2、java的重载overload

重载是在一个类里边，方法名相同而参数不同。返回类型可以相同也可以不同，每个重载的方法，都必须有一个独一无二的参数类型列表

被重载的方法可以改变返回类型
被重载的方法可以改变访问修饰符
被重载的方法可以声明新的，或者更广的检查异常
方法能够在同一个类中或者在一个子类中被重载
无法以返回值类型作为重载函数的区分标准

15、java的多态性

没有继承就没有多态性

对象的多态性：父类的引用指向子类的对象

Person p = new Man（）；

编译时看左边，运行时看右边。

只是用于方法，不适用于属性

16、java的static关键字

static可以修饰：属性、方法、代码块、内部类

静态方法中只能调用静态方法

静态方法中不能使用this、super关键字

17、java的final关键字

修饰类，不能再被继承

修饰方法，不能再被重写

修饰属性，不能再被更改，初始化：显示初始化，代码块，构造器中

18、java的abstract关键字

修饰类：该类不能再被实例化；抽象类一定有构造器，便于子类实例化时使用；开发中一定会提供抽象类的子类

修饰方法：只有方法的声明没有方法体；一般用于接口中

19、java的interface关键字（接口）

接口中可以定义：全局常量，抽象方法，静态方法，默认方法（都是public的）。（java9中可以定义私有方法private）

接口中的静态方法只能由接口调用，

实现类可以调用接口中的默认方法，也可以被重写

20、java的异常

异常分为两种

error：java虚拟机无法解决的严重问题。如OOM和StackOverflowError

exception：编译时异常和运行时异常

在这里插入图片描述

异常处理的两种方式：try-catch-finally 和throws

try{

//可能出现异常的代码

}catch（）{

//处理异常的方式1

}catch（异常类型1 变量名1）{

//处理异常的方式2

}catch（异常类型1 变量名1）{

//处理异常的方式3

}finally{

//一定会执行的代码

}

手动抛出异常：throw new

异常的捕获规则：

异常是指程序运行时（非编译）所发生的非正常情况或错误，当程序违反了语音规则，jvm就会将出现的错误表示一个异常抛出。

异常也是java 的对象，定义了基类 java。lang。throwable作为异常父类。这些异常类又包括error和exception。两大类

error类异常主要是运行时逻辑错误导致，一个正确程序中是不应该出现error的。当出现error一般jvm会终止。

exception表示可恢复异常，包括检查异常和运行时异常。检查异常是最常见异常比如 io异常sql异常，都发生在编译阶段。这类通过try、catch捕捉

而运行时异常，编译器没有强制对其进行捕捉和处理。一般都会把异常向上抛出，直到遇到处理代码位置，若没有处理块就会抛到最上层，多线程用thread。run（）抛出，单线程用main（）抛出。常见的运行异常包括空指针异常类型转换异常数组月结异常数组存储异常缓冲区溢出异常算术异常等，

21、java的String类

		String a = "javaee";
		String b = "hadoop"
		String c = "javaeehadoop"
        String d = "javaee"+"hadoop";
		String e = a+"hadoop";
		String f = a+b;
		
		System.out.println(d==c);//true，常量与常量之间的拼接都是在常量池中
		System.out.println(e==c);//false，有变量参与的都视为new，在堆中创建新的对象
        System.out.println(f==c);//false
		System.out.println(e==f);//false

22、String、StringBuilder和StringBuffer

StringBuilder：线程不安全的，效率高

StringBuffer：线程安全的，效率低

23、java8的新日期和时间

LocalDate、LocalTime、LocalDateTime

        //指定格式
		LocalDateTime now1 = LocalDateTime.now();
        DateTimeFormatter dtf = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM);
        String format = dtf.format(now1);
        System.out.println(format);//2019-12-4 15:26:32
		//自定义格式
        DateTimeFormatter dtf2 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String format1 = dtf2.format(now1);
        System.out.println(format1);//2019-12-04 15:26:32

24、java的枚举类

enum：当定义一组常量时，强烈建议使用枚举类

25、java的注解（annotation）

框架=注解+反射+设计模式

在这里插入图片描述

信息处理流程：反射

jdk提工的元注解：

1. Retention（指定生命周期）、
2. Target、（用于修饰什么类型（类，方法，...））
3. Documented、（javadoc 用于生成文档）
4. Inherited、（具有继承性）

26、java的对象序列化

对象序列化机制：允许把内存中的java对象转换成与平台无关的二进制流，从而允许把这种二进制流持久化的保存到次磁盘上，或通过网络将这种二进制流传输到另一个网络节点，当其他程序获取了这种二进制流，就可以恢复成原来的java对象

27、java的反射机制

被视为动态语言的关键，允许程序在执行期间动态的获取任何类的内部信息

java是静态语言（准动态语言）

1）理解Class类并获取Class实例

2）类的加载与ClassLoader的理解

3）创建运行时类的对象

calss ReflectTest
	//1
	Class clazz = Person.class;
    //2
    Person p = new Person();   
	Class clazz1 = p.getClass();
    //3
	Class clazz2 = class.forName(String classPath);
	//4
	ClassLoader classLoader = ReflectTest.class.getClassLoader();
	Class calclassLoader.loadClass(String classPath);
	
}

4）获取运行时类的完整结构

5）调用运行时类的指定

6）反射的应用：动态代理

代理模式：使用一个代理将对象包装起来，然后用该代理对象取代原始对象，任何对原始对象的调用都要通过代理。代理对象决定是否以及合适将方法调用转到原始方法

动态代理：指客户端通过代理类来调用其他对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象

28、java的Lambda表达式（jdk1.8）

Lambda是一个匿名函数，我们可以吧Lambda表达式理解为是一段可以传递的代码（将代码向数据一样进行传递）。使用它可以写出更简洁、更灵活的代码、

->；Lambda操作符。左边是形参列表（其实就是借口中的抽象方法的形参列表），右边：Lambda体（重写的抽象方法的方法体）

Lambda的使用：

无参无返回值： Runnable r1 = () ->{System.out.println(“nihao”);};
有一个参数没有返回值：Consumer<String> con = (String str ) ->{System.out.println(str);}；
数据类型可以省略，因为可以由编译器推断得出，称为“类型推断”：Consumer<String> con = （str）->{System.out.println(str);};
Lambda若只需要一个参数时，参数的小括号可以省略：Consumer<String> con = str ->{System.out.println(str);};
Lambda需要两个或以上的参数，多条执行语句，并且可以有返回值：Comparator<Integer> com = （x,y） ->{System.out.println(“实现函数式接口方法！”); return Integer.compare（x，y）}；
当Lambda：体只有一条语句时，return与大括号若有，都可以省略：Comparator<Integer> com = （x，y）->Integer.compare（x，y）；

	//1. 无参无返回值： 
    Runnable r1 = () ->{System.out.println("nihao");};
	//2. 有一个参数没有返回值：
    Consumer<String> con = (String str ) ->{System.out.println(str);}；
	//3. 数据类型可以省略，因为可以由编译器推断得出，称为“类型推断”：
    Consumer<String> con = (str) ->{System.out.println(str);};
	//4. Lambda若只需要一个参数时，参数的小括号可以省略：
    Consumer<String> con =  str ->{System.out.println(str);};
	//5. Lambda需要两个或以上的参数，多条执行语句，并且可以有返回值：
    Comparator<Integer> com = (x,y) ->{
        System.out.println("实现函数式接口方法！"); 
        return Integer.compare（x，y）
    };
	//6. 当Lambda：体只有一条语句时，return与大括号若有，都可以省略：
    Comparator<Integer> com = (x，y)->Integer.compare(x，y);

Lambda表达式的本质：作为接口的实例

29、java的内置函数式接口

函数式接口	参数类型	返回类型	用途
Consumer 消费型接口	T	void	对类型为T的对象应用操作，包括方法：void accept（T t）
Supplier 供给型接口	无	T	返回类型为T的独享，包含方法：T get（）
Function<T,R> 函数型接口	T	R	对类型为T的对象应用操作，并返回结果。结果是R类型的对象。包含方法：R apply（T t）
Predicate 断定型接口	T	boolean	确定类型为T的对象是否满足某约束，并返回boolean值。包含方法：boolean test（T t）

在这里插入图片描述

30、java的方法引用

当要传递给Lambda体的操作，已经有实现的方法了，就可以使用方法引用。。本质上就是Lambda表达式

使用：类（对象）：：方法名

对象：：非静态方法
类：：静态方法
类：：非静态方法

31、java的Stream API

集合讲的是数据，Stream讲的是计算！

注意：

Stream 自己不会存储元素。
Stream不会改变源对象。相反，他们会返回一个持有结果的新Sream
Stream操作时延迟执行的。这意味着他们会等到需要结果的时候才执行。

创建Sream的方式

1）通过集合

default Stream<E> stream():返回一个顺序流

Stream<E> stream = 集合.stream（）；

default Stream<E> parallelStream（）：返回一个并行流

Stream<E> parallelStream = 集合.parallelStream（）；

2）通过数组

调用Arrays类的static <T> Stream<T> Stream（T[] array）：返回一个流

Arrays.Stream（arr）；

3）通过Stream的of（）

Stream<Integer> stream = Stream.of(1,2,3,4,5);

4）创建无限流

迭代

public static<T> Stream<T> iterate(Final T seed,Final unaryOperator<T> f)

生成

public static<T> Stream<T> generate(Supplier<T> s)

Stream的中间操作（筛选与切片）

        List<Employee> employees = Employee.getEmployees();
        Stream<Employee> stream = employees.stream();
        //filter(Predicate p) --接收Lambda，从流中排出某些元素
        stream.filter(e -> e.getSalay() > 10000).forEach(System.out::println);
        //limit（n）截断流，使其元素不超过给定数量
        employees.stream().limit(3).forEach(System.out::println);
        //skip(n) --跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流。与limit（n）互补
        employees.stream().skip(3).forEach(System.out::println);
        //distinct()--筛选，通过流所生成元素的hashCode（）和equals（）去除重复元素

Stream的映射

map(Function f)–接收一个函数作为参数，将元素转换成其他形式或提供信息，该函数会被应用到每一个元素上，并将其映射成一个新的元素

flatMap（Function f）–接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

Stream的排序

sorted（）：产生一个新流，其中按照自然排序

sorted（Comparator com）：产生一个新流，其中按比较器顺序排序

Sream的终止操作

allMatch（Predicate p）：检查是否匹配所有元素

anyMatch（Predicate p）：检查是否有匹配元素

noneMatch（Predicate p）：检查是否没有匹配的元素

findFirst（）：返回第一个元素

findAny（）：返回当前流中的任意元素

max（Comparator c）：返回流中的最大值

min（Comparator c）：返回流中的最小值

forEach（Consumer c）：内部迭代

reduce（T identity，BinaryOperator ）：可以将流中的元素结合起来，得到一个值。返回T

reduce（BinaryOperator ）：可以将流中元素反复结合起来，得到一个值，返回Optional<T>

collect（Collector c）：将流转换为其他形式。接收一个Coolector接口的实现，用于给Stream中元素做汇总的方法。就是用一个List，Set，Map接收

32、java的Optional类

Optional<T>类（java.util.Optional）是一个容器类，他可以保存类型T的值，代表这个值存在，或者仅仅保存null，表示这个值不存在。原来用null表示一个值不存在，现在Opyional可以更好的表达这个概念，并且可以避免空指针异常。

创建Optional类：

Optional.of（T t）：创建一个Optional实例，t必须非空。

Optional.empty（）：创建一个空的Optional实例。

Optional.ofNullable（T t）：t可以为null。

判断Optional：容器中是否包含对象：

boolean isPresent（）：判断是否包含对象

void ifPresent（Consumer<？ super T> consumer）：如果有值，就执行Consumer接口的实现代码，并且该值会作为参数给它。

获取Optional容器的对象：

T get（）；如果调用对象包含值，返回该值，否则抛出异常

T orElse（T other）：如果有值则将其返回，否则返回指定的other对象。

t orElseGet（Supplier<? expends T> other）：如果有值则将其返回，否则返回由Supplier接口实现提供的对象

T orElseThrow（Supplier<? expends T> exceptionSupplier）：如果有值则将其返回，否则抛出由Supplier接口实现提供的异常。

33、java14的instanceof改动

//14之前

if( obj instanceof String ){
    String str = (String) obj;
    str.contains(..);
}

//14
if( obj instanceof String str ){
    str.contains(..);
}

34、java14对于NullPointerException的更改

//在虚拟机参数配置中开启
-XX:+ShowCodeDetailsInExceptionMessages

35、java14中新增Record

当你用record 声明一个类时，该类将自动拥有以下功能： 
	 获取成员变量的简单方法，以上面代码为例 name() 和 partner() 。注意区别 于我们平常getter的写法。 
	 一个 equals 方法的实现，执行比较时会比较该类的所有成员属性 
	 重写 equals 当然要重写 hashCode 
	 一个可以打印该类所有成员属性的 toString 方法。 
	 请注意只会有一个构造方法。
	• 还可以在Record声明的类中定义静态字段、静态方法、构造器或实例方法。
	• 不能在Record声明的类中定义实例字段；类不能声明为abstract；不能声明显式的 父类等

36、java14确定switch的新特性

	String a = “3”
    int x = switch(x){
            case "1","2","3" -> 1;
            case "4","5","6" -> 2;
            default -> {
                syso;
                yield 4;
            }
    };

    int x = switch(x){
        case "1","2","3" : yield 1;
        case "4","5","6" : yield 2;
        default : yield 4;
        };

37、java14字符串

	//\为取消换行的操作
	//\s 换行
    String str = """ 
	sadasdas
	asdasdasd\
	asdasdasdas
	""";

J-J♃

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
java部分基础知识

1、比特（bit）和字节（byte）一个字节有八个比特构成文档注释的注释内容可以被JDK提供的工具javadoc解析，生成一套以网页文件形式提现的该程序的说明文档3、Java的数据类型包括基本数据类型和引用数据类型（类calss（String），接口interface，数组array）自动类型提升：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果会自动提升为容量大的byte 、char、 short < int < long < float < double
复制链接

扫一扫

专栏目录