java基础复习

最新推荐文章于 2024-09-20 21:48:23 发布

weixin_43830835

最新推荐文章于 2024-09-20 21:48:23 发布

阅读量137

点赞数 1

文章标签： java

本文链接：https://blog.youkuaiyun.com/weixin_43830835/article/details/105934558

版权

JAVASE复习

环境变量配置 path(略)
八大基本数据类型：
整型：byte, short, int, long
字符型：char
浮点型：float, double
布尔型：boolean
运算符：
& 和 && ,|和||之间的区别:短路作用&&和||是逻辑比较与和或与就是两者皆为真则为来真否则为假或则是只要有一者为真即为真否则为假而&和|则是位运自算
流程控制和循环语句：
流程控制：if和switch。
循环语句：for和while。
break与continue,return之间的区别：break：此语句导致程序终止包含它的循环，并进行程序的下一阶段continue:循环语句里有此语句时，程序运行到此语句时，不在执行循环体里continue后面的语句而是跳到下一个循环入口处执行下一个循环。
数组及工具类Arrays：
jdk中为了便于开发，给开发者提供了Arrays（在Jdk的Util包中）类，其中包括了很多数组的常用操作。列如快速输出，排序，查找等。常用方法：

import java.util.Arrays;
public class Test02{
    public static void main(String[] args){
        
        int[] arr = {4,2,3,1};
        // 【1】数组的字符串形式
        String str = Arrays.toString(arr);
        System.out.println(str);
        
        // 【2】sort对数组排序(只能升序)-> 内部使用快速排序。
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        
        // 【3】fill 填充数组
        Arrays.fill(arr,0);
        System.out.println(Arrays.toString(arr));

        // 【4】equals(arr1,arr2) 判断两个数组是否相等。
        // 数组相等的条件:a.长度相等 b.对应位置元素相等。
        int[] arr2 = {1,2,3};
        System.out.println(Arrays.equals(arr,arr2));
    }
}

面向对象：

面向对象的三大核心特性：继承性,封装性,多态性
局部变量和成员变量:成员变量：直接定义在类中的变量–直接定义在类的变量。局部变量：定义在类中局部位置（函数中）的变量–直接定义在函数的变量。

public class test {
    int a = 10;//成员变量
    public static void   main(String[] args ){
        int a =100;//局部变量
        System.out.println("a:"+a);//100
    }
}

区别

**
1.从定义的位置上：
局部变量：函数里面
成员变量：直接定义在类中
2.从内存上看：
局部变量：栈内存中
成员变量:堆内存中
3.从生命周期（指的是从分配空间到回收空间）上看：
局部变量：随着函数进栈执行，开始分配空间；函数之行结束出栈，空间被回收
成员变量：随着创建对象开始分配空间；随着对象的空间变成垃圾空间被回收而被回收；
4.从使用范围上：
局部变量：仅限于定义它的局部范围里面（比如函数中）
成员变量：整个类中
5.从初始值上看：
局部变量：没有默认值，使用前必须先要初始化

匿名对象
匿名对象，就是创建对象后，不将引用赋值给任何变量；
匿名对象的应用
如果一个对象只需要作为参数被使用一次，就可以定义为匿名对象，好处是在那行代码执行结束后，不会继续占有内存空间；

内存图解 在这里插入图片描述

常用类：
String、StringBuilder StringBuffer、Integer、Date等
集合：

Collection接口：

List和Set的区别
在这里插入图片描述
常用的ArrayList、LinkedList、HashSet

在上述Collection接口结构图中，线程安全的只有Vector和Stack，其余的都是线程不安全的。
线程安全的List有Collections.synchronizedList；

Map框架：

在这里插入图片描述
HashTable和 vbvb是线程安全的

反射：
反射机制是在运行状态中, 对于任意一个类, 都能够知道这个类的所有属性和方法; 对于任意一个对象, 都能够调用它的任意一个方法和属性。
获取class的三种方法：
第一种：Class clazz = Class.forName(XX.class的全包名)
第二种：Class clazz = XX xx = new XX();xx.getClass();
第三种：Class clazz = XX.class;
常用方法：

public class ReflectPhone2 {

    public static void main(String[] args) throws Exception {
        //获取字节码文件
        Class<?> rName = Class.forName(全限定类名);
        
        /**
         * 获取构造方法
         * 
         */
        //获取___所有public的构造方法，
        //如果还要获取所有的构造方法用getDeclaredConstructors()方法
        Constructor<?>[] constructors = rName.getConstructors();
        //获取___指定的构造方法,这获取的是无参构造方法，
        //要获取有参的请在行参列表上写上(数据类型.class,数据类型.class)；
        Constructor<?> constructor = rName.getConstructor();
        //调用___无参构造方法
        Object newInstance = constructor.newInstance();
        
        /**
         * 获取方法
         * 
         */
        //获取___类中所有的public修饰的方法,其中包括父类的方法。
        //如果还要获取所有的方法用getDeclaredMethods()方法
        Method[] methods = rName.getMethods();
        //获取___指定的方法，这获取的是无参方法，
        //要获取有参的请在行参列表上写上(指定的方法名,数据类型1.class,数据类型2.class)；
        Method method = rName.getMethod(方法名);
        //调用___非static修饰的方法需要invoke(对象,实参1，实参2)，
        //有static修饰的方法需要invoke(null,实参1，实参2)。
        //我这调用的非static修饰方法没有参数就只需一个对象
        method.invoke(newInstance);
        /**
         * 获取字段
         * 
         */
        //获取___类中的public字段。如果还要获取所有的字段用getDeclaredFields()方法
        Field[] fields = rName.getFields();
        //获取___指定的字段。
        Field field = rName.getDeclaredField(指定的字段名);
        //设置___指定的字段,非static修饰，set(对象,值);有static修饰，set(null,值)
        field.set(newInstance,5.2);
        //调用___指定字段的值,非static修饰，get(对象);有static修饰，get(null)
        Object object = field.get(newInstance);
        System.out.println("指定字段的值=="+object);
        
        /**
         * 破坏包装declaredField.setAccessible(boolean)破坏封装，可以调用私有成员
         * true:破环
         * false：默认值，不破坏
         */
        Field field2 = rName.getDeclaredField(私有化的字段名);
        //破坏封装，不让字段私有化
        field2.setAccessible(true);
        //设置字段的值
        field2.set(newInstance,值);
        //调用设置后的字段值，并打印
        Object object2 = field2.get(newInstance);
        System.out.println("破坏封装==="+object2);
        
        //获取全限定类名
        String name = rName.getName();
        System.out.println("全限定类名: "+name);
        
        //获取类名简写
        String simpleName = rName.getSimpleName();
        System.out.println("类名简写: "+simpleName);
    }
}

IO流：

字节流和字符流的区别：

1.字节流处理所有的类型数据，如：图片，视频等等，而字符流只能处理字符数据，如果处理纯文本文件，优先考虑使用字符流，其他的考虑使用字节流；
2.字节流读到一个字节就返回一个字节，字符流使用字节流读到一个或者多个字节，去查编码表，将查到的字符返回（中文对应的字节数为两个）。

多线程：
线程状态：

1、新建状态（New）：新创建了一个线程对象。
2、就绪状态（Runnable）：线程对象创建后，其它线程调用了该对象的start()方法。
该状态的线程位于可执行线程池中，变得可执行，等待获取CPU的使用权。
3、执行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。
4、堵塞状态（Blocked）：堵塞状态是线程由于某种原因放弃CPU使用权。临时停止执行。直到线程进入就绪状态，才有机会转到执行状态。堵塞的情况分三种：
（一）、等待堵塞：执行的线程执行wait()方法，JVM会把该线程放入等待池中。
(wait会释放持有的锁)
（二）、同步堵塞：执行的线程在获取对象的同步锁时。若该同步锁被别的线程占用。则JVM会把该线程放入锁池中。
（三）、其它堵塞：执行的线程执行sleep()或join()方法。或者发出了I/O请求时。JVM会把该线程置为堵塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时。线程又一次转入就绪状态。（注意,sleep是不会释放持有的锁）
5、死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

实现多线程的方法：
查看Thread类的源码，可以发现它实现了Runnable接口，然后在自己的run方法中调用了Runnable的run方法。这里其实就是静态代理这一设计模式，Thread是代理角色，而Runnable则是真实角色。在Thread的start方法中，会为我们开辟新的线程并执行其run方法，而Thread的run方法会调用它内部持有引用的Runnable的run方法。
1. 重写Thread的run方法：

Thread thread = new Thread(){
    @Override
    public void run() {
        //TODO
    }
};
thread.start();

2. 通过Runnable的run方法：

Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        //TODO
    }
});
thread.start();

3. 通过Callable接口：

class Race implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        return 1000;
    }
}

线程的阻塞：
1：join 合并线程：
join()：等待该线程终止
join(long millis)：等待该线程终止的时间最长为millis毫秒
join(long millis, int nanos)：等待该线程终止的时间最长为millis毫秒+nanos纳秒
2：yield 暂停线程：
yield方法可以实现暂停当前线程，执行其他的线程。
3：sleep 休眠线程：
sleep(long millis)：让当前线程休眠millis毫秒

线程的同步
同步也称为并发。由于现在有多个线程，就可能导致多个线程访问同一份资源的问题。我们要确保这个资源安全，因此我们对其进行同步的处理。这样就可以保证它线程安全。也就是说，线程安全的资源就是指多个线程同时访问这个资源的时候，是同步的。这份资源是安全的。
在这里插入图片描述
synchronized关键字
我们通过synchronized标识符可以保证某一部分的线程安全，它是通过等待来实现的。我们把使用synchronized的行为叫做‘加锁’。当几个线程同时访问一份资源的时候，先到达的线程拿到锁，然后再轮到其他线程来。这样能保证线程的安全。
当我们加上synchronized后，就是为它加了一把锁。当多个线程同时来访问这份资源时，先到达的资源便可以得到这个锁，其他资源只能等待，等待结束后再执行。这样就保证了我们的线程安全。
由于线程安全是通过等待来进行，因此会造成效率的低下。为了减少这种效率损耗，我们应该尽量缩小加锁的范围，来提高效率。

synchronized(引用类型|this|类.class){
    //TODO
}

大概介绍了se的内容，第一次写文章，多多包涵