JAVA中的“ 大同小异 “知识点总结

Posted 小智RE0

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JAVA中的“ 大同小异 “知识点总结相关的知识，希望对你有一定的参考价值。

在学习过程中,总结的部分相似知识点;
有啥不对的地方;希望大家多多指教

目录

1.JDK 、JRE 、JVM

JDK,JRE,JVM三者关系概括如下：
jdk是JAVA程序开发时用的开发工具包，其内部也有JRE运行环境JRE。JRE是JAVA程序运行时需要的运行环境，仅仅是为了运行JAVA程序而不是去搞开发的话，只安装JRE就可运行已存在的JAVA程序。JDK、JRE内部都包含JAVA虚拟机JVM，JAVA虚拟机内部包含许多应用程序的类的解释器和类加载器…

JVM：JVM是Java Virtual Machine（Java虚拟机）的缩写，是整个java实现跨平台的最核心的部分，所有的java程序会首先被编译为.class的类文件，这种类文件可以在虚拟机上执行，class并不直接与机器的操作系统相对应，而是经过虚拟机间接与操作系统交互，由虚拟机将程序解释给本地系统执行。JVM是Java平台的基础，和实际的机器一样，它有自己的指令集，并在运行时操作不同的内存区域。 JVM通过抽象操作系统和CPU结构，提供了一种与平台无关的代码执行方法，即与特殊的实现方法、主机硬件、主机操作系统无关。JVM的主要工作是解释自己的指令集（即字节码）到CPU的指令集或对应的系统调用，保护用户免被恶意程序骚扰。 JVM对上层的Java源文件是不关心的，它关注的只是由源文件生成的类文件（.class文件）。

JRE：JRE是java runtime environment（java运行环境）的缩写。仅有JVM还不能让class文件执行，因为在解释class时JVM需要调用解释所需要的类库lib。在JDK的安装目录里可以找到jre目录，存在两个文件夹bin和lib,可认为bin目录中的就是jvm，lib中则是jvm工作所需要的类库，而jvm和lib和起来就称为jre。JRE是Sun公司发布的系统，它里面就有JVM。JRE就与具体的CPU结构和操作系统有关，是运行Java程序必不可少的（除非用其他一些编译环境编译成.exe可执行文件……)

JDK：JDK是java development kit（java开发工具包）的缩写。JDK的安装目录中有六个文件夹、一个src类库源码压缩包、和其他几个声明文件。真正在运行java时起作用仅有这四个文件夹：bin、include、lib、jre。

JDK包含JRE，而JRE包含JVM。
bin:最主要的是编译器(javac.exe)
include:java和JVM交互用的头文件

2.标识符

Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符。

命名由英文字母大小写，0-9 ，_或 $ 组成；注意不能以数字开头，不能是关键字和保留字，不能有空格。
包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写： XxxYyyZzz
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

3.基本数据类型,引用数据类型,包装类

  • 基本数据类型

基本数据类型(内置数据类型):【数值型: [整数型(byte、int，short，long) ；浮点型（float、double）] 】
【字符型（char）】 【布尔型（boolean）】

浮点数不可用于比较,因为它本身就具有误差.

基本数据类型数据类型转换:(注意布尔型(boolean)不参与数据类型转换)

默认转换::容量小的转化为容量大的;
byte,short,char->int->long->float->double
占用内存空间字节:1,2,2,4,8,4,8

强制转换:
容量大的强制转换为容量小的;
但是会产生问题:数据溢出以及精度损失.

  • 引用数据类型

对象、数组都是引用数据类型。引用类型变量就是一个指针，只是 Java 语言里不再使用指针这个说法。
所有引用类型的默认值都是null。
空类型（null type）就是 null 值的类型，这种类型没有名称。因为 null 类型没有名称，所以不可能声明一个 null 类型的变量或者转换到 null 类型。
空引用（null）是 null 类型变量唯一的值。空引用（null）可以转换为任何引用类型。

  • 包装类:

引入包装类的目的就是：提供一种机制，使得基本数据类型可以与引用类型互相转换。

包装类基本数据类型
Bytebye
Shortshort
Integerint
Longlong
Floatfloat
Doubledouble
Characterchar
Booleanboolean

4.位 、 字节 、字符

位:(bit)计算机中内部数据最小的存储单位;00000001是二进制八位;
字节:(byte) 计算机中 数据处理 的基础单位;习惯上用大写的B表示;

1 B=8bit

字符:计算机中使用的字母,数字,字,符号;

1024B=1KB; 1024KB=1M;1024M=1G;

5.运算符之: & 与 && 、 | 与 ||

逻辑运算符

位运算符:

运算符优先级:

  • & 与 &&

& :逻辑与左边无论真假，右边都进行运算；
&&: 短路与如果左边为假，那么右边不参与运算。

  • | 与 ||

| :逻辑或 左边无论真假，右边都进行运算；
|| :短路或当左边为真，右边不参与运算。

6.hasnext( ) 、 hasnextLine( )

hasnext( )
读到有效字符后才可以结束输入;
对输入的有效字符之前遇到的空白,next方法会将其自动去掉;
只能输入字符后,才将其后面的空白作为分隔符或结束符;
next()不能得到带空格的字符串.

hasNextLine( )
以ENTER为字符串,也就是说,nextLine方法返回的是输入回车之前的所有字符;
它可以获得空白;

7.方法重载 、 方法重写(覆盖,覆写)

方法重载:在同一个类中，有相同的方法名称，但是形参不同。

方法名称必须相同；参数列表必须不同；
方法的返回值可以相同，也可以不相同；与访问权限修饰符无关.

方法重写:(覆盖,覆写);在一个继承关系中;当子类的实现方式和父类不一样时(或者理解为父类的方法不能满足子类的需求时);在子类中对父类的方法进行重写.

前提是在继承关系中;方法名相同,参数列表相同;返回值类型相同;
子类重写方法中的访问权限是要大于等于父类的权限;(例如父类的方法权限是默认的;子类重写方法时使用Public权限是可行的;);
构造方法;静态方法不能重写;
重写时使用注解:@Override;

8.静态代码块 、实例代码块

代码块:在类中声明，类似一个没有名称的方法体(代码块)
静态代码块:静态块在类被加载时、第一次创建对象、使用类中的静态变量、静态方法、时就会被调用;
仅仅只执行一次;之后不再执行;

static {
//任何符合语法的Java代码
}

实例代码块:在创建对象时调用,每创建一次对象就会执行一次;

{
//任何符合语法的Java代码
}

执行优先级:

关于类加载的优先级:
先加载静态代码块 = =>静态属性或方法 = =>接着是实例代码块==>然后是构造方法

9.访问权限修饰符

(1)public; 修饰类,方法,属性; 公共的;可在任意位置使用;
(2)protected;修饰属性;方法; 受保护的;本类;同包的类,不同包的子类中使用;
(3)default; 修饰类,属性,方法; 默认的;本类;同包的类中使用;
(4)private 修饰属性,方法,内部类; 私有的;仅可在本类中使用;

10. this 、 super

this关键字代表自身类的对象

使用this关键字引用成员变量;
使用this关键字引用成员方法;
注意：this关键字必须放在非静态方法里面;

super关键字代表父类的对象

构造方法的第一行默认使用super( );它是默认存在的;调用父类无参的构造方法;
也可以显式地使用super关键字调用有参构造方法;
super必须只能出现在子类的方法||构造方法中;

区别:

  • this:指向当前类的成员; super:指向的是父类的成员;
  • this 没有继承也是可以用的; super只能在继承关系中使用;
  • this: 本身这个类的构造; super :父类的构造;

11.抽象类 、 接口

抽象类:被关键字abstract修饰的类;

(1)有抽象方法的类必须是抽象类;抽象类除了抽象方法外,还可以有构造方法,非抽象方法;
(2)抽象类中不一定要有抽象方法;
(3)抽象类不能实例化对象,因为它包含了不能实现的抽象类;
(4)抽象类包含构造方法;在创建子类对象时,可以间接创建父类对象,调用父类的构造方法;
(5)抽象类作为定义,让其他类去继承,要么将子类声明抽象类,要么将重写抽象类中所有抽象方法;

接口:被关键字 interface修饰;

属性变量默认为静态常量,即被public static final 修饰;
接口中的抽象方法默认被public abstract修饰;

(1)接口可理解为一个纯粹的抽象类;
(2)接口是隐式抽象的，当声明一个接口的时候，可以不用abstract关键字;
(3)接口不是被类继承了，而是要被类实现;
(4)接口没有构造方法;不能实例化对象;
(5)一个接口可以继承多个接口 ; 一个实现类只能有一个直接继承父类;但可以实现多个接口 ; 多个类可以去实现同一个接口
(6)实现接口用implements关键字;要么重写接口所有抽象方法;要么将自身声明为抽象类;

在jdk8以后也可以写非抽象的方法:静态方法和默认方法;
(1)静态方法:可以通过接口这个类直接去调用;
(2)默认方法:可理解为是对接口中的抽象方法的补充;有方法体,可以不写;

12.装箱 、拆箱

装箱:基本类型转为引用类型;
拆箱:引用类型转为基本类型

装箱过程是通过调用包装类的valueOf方法实现的
拆箱过程是通过调用包装类的xxxValue方法实现的（xxx表示对应的基本数据类型）

案例:

int a=128;
//自动装箱(隐式调用 valueOf方法);
Integer it=a;
//装箱:
Integer it1=Integer.valueOf(a);
 System.out.println(it==it1);//false
// 在包装类中还存在着缓冲池的机制;例如,Integer的缓冲数值区间为[-128~127]
//==============================
int a=10;
System.out.println(it==it1);//true

拆箱:

Integer integer=new Integer(1800000);
//拆箱;
int b = integer.intValue();
//自动拆箱:(隐式地调用intValue方法)
int c=integer;
System.out.println(b==c);//true ;这时是两个基本数据类型在比较;

13. == 、 equals

  • 比较基本数据类型时;只能使用 == 比较,
  • " =="用于引用类型的比较时,比较两个对象在内存中的地址是否相等;
  • equals方法一般来说比较的是内容;在Object类中;equals方法比较的是对象地址是否相等
  • 自定义的一个类;若是不去重写equals方法;就默认调用Object类中的equals方法
  • 两个不同类型的引用不能进行 == 比较。(会报出编译错误)

Object类中的equals( ) 方法源码:比较的是对象地址是否相等

    public boolean equals(Object obj) {
        return (this == obj);
    }

两个不同类型的引用不能进行 == 比较。(会报出编译错误)

int,Integer,new Integer

  • int和Integer比较，Integer会自动拆箱， ==为true
  • int和new Integer比较，Integer会自动拆箱， 所以 == 为true.
  • Integer和Integer比较，是直接赋值,自动装箱。当赋值在[-128,127]区间时，不会创建新的Integer对象，直接从缓冲池中获取已经创建好的Integer对象。当赋值超出缓冲池区间范围时，会直接new Integer。当Integer和Integer进行== 比较,赋值在[-128,127]区间的时候，为true。不在区间范围时则为false;由于Integer的equals方法是进行重写的，比较的是内容，所以为true.
  • Integer和new Integer 比较时;Integer的赋值如果是在区间[-128,127]中,就从缓冲池中取值，否则就会new Integer.new Integer会创建对象，存储在堆中; ;所以Integer和new Integer 比较时;进行==为false ; Integer和new Integer 进行equals比较内容为true.
  • new Integer和new Integer比较;new Integer会分别创建对象，存储在堆中;分配的地址不同; 进行==比较为false;进行equals比较内容为true.

案例:

//int和Integer比较，
        int a1=10;
        Integer b1=10;
        System.out.println(a1==b1);//true
  
// int和new Integer比较，
        int a2 = 10;
        Integer b2 = new Integer(10);
        System.out.println(a2 == b2);//true
        
//Integer和Integer比较;
        //(1)赋值在缓冲区间[-128,127]时;
        Integer a3=10;
        Integer b3=10;
        System.out.println(a3==b3);//true
        System.out.println(a3.equals(b3));//true  
        //(2)赋值不在缓冲区间[-128,127]时;
        Integer a4=128;
        Integer b4=128;
        System.out.println(a4==b4);//false
        System.out.println(a4.equals(b4));//true

//Integer和new Integer 比较;
        Integer a5 = 10;
        Integer b5 = new Integer(10);
        System.out.println(a5 == b5);//false
        System.out.println(a5.equals(b5));//true

//new Integer和new Integer比较;
        Integer a6 = new Integer(10);
        Integer b6 = new Integer(10);
        System.out.println(a6 == b6);//false
        System.out.println(a6.equals(b6));//true

14.String str=null ;String str=new String();String str="";

String str=null

null表示对象的内容为空，即对象的内容是空白的。null没有分配内存。
不会指向任何对象,

  • 案例:
//用isEmpty( )方法判断字符串是否为空。
//字符串通过 length() 方法计算字符串长度，如果返回 0，即为空字符串。

String s=null;
System.out.println(s==null);//true
//System.out.println(s.length());空指针异常;
//System.out.println(s.isEmpty());空指针异常;
//System.out.println(s.equals(""));//空指针异常;

String str=new String( )

创建一个字符串对象的默认值为”” ;该字符串为空串;即长度为0;
分配了内存

调用字符串无参构造方法:(这里的value指向值为空字符串 ""的值)

public String() {
        this.value = "".value;
    }
  • 案例:
 String s1=new String();
System.out.println(s1==null);//false
System.out.println(s1.length());// 0
System.out.println(s1.isEmpty());//true
System.out.println(s1.equals(""));//true;

String str=""

创建一个值为”” 的字符串对象;该字符串为空串;即长度为0;

调用有参构造方法:

public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
    }
  • 案例:
String s2 = new String("");
System.out.println(s2 == null);//false;
System.out.println(s2.length());//0
System.out.println(s2.isEmpty());//true
System.out.println(s2 .equals("") );//true

在字符串判空时,首先要判断是否为null;然后判断是否为空字符串.

15.编码 解码

编码: 字符串转为字节

解码: 字节转为为字符

  • 案例:
public class Demo03 {
    public static void main(String[] args) {
        String str=new String("我爱Java");
        //byte[] getBytes() 将字符串转化为byte 数组

        try {
            //指定字节编码方式为utf-8;
            //编码:
            byte[] bytes=str.getBytes("utf-8");
            System.out.println("编码==>:"+Arrays.toString(bytes));

            //解码:
            //注意字节编码方式前后一致;
            String str1=new String(bytes,"utf-8");
            System.out.println("解码==>"+str1);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
}
  • 结果:
编码==>:[-26, -120, -111, -25, -120, -79, 74, 97, 118, 97]
解码==>我爱Java

16.throw throws

throw 抛出异常对象

  • throw关键字用于显式抛出异常,抛出的是一个异常类的实例化对象.
  • 在异常处理中，try语句要捕获的是一个异常对象，那么此异常对象也可以自己抛出。
  • throw用于方法体中，用来抛出一个实际的异常对象，使用throw后，要么使用try ,catch捕获异常，要么使用throws声明异常

throws 声明异常

  • •throws用于方法声明，用来声明该方法可能发生的异常类型，可以是多个异常类型，用来强制调用该方法时处理这些异常
  • throws声明异常大多数是编译期(检查期)的异常;如果是声明的是运行期异常,在方法调用处可处理,也可不处理; 如果声明的是编译期异常,在方法调用处,要么声明给调用它的上一级;要么try catch处理;
  • 对于编译期的异常可以throws声明,也可以直接try, catch直接处理;
  • 在调用声明了异常的方法时,可以选择try,catch处理异常,或者选择throws声明给调用它的上级;
  • 在抽象方法中也可以使用throws声明,即便它没有方法体;在子类继承抽象类时,重写声明了抽象方法;那么这时,子类重写的方法中声明的异常类型需要小于等于父类的异常类型
  • 案例
public class ExceptionDemo {
    public static void main(String[] args) {
        //创建类对象;
        ExceptionDemo e=new ExceptionDemo();
        //try,catch处理异常;
        try {
            e.test();
        }catch (ArrayIndexOutOfBoundsException aex){
            aex.printStackTrace();
        }
        System.out.println("可运行");
    }
    //在方法test处声明数组越界异常;
    public void test() throws ArrayIndexOutOfBoundsException{
        //这里数组越界;
        int[] array=new int[2];
        array[2] =5;
        //抛出数组越界异常对象;
        throw new ArrayIndexOutOfBoundsException();
    }
}
  • 结果:
java.lang.ArrayIndexOutOfBoundsException: 2
	at bigandsmall.intinteger.ExceptionDemo.test(ExceptionDemo.java:22)
	at bigandsmall.intinteger.ExceptionDemo.main(ExceptionDemo.java:12)
可运行

17.Hashtable HashMap

  • Hashtable 是一个散列表，它存储的内容是键值对(key-value)映射。
  • Hashtable 线程安全的，而 HashMap 是线程不安全的
  • HashTable直接使用对象的hashCode;HashMap重新计算hash值.
  • HashMap 是内部基于哈希表实现，该类继承AbstractMap，实现Map接口.
  • 由数组+链表组成的，基于哈希表的Map实现，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的。
  • HashMap允许将 null 作为一个 entry 的 key 或者 value，而 Hashtable 不允许。

key value能否为null

Map集合keyvalue
HashMap允许为null允许为null
TreeMap不允许允许
HashTable不允许不允许
ConcurrentMap不允许不允许

18.创建线程: 继承Thread类 实现Runnable接口

  • 继承Thread类: 线程代码存放Thread子类run方法中。
  • 实现Runnable接口：线程代码存在接口的子类的run方法。

若是继承java.lang.Thread类的方式; 重写run( ) 方法后 ,在线程的Thread对象上调用start( )方法;

new 类名( ).start( )

若是实现java.lang.Runnable接口的方式,重写 run方法,则先用Thread的构造方法;然后在Thread对象上调用start( )方法;

new Thread( new 类名( )).start( )

以上是关于JAVA中的“ 大同小异 “知识点总结的主要内容，如果未能解决你的问题，请参考以下文章

线程学习知识点总结

暑期第四周学习总结

Java习惯用法总结

#yyds干货盘点#愚公系列2023年02月 .NET/C#知识点-程序运行计时的总结

java代码连接本地SQL server数据库总结

java代码连接本地SQL server数据库总结