Java知识点

最新推荐文章于 2023-06-22 12:54:35 发布

米花町的哲瑞雷恩

最新推荐文章于 2023-06-22 12:54:35 发布

阅读量134

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/qq_27031945/article/details/110345605

版权

java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Java知识点

变更履历

日期	版本	内容	作者	备注
2020/11/29	v1.00	初版做成	author	copyFrom1024_初次整理

1.概述

JavaSE(Java Platform Standard Edition)标准版,主要用于桌面应用程序的开发
JavaME(Java Platform Micro Edition)小型版,为开发电子消费产品和嵌入式设备提供的解决方案
JavaEE(Java Platform Enterprise Edition)企业版(JakartaEE)，是为开发企业环境下的应用程序提供的一套解决方案,主要针对于Web应用程序开发
Java语言是面向对象的编程语言
JRE（Java Runtime Environment）即Java运行时环境，主要负责运行Java程序
JDK（Java Development Kit）即Java开发工具包，主要用来开发Java程序，给Java开发人员使用的
使用javac命令将*.java文件编译成生成以.class结尾的文件，这个生成的class文件叫做字节码文件
要想运行这个字节码文件的话，需要使用java命令，之后会启动JVM，JVM中的类装载器会去电脑硬盘里面寻找这个class文件，然后将其加载到内存中开始运行
单行注释使用//,多行注释使用/* /来标注,文档注释使用/** */来标注
文件名必须和类名一致
在一个Java文件里面，可以声明多个class，但是只能声明一个public class
package语句只能出现在.java源文件的第一行,package语句在一个java文件中只能有一个,如果没有package，默认表示无包名

2.基础

标识符

Java标识符命名规则:标识符是由，数字，字母，下划线和美元符号构成，其他符号不可以。必须以字母、下划线和美元符号开头，不能以数字开头。
关键字不能作为标识符
标识符区分大小写，理论上没有长度限制，但是最好不要命名太长的名字。

基本数据类型

byte 占一个字节 -128到127 （字节型）
short 占两个字节 -2¹⁵~2 ¹⁵-1（短整型）
int 占四个字节 -2³¹~2³¹-1 （整型）
long 占八个字节 -2⁶³~2⁶³-1 （长整型）
float 占四个字节 -3.403(10³⁸)~3.403(10³⁸) 单精度
double 占八个字节-1.798(10³⁰⁸)~1.798(10³⁰⁸)双精度
char 占两个字节 0~65535(Unicode 字符编码)例：‘a’ 97，‘A’ 65，‘0’ 48。char的默认值 \u0000
boolean 只有两个取值true和false
关于基本数据类型转换规则：
- 8种基本数据类型除boolean类型之外都可以相互转换.
- 小容量向大容量转换叫做自动类型转换：byte<short(char)<int<long<float<double
- byte,short,char做混合运算的时候，各自都先转换成int在做运算
- 大容量向小容量转换是强制类型转换，需要加强制转换符，编译虽然通过，运行期可能损失精度。谨慎使用。
- 如果整数没有超出byte,short,char的取值范围，可以直接将这个整数赋值给byte,short,char
- 多种数据类型做混合运算，先转换成容量最大的那种再做运算。

运算符

+号在java中有三种作用,代表正号,做加法运算,字符串的连接符
++这个叫做自增运算符，–叫做自减运算符。放在变量的前面，先自增或者自减，然后再参与运算。
开发中常用&&和||，如果当需求要求无论左边的表达式是true还是false，右边的表达式必须执行，此时必须使用逻辑与(&)，短路与(&&)做不到。
三目运算符:boolean表达式 ? 表达式1 : 表达式2

语句

switch判断程序遇到break语句结束了，可以不写break，如果不写，则会发生case穿透现象
do…while循环至少执行一次循环体。而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。
while后面的;不要忘记，否则会报错。
方法重载发生的条件:发生在同一个类中,方法名相同,参数列表不同(类型，个数，顺序)
方法重载和返回值类型无关,方法重载和方法的修饰符列表无关

3.面向对象

封装，继承，多态
类=成员变量+方法

构造方法

方法名与类名相同(注意大小写也要与类名一致)
没有返回值类型
没有void修饰
没有具体的返回值return;
如果一个类没有提供任何构造方法，系统默认提供无参数构造方法
如果一个类已经手动的提供了构造方法，那么系统不会再提供任何构造方法。
构造方法是可以构成重载的
如果要是使用this调用构造方法的话，那么this必须出现在构造方法的第一行。
构造代码块优先于构造方法执行

静态

static可以修饰变量，被static修饰的变量叫做静态变量，静态变量在类初始化阶段赋值，并且只赋值一次
static可以修饰方法，被static修饰的方法叫做静态方法，不用创建对象就能能直接访问该方法，即使用类名.静态方法名的方式。静态方法不能访问非静态的数据，静态方法不能使用this
static可以定义静态语句块，静态语句块在类初始化阶段执行，并且只执行一次，并且是自上而下的顺序执行，在构造方法之前执行

继承

java语言里面只支持单继承
如果一个类没有显示的继承其他类，那么这个类会默认继承Object类
子类需使用关键字super()方法调用父类的构造方法，super不能用在静态方法中。

重写

两个类必须是继承关系
必须具有相同的方法名，相同的返回值类型，相同的参数列表.
重写的方法不能比被重写的方法拥有更低的访问权限。
重写的方法不能比被重写的方法抛出更宽泛的异常。
私有的方法不能被重写。
构造方法无法被重写，因为构造方法无法被继承。
静态的方法不存在重写。
重写指的是成员方法，和成员变量无关。

final关键字

final修饰的类无法被继承
final修饰的方法无法被重写
final修饰的局部变量，一旦赋值，不可再改变
final修饰的成员变量必须初始化值
修饰的基本类型，是值不能被改变
修饰的引用类型，是地址值不能被改变,对象中的属性可以改变…

抽象类

抽象类无法被实例化，无法创建抽象类的对象。
虽然抽象类没有办法实例化，但是抽象类也有构造方法，该构造方法是给子类创建对象用的。这也算是多态的一种。
抽象类中不一定有抽象方法，但抽象方法必须出现在抽象类中。
抽象类中的子类可以是抽象类，如果不是抽象类的话必须对抽象类中的抽象方法进行重写。
抽象类和抽象方法不能被final修饰

接口

接口中只能出现常量和抽象方法
接口里面没有构造方法，无法创建接口的对象
接口和接口之间支持多继承，即一个接口可以有多个父接口
一个类可以实现多个接口，即一个类可以有多个父接口
一个类如果实现了接口，那么这个类需要重写接口中所有的抽象方法，如果不重写则这个类需要声明为抽象类

访问控制权限

java访问级别修饰符主要包括：private 、protected、public和default（默认），可以限定其他类对该类、属性和方法的使用权限。
注意对类的修饰只有：public和default

集合

Collection

List：有顺序，可重复
Set：没有顺序的，不能重复
Queue：队列，先进先出，可以重复
遍历Collection的四种方式

	//普通for循环
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
    //增强for循环
    for (Integer i:list){
        System.out.println(i);
    }
    //迭代器
    Iterator<Integer> iterator = list.iterator();
    while(iterator.hasNext()){
        Integer i = iterator.next();
        System.out.println(i);
    }
    //使用Iterable接口中的default方法forEach+lambda表达式
    list.forEach((i) -> {System.out.println(i); });
    list.forEach(i -> System.out.println(i));
    list.forEach(System.out :: println);

Map

Map中的元素是以键-值的方式存在的，通过键可以获取到值，键是不可以重复的（put方法自动覆盖）
遍历Map的方式

Map中的keySet()返回的是一个包含所有键的Set类型的对象，通过键获取值
// 获取map中所有的键返回给Set
        Set<Integer> keySet = map.keySet();

        //遍历set获取键，根据键获取值
        Iterator<Integer> iter = keySet.iterator();
        while(iter.hasNext()){
            Integer key = (Integer)iter.next();
            System.out.println("键：" + key + "，值：" + map.get(key));
        }
        //使用增强for循环遍历
        for(Integer key : map.keySet()) {            
            System.out.println("键：" + key + "，值：" + map.get(key));
        }
    }
Map中的键和值被封装成了Entry对象,并存储在Set集合中，通过entrySet()可以获取到这个Set集合。
Set<Map.Entry<Integer,String>> entrySet = map.entrySet();
        Iterator<Map.Entry<Integer,String>> it = entrySet.iterator();
        while(it.hasNext()) {
            //获取每一个Entry对象
            Entry<Integer,String> en = it.next();    
            //根据键值对对象获取键
            Integer key = en.getKey();        
            //根据键值对对象获取值
            String value = en.getValue();    
            System.out.println("键：" + key + "，值：" + value);
        }


        //增强for循环
        for (Entry<Integer, String> en : map.entrySet()) {
            System.out.println("键：" + en.getKey() + "，值：" + en.getValue());
        }

IO流

字节流（InputStream和OutputStream） : 字节流可以操作任何数据,因为在计算机中的数据都是以字节的形式存储的。
字符流（Reader和Writer） : 字符流只能操作纯字符数据，防止乱码。

多线程

多线程创建的三种方式
- 继承Thread类创建线程
- 实现Runnable接口
- 实现Callable接口

class MyThread extends Thread {
    //2.重写run方法
    public void run() {        
        //3.将要在线程中执行的代码编写在run方法中
   ;
        }
    }
}

public class ThreadTest01 extends Thread {

    public static void main(String[] args) {
        //4.创建上面自定义类的对象
        //创建一个线程
        MyThread mt = new MyThread();        

        //5.调用start方法启动线程
        mt.start();                            
        }
    }
// 1.自定义一个类实现java.lang包下的Runnable接口
class MyRunnable implements Runnable {

    // 2.重写run方法
    @Override
    public void run() {
        // 3.将要在线程中执行的代码编写在run方法中
;
    }

}

public class ThreadTest02 {

    public static void main(String[] args) {
        // 4.创建上面自定义类的对象
        MyRunnable mr = new MyRunnable();

        // 5.创建Thread对象并将上面自定义类的对象作为参数传递给Thread的构造方法
        Thread t = new Thread(mr); 

        //6.调用start方法启动线程
        t.start();
        }
   /**
 * 多线程实现的第三种方法，实现Callable接口 优点： 可以获取返回值 可以抛出异常
 */

//1.定义一个类实现Callable<V>接口
public class MyCallable implements Callable<Integer> {

    // 2.重写call方法
    @Override
    public Integer call() throws Exception {
        // 3.将要执行的代码写在call方法中
        //返回一个随机数
        Random r = new Random();
        int num = r.nextInt(100);

        return num;
    }
}
public class Callable01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //4.创建ExecutorService线程池
        ExecutorService exec = Executors.newCachedThreadPool();

        //5.将自定义类的对象放入线程池里面
        //开启两个线程
        Future<Integer> result1 = exec.submit(new MyCallable());
        Future<Integer> result2 = exec.submit(new MyCallable());


        //判断线程是否计算完毕
        while (!result1.isDone() && !result2.isDone()) {
            System.out.println("等待线程计算完毕");
        }

        //6.获取线程的返回结果
        Integer i1 = result1.get();
        Integer i2 = result2.get();

        System.out.println(i1);
        System.out.println(i2);

        //7.关闭线程池，不再接收新的线程，未执行完的线程不会被关闭
        exec.shutdown();
    }
}

反射

可以实现简单的反编译，获取类中的属性和方法等基本信息，.class—>java
通过反射机制获取类的属性、方法等
三种方式

//第一种方式：
//c1引用的对象代表整个Person类
Class c1 = Class.forName("com.Person");

//第二种方式：
//java中每个类型都有 class 属性.
Class c2 = Person.class;

//第三种方式：
//java语言中任何一个java对象都有getClass 方法
Person p = new Person();
Class c3 = e.getClass(); ```

米花町的哲瑞雷恩

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java知识点

Java知识点变更履历日期版本内容作者备注2020/11/29v1.00初版做成authorcopy_初次整理1.概述JavaSE(Java Platform Standard Edition)标准版,主要用于桌面应用程序的开发JavaME(Java Platform Micro Edition)小型版,为开发电子消费产品和嵌入式设备提供的解决方案JavaEE(Java Platform Enterprise Edition)企业版(Ja
复制链接

扫一扫