JavaSE学习笔记

最新推荐文章于 2024-11-11 00:03:55 发布

gfqqq

最新推荐文章于 2024-11-11 00:03:55 发布

阅读量75

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_44741964/article/details/119534396

版权

方法

System.out.println()
system类下的标准输出对象out的println、方法

Java方法是语句的集合，他们在一起执行一个功能。
- 方法是解决一类问题的步骤的有序组合
- 方法包含于类或对象中
- 方法在程序中被创建，再其他地方被引用

方法调用

调用方法：对象名.方法名（实参列表）
Java支持两种调用方法的方式，根据方法是否返回值来选择。
当方法返回一个值时，方法调用通常北方做一个值。
```
int larger = max(30,40);
```
如果方法返回值是void，方法调用一定是一条语句。
```
System.out.println();
```

值传递（Java）和引用传递

方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数

方法的重载规则：

方法名称必须相同
参数不同
- 参数类型不同
- 参数个数不同
- 参数磐裂顺序不同等
方法的返回类型可以相同也可以不同
仅仅放回类型不同不足以成为方法的重载

可变参数方法

public class Demo04 {
    public static void main(String[] args) {
        //调用可变参数方法
        printMax(1,2,3,4,56.5);
        //传数组
        printMax(new double[]{1,2,3});
    }
    public static void printMax(double ... numbers){
        if(numbers.length == 0){
            System.out.println("没有参数");
            return;
        }
        double max = numbers[0];
        for (int i = 1; i < numbers.length; i++) {
            if(max < numbers[i]){
                max = numbers[i];
            }
        }
        System.out.println("the max is "+max);
    }
}

加入…代表可变参数，可变参数必须放在最后，即可变参数只能为最后一个参数

递归

递归就是自己调用自己，即方法A调用自己本身
递归结构包括两个部分
- 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
- 递归体：什么时候需要调用自身方法。

public class Demo05 {
    public static void main(String[] args) {
        //阶乘
        System.out.println(f(4));
    }
    public static int f(int n){
        if(n == 1){
            return 1;
        }else {
           return n* f(n-1);
        }
    }
}

数组

数组是相同类型数据的有序集合
数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
其中，每个数据称做一个数组元素，每个数组元素可以通过下标来访问他们

public class Demo01 {
    public static void main(String[] args) {
        //变量类型    变量名字  = 变量的值
        int [] nums;//1.定义，声明一个数组
        // int numss[];//不推荐使用
        nums = new int [10];//2.开辟空间，可以存放10个int型的数字
        //3.数组元素中赋值
        for (int i = 0; i < nums.length; i++) {
            nums[i] = i;
        }
    }
}

内存分析

Java内存
- 堆
  - 存放new的对象和数组
  - 可以被所有的线程共享，不会存放别的对象引用
- 栈
  - 存放基本变量类型（会包含这个基本类型的具体数值）
  - 引用对象的变量（会存放这个引用在堆里面的的具体地址）
- 方法区
  - 可以被所有的线程共享
  - 包含了所有的class和static变量

数组的四个基本特点

其长度是确定的。数组一旦被创建，他的大小是不可改变的。
其元素都是相同类型，不允许出现混合类型
数组中的元素可以是任何数据类型，包括基本类型和引用类型
数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身实在堆中的

小结

数组是相同数据类型的有序集合（数据类型可以为任意类型）
数组也是对象。数组元素相当于对象的成员变量
数组长度是确定的，不可变的。如果月结，则报：ArrayIndexOutofBounds

面向对象

什么是面向对象

面向对象的本质就是：以类的方式组织代码，以对象组织（封装）数据。
抽象
三大特性：
- 封装
- 继承
- 多态

类与对象的关系

类是一种抽象的数据类型，他是对某一类事物整体描述/第一，但不能代表某一具体的事物
对象是抽象概念的具体实例

封装

该露的露，该藏的藏
- “高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装（数据的隐藏）
- 通常，应禁止直接访问一个对象中的数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
属性私有

继承

继承的本质是对某一批类的抽象
Java中类只有单继承，没有多继承
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有以、组合和聚合等。

super注意点

super调用父类的构造方法，必须在构造方法的第一个
super必须只能出现在子类的方法或者构造方法中
super和this不能同时调用构造方法
this():本类的构造方法，super():父类的构造方法

方法的重写（不是重载）

需要有继承关系，子类重写父类的方法
1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大： public > protected>default>private
4. 抛出异常：范围：可以被缩小，但不能扩大

重写：子类的方法和父类必须要一致。方法体不同

为什么要重写：父类的功能子类不一定需要，或者不一定满足。

多态

动态编译：类型：可扩展性
多态是方法的多态
父类和子类，有联系否则类型转换异常 ClassCastException
存在条件：继承关系，方法需要重写（static方法属于类，不属于实例，final修饰，private修饰的方法不能被重写，也就没有多态），父类的引用指向子类对象

强制转换

父类引用指向子类对象
把子类转换为父类，向上转型，强制转换，可能丢失一些方法
把父类转换为子类，向下转型
方便方法的调用，减少重复代码

抽象类

不能new这个抽象类，只能靠子类去实现它：约束！
抽象类里可以写普通方法，抽象方法必须写在抽象类中
不能new对象，抽象类存在构造器吗有构造器
继承抽象类只需要重写抽象方法
存在的意义：提高开发效率

接口（可以多继承）只有规范（约束）

专业的约束，约束和实现分离：面向接口编程
接口就是规范，定义一组规则
接口的本质就是契约

作用：

约束
定义一些方法，让不同的人实现
方法都是public abstract
属性都是public static final
接口不能被实例化
可以实现多个接口
必须要重写接口中的方法

内部类

异常机制

多线程

继承Thread类实现多线程

自定义线程类继承Thread类
重写run()方法，编写线程执行体
创建线程对象，调用start()方法启动线程，不能调用run()方法
线程开启不一定立即执行，由CPU调度执行

实现Runnable接口实现多线程

重写run()方法
实例出实现了Runnable接口类的对象
启动线程：new Thread().start(),将实例出的对象丢进Thread()中
推荐使用，避免单继承的局限性，灵活方便，方便同一个对象被多个线程使用

Lamda表达式

避免匿名内部类定义过多
其实质是属于函数式被编程的概念
为什么要使用lambda表达式
- 可以让代码看起来很简洁
- 去掉了一堆没有意义的代码，只留下核心的逻辑
函数式接口
- 任何接口，如果只包含唯一一个抽象方法，那么他就是一个函数式接口：如Runnable接口
- 对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。

public class Demo02 {
    //3.静态内部类
    static class Love1 implements ILove{
        @Override
        public void love(int a) {
            System.out.println("Love"+a);
        }
    }
    public static void main(String[] args) {
        //实现类
        ILove love = new Love();
        love.love(0);
        //静态内部类
        love = new Love1();
        love.love(1);
        //局部内部类
        class Love2 implements ILove{
            @Override
            public void love(int a) {
                System.out.println("Love"+a);
            }
        }
        love = new Love2();
        love.love(2);
        //5.匿名内部类,没有类的名称，必须借助接口或者父类
        love = new ILove() {
            @Override
            public void love(int a) {
                System.out.println("Love"+a);
            }
        };
        love.love(5);
        //lambda表达式
        /*ILove bb = (int a) -> {//bb必须是ILove类型的
            System.out.println("Love"+a);
        };*/
        ILove bb = (a) -> {//bb必须是ILove类型的,参数类型可以去掉，多参数要么都去掉，要么都不去
            System.out.println("Love"+a);
        };
        love.love(6);
    }
}
//1.接口
interface ILove{
    void love(int a);
}
//2.实现类
class Love implements ILove{
    @Override
    public void love(int a) {
        System.out.println("Love"+a);
    }
}

线程状态

创建状态new
就绪状态start
运行状态，CPU调度
阻塞状态，sleep，wait，锁等
死亡状态，线程中断或者结束，一旦进入死亡状态，就不能再次启动

线程休眠

sleep（）指定当前线程组的的毫秒数
sleep存在异常InterruptedException
sleep时间达到后线程进入就绪状态
sleep可以模拟网络延时，倒计时等
每一个对象都有一把锁，sleep不会释放锁

线程礼让

礼让线程，让当前正在执行的线程暂停，但不阻塞
将线程从运行状态转为就绪状态
让CPU重新调度，礼让不一定成功，看CPU心情

Join

Join合并线程，待此线程执行完成后

//测试join方法，想象为插队
public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("VIP来了");
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin = new TestJoin();
        Thread t = new Thread(testJoin);
        t.start();

        //主线程
        for (int i = 0; i < 500; i++) {
            if(i == 200){
                t.join();//插队，强制执行完成后，其他线程才可以执行
            }
            System.out.println("main"+i);
        }
    }
}

线程优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行
线程的优先级用数字表示，范围1~10
- Thread.MIN_PRIORITY =1;
- Thread.MAX_PRIORITY =10;
- Thread.NORM_PRIORITY =5;
使用getPriority(),和setPriority(int xxx)来获取和设置优先级
先设置优先级，再启动。
优先级低只是意味着获得调度的概率低，并不是优先级第就不会被调度了，这都是看CPU的调度。

守护(daemon)线程

setDaemon(true)设置守护线程
线程分为用户线程和守护线程
虚拟机必须确保用户线程执行完毕
虚拟机不用等待守护线程执行完毕 -->gc()垃圾回收线程
作用如：后台记录操作日志，监控内存，垃圾回收等待

线程同步

并发与同步

==并发：==多个线程访问同一个对象。

同步：并且某些线程还想修改这个对象。线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。

队列和锁

synchronized

一个线程持有锁会导致其他所有需要此锁的线程挂起
在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
如果一个优先级高的线程等待一个优先级第的线程释放锁，会导致优先级倒置，引起性能问题。

同步方法

使用synchronized关键字，它包括两种用法：synchronized方法和synchronized块
- 同步方法：public synchronized void method(int args){}
synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，知道该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行
缺陷：若一个大方法申明synchronized将会影响效率
方法里面需要修改的内容才需要锁，锁的太多，浪费资源
加了synchronized变为同步方法，锁的是this,也就是这个类本身
同步块：synchronized（obj）{}
- obj称之为同步监视器
  - 它一定是需要增删改的对象
  - obj可以是任何对象，但是推荐使用共享资源作为同步监视器
  - 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class
- 同步监视器的执行过程
  1. 第一个线程访问，锁定同步监视器，执行其中代码
  2. 第二个线程访问，发现同步监视器被锁定，无法访问
  3. 第一个线程访问完毕，解锁同步监视器
  4. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问

死锁

多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等在对方释放资源，都停止执行的情形。同一个同步块同时拥有“两个以上对象的锁”时，就可能会发生死锁的问题

private void makeup(){
    if(choice==0){
        synchronized (lipstick){//选择口红
            System.out.println(Thread.currentThread().getName()+"获得口红");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            /*synchronized (mirror){//等待一秒后想获得镜子
                System.out.println(Thread.currentThread().getName()+"获得了镜子");
            }*/
        }//放在同步块外面，不会两个人同时抱一把锁
        synchronized (mirror){//等待一秒后想获得镜子
            System.out.println(Thread.currentThread().getName()+"获得了镜子");
        }
    }else {
        synchronized (mirror){//选择镜子
            System.out.println(Thread.currentThread().getName()+"获得镜子");
            try {//等待2秒
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            /*synchronized (lipstick){//等待2秒后想获得镜子
                System.out.println(Thread.currentThread().getName()+"获得了口红");
            }*/
        }//放在同步块外面
        synchronized (lipstick){//等待2秒后想获得镜子
            System.out.println(Thread.currentThread().getName()+"获得了口红");
        }
    }
}

死锁避免方法

产生思索地四个必要条件：
1. 互斥条件：一个资源每次只能被一个进程使用。
2. 请求与保持条件：一个进程因请求资源而阻塞时，对一伙的的资源保持不放。
3. 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺。
4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

Lock（锁）

同步锁使用Lock对象充当
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁童工了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
Reentrant Lock可重入锁类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的时Reentrant Lock，可以显式加锁、释放锁。

synchronized与Lock的对比

Lock是显式锁（手动开始和关闭锁），synchronized是隐式锁，除了作用域自动释放
Lock只有代码块锁，synchronized有代码块锁和方法锁
使用Lock锁，JVM将花费较少的实践来调度线程，性能更好。并且具有更好的扩展性（提供了更多子类）
优先使用顺序
- Lock>同步代码块>同步方法

线程协作

生产者消费者问题

管程法：利用缓冲区

//缓冲区
class Syncontainner{
    Product []rice = new Product[20];
    int count = 0;
    public synchronized void push(Product rice) throws InterruptedException {
        if(count == this.rice.length){
            //缓冲区满，生产者等待
            this.wait();
        }
        //可以生产
        this.rice[count] = rice;
        count++;
        System.out.println("生产了第"+rice.getId()+"号米饭,剩余"+count+"碗");

        //生产完成通知消费者
        this.notifyAll();
    }

    public synchronized Product pop() throws InterruptedException {
        if(count==0){
            //缓冲区为空，消费者等待
            this.wait();
        }
        //可以消费
        //System.out.println("剩余"+count+"碗");
        count--;
        Product p = rice[count];
        System.out.println("消费了第"+p.getId()+"碗米饭"+"剩余"+count+"碗");

        this.notifyAll();
        return p;
    }

信号灯法：利用标志位

//TV
class TV {
    boolean flag = true;
    String name;
    public synchronized void perform(String voice) throws InterruptedException {
        if(!flag){
            //如果不该表演者表演，表演者就等待
            this.wait();
        }
        //该表演者表演，则表演
        System.out.println("表演者表演的节目是："+voice);
        //表演完通知观看者
        this.notifyAll();
        this.flag = !this.flag;//变换flag
        this.name = voice;//这是为什么？？？
    }

    public synchronized void visit() throws InterruptedException {

        if(flag){
            //如果没有节目，观看者就等待
            this.wait();
        }
        //有节目了，则观看
        System.out.println("观看者观看的节目是："+name);
        //观看结束，通知表演者
        this.notifyAll();
        this.flag = !this.flag;//变换flag
    }

}

线程池

背景：经常创建和销毁、使用量特别大的资源，比如在并发情况下的线程，对性能影响很大。
思路：提前创建好多个线程，放入线程池种，使用是直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活公共交通工具。
好处：
- 提高响应速度（减少了创建新线程的时间）
- 降低资源消耗（重复利用线程池中的线程，不需要每次都创建）
- 便于县城管理
  - corePoolSize:核心池的大小
  - maximumPoolSize:最大线程数
  - keepAliveTime:线程没有任务时最多保持多长时间后会终止

//测试用Runnable实现线程池
public class TestPool {
    public static void main(String[] args) {

        //创建服务，创建线程池，参数为线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);
        //执行，与callable不同，这里用execute，callable用的是submit
        service.execute(new Test());
        service.execute(new Test());
        service.execute(new Test());
        service.execute(new Test());
        //断开连接
        service.shutdown();

    }
}

class Test implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}