这四个概念，很多Java老手都说不清？

最新推荐文章于 2024-01-31 18:26:46 发布
最新推荐文章于 2024-01-31 18:26:46 发布
阅读量112 收藏
点赞数
文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/it1124/article/details/123136636
版权

Java 是很多人一直在用的编程语言，但是有些 Java 概念是非常难以理解的，哪怕是一些多年的老手，对某些 Java 概念也存在一些混淆和困惑。

所以，在这篇文章里，会介绍四个 Java 中最难理解的四个概念，去帮助开发者更清晰的理解这些概念：

  1. 匿名内部类的用法
  2. 多线程
  3. 如何实现同步
  4. 序列化

一、匿名内部类

匿名内部类又叫匿名类，它有点像局部类(Local Class)或者内部类(Inner Class)，只是匿名内部类没有名字，我们可以同时声明并实例化一个匿名内部类。

一个匿名内部类仅适用在想使用一个局部类并且只会使用这个局部类一次的场景。

匿名内部类是没有需要明确声明的构造函数的，但是会有一个隐藏的自动声明的构造函数。

创建匿名内部类有两种办法： 1. 通过继承一个类(具体或者抽象都可以)去创建出匿名内部类 2. 通过实现一个接口创建出匿名内部类

咱们看看下面的例子：

// 接口：程序员
interface Programmer {
    void develop();
}

public class TestAnonymousClass {
    public static Programmer programmer = new Programmer() {
        @Override
        public void develop() {
            System.out.println("我是在类中实现了接口的匿名内部类");
        }
    };

    public static void main(String[] args) {
        Programmer anotherProgrammer = new Programmer() {
            @Override
            public void develop() {
                System.out.println("我是在方法中实现了接口的匿名内部类");
            }
        };

        TestAnonymousClass.programmer.develop();
        anotherProgrammer.develop();
    }
}

从上面的例子可以看出，匿名类既可以在类中也可以在方法中被创建。

之前我们也提及匿名类既可以继承一个具体类或者抽象类，也可以实现一个接口。所以在上面的代码里，我创建了一个叫做 Programmer 的接口，并在 TestAnonymousClass 这个类中和 main() 方法中分别实现了接口。

Programmer除了接口以外既可以是一个抽象类也可以是一个具体类。

抽象类，像下面的代码一样：

public abstract class Programmer {
    public abstract void develop();
}

具体类代码如下:

public class Programmer {
    public void develop() {
        System.out.println("我是一个具体类");
    }
}

OK，继续深入，那么如果 Programmer 这个类没有无参构造函数怎么办？我们可以在匿名类中访问类变量吗？我们如果继承一个类，需要在匿名类中实现所有方法吗？

public class Programmer {
    protected int age;

    public Programmer(int age) {
        this.age = age;
    }

    public void showAge() {
        System.out.println("年龄:" + age);
    }

    public void develop() {
        System.out.println("开发中……除了异性，他人勿扰");
    }

    public static void main(String[] args) {
        Programmer programmer = new Programmer(38) {
            @Override
            public void showAge() {
                System.out.println("在匿名类中的showAge方法:" + age);
            }
        };
        programmer.showAge();
    }
}
  1. 构造匿名类时，我们可以使用任何构造函数。上面的代码可以看到我们使用了带参数的构造函数。
  2. 匿名类可以继承具体类或者抽象类，也能实现接口。所以访问修饰符规则同普通类是一样的。子类可以访问父类中的 protected 限制的属性，但是无法访问 private 限制的属性。
  3. 如果匿名类继承了具体类，比如上面代码中的 Programmer 类，那么就不必重写所有方法。但是如果匿名类继承了一个抽象类或者实现了一个接口，那么这个匿名类就必须实现所有没有实现的抽象方法。
  4. 在一个匿名内部类中你不能使用静态初始化，也没办法添加静态变量。
  5. 匿名内部类中可以有被 final 修饰的静态常量。

匿名类的典型使用场景：

  1. 临时使用:我们有时候需要添加一些类的临时实现去修复一些问题或者添加一些功能。为了避免在项目里添加java文件，尤其是仅使用一次这个类的时候，我们就会使用匿名类。
  2. UI Event Listeners:在java的图形界面编程中，匿名类最常使用的场景就是去创建一个事件监听器。比如:
button.setOnClickListener(new View.OnClickListener() {
    public void onClick(View v) {
    }
});

上面的代码中，我们通过匿名类实现了 setOnClickListener 接口，当用户点击按钮的时候，就会触发我们实现的 onClick 方法。

二、多线程

Java 中的多线程就是利用多个线程共同完成一个大任务的运行过程，使用多线程可以最大程度的利用CPU。

使用多线程的使用线程而不是进程来做任务处理，是因为线程比进程更加轻量，线程是一个轻量级的进程，是程序执行的最小单元，并且线程和线程之间是共享主内存的，而进程不是。

线程生命周期

 

正如上图所示，线程生命周期一共有六种状态。我们现在依次对这些状态进行介绍。

  • 1. New:当我们构造出一个线程实例的时候, 这个线程就拥有了 New 状态。这个状态是线程的第一个状态。此时，线程并没有准备运行。
  • 2. Runnable:当调用了线程类的 start() 方法, 那么这个线程就会从 New 状态转换到 Runnable 状态。这就意味着这个线程要准备运行了。但是，如果线程真的要运行起来，就需要线程调度器来调度执行这个线程。但是线程调度器可能忙于在执行其他的线程，从而不能及时去调度执行这个线程。线程调度器是基于 FIFO 策略去从线程池中挑出一个线程来执行的。
  • 3. Blocked:线程可能会因为不同的情况自动的转为 Blocked 状态。比如，等候 I/O 操作，等候网络连接等等。除此之外，任意的优先级比当前正在运行的线程高的线程都可能会使得正在运行的线程转为 Blocked 状态。
  • 4. Waiting:在同步块中调用被同步对象的 wait 方法，当前线程就会进入 Waiting 状态。如果在另一个线程中的同一个对象被同步的同步块中调用 notify()/notifyAll()，就可能使得在 Waiting 的线程转入 Runnable 状态。
  • 5. Timed_Waiting:同 Waiting 状态，只是会有个时间限制，当超时了，线程会自动进入 Runnable 状态。
  • 6. Terminated:线程在线程的 run() 方法执行完毕后或者异常退出run()方法后，就会进入 Terminated 状态。

为什么要使用多线程

大白话讲就是通过多线程同时做多件事情让 Java 应用程序跑的更快，使用线程来实行并行和并发。如今的 CPU 都是多核并且频率很高，如果单独一个线程，并没有充分利用多核 CPU 的优势。

重要的优势 - 可以更好地利用 CPU - 可以更好地提升和响应性相关的用户体验 - 可以减少响应时间 - 可以同时服务多个客户端

创建线程有两种方式

  1. 通过继承Thread类创建线程

这个继承类会重写 Thread 类的 run() 方法。一个线程的真正运行是从 run() 方法内部开始的，通过 start() 方法会去调用这个线程的 run() 方法。

public class MultithreadDemo extends Thread {
    @Override
    public void run() {
        try {
            System.out.println("线程 " + Thread.currentThread().getName() + " 现在正在运行");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            MultithreadDemo multithreadDemo = new MultithreadDemo();
            multithreadDemo.start();
        }
    }
}
  1. 通过实现Runnable接口创建线程

我们创建一个实现了 java.lang.Runnable 接口的新类，并实现其 run() 方法。然后我们会实例化一个 Thread 对象，并调用这个对象的 start() 方法。

public class MultithreadDemo implements Runnable {

    @Override
    public void run() {
        try {
            System.out.println("线程 " + Thread.currentThread().getName() + " 现在正在运行");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(new MultithreadDemo());
            thread.start();
        }
    }
}

两种创建方式对比

  • 如果一个类继承了 Thread 类，那么这个类就没办法继承别的任何类了。因为 Java 是单继承，不允许同时继承多个类。多继承只能采用接口的方式，一个类可以实现多个接口。所以，使用实现 Runnable 接口在实践中比继承 Thread 类更好一些。
  • 第一种创建方式，可以重写 yield()、interrupt() 等一些可能不太常用的方法。但是如果我们使用第二种方式去创建线程，则 yield() 等方法就无法重写了。

三、同步

同步只有在多线程条件下才有意义，一次只能有一个线程执行同步块。

在 Java 中，同步这个概念非常重要，因为 Java 本身就是一门多线程语言，在多线程环境中，做合适的同步是极度重要的。

为什么要使用同步

在多线程环境中执行代码，如果一个对象可以被多个线程访问，为了避免对象状态或者程序执行出现错误，对这个对象使用同步是非常必要的。

在深入讲解同步概念之前，我们先来看看同步相关的问题。

class Production {

    //没有做方法同步
    void printProduction(int n) {
        for (int i = 1; i <= 5; i++) {
            System.out.print(n * i+" ");
            try {
                Thread.sleep(400);
            } catch (Exception e) {
                System.out.println(e);
            }
        }

    }
}

class MyThread1 extends Thread {

    Production p;

    MyThread1(Production p) {
        this.p = p;
    }

    public void run() {
        p.printProduction(5);
    }

}

class MyThread2 extends Thread {

    Production p;

    MyThread2(Production p) {
        this.p = p;
    }

    public void run() {
        p.printProduction(100);
    }
}

public class SynchronizationTest {
    public static void main(String args[]) {
        Production obj = new Production(); //多线程共享同一个对象
        MyThread1 t1 = new MyThread1(obj);
        MyThread2 t2 = new MyThread2(obj);
        t1.start();
        t2.start();
    }
}

运行上面的代码后，由于我们没有加同步，可以看到运行结果非常混乱。 Output: 100 5 10 200 15 300 20 400 25 500

接下来，我们给 printProduction 方法加上同步：

class Production {

    //做了方法同步
    synchronized void printProduction(int n) {
        for (int i = 1; i <= 5; i++) {
            System.out.print(n * i+" ");
            try {
                Thread.sleep(400);
            } catch (Exception e) {
                System.out.println(e);
            }
        }

    }
}

当我们对 printProduction() 加上了同步(synchronized)后, 已有一个线程执行的情况下，是不会有任何一个线程可以再次执行这个方法。这次加了同步后的输出结果是有次序的。

Output: 5 10 15 20 25 100 200 300 400 500

类似于对方法做同步，你也可以去同步 Java 类和对象。

注意：其实有时候我们可以不必去同步整个方法。出于性能原因，我们其实可以仅同步方法中我们需要同步的部分代码。被同步的这部分代码就是方法中的同步块。

序列化

Java 的序列化就是将一个 Java 对象转化为一个字节流的一种机制。从字节流再转回 Java 对象叫做反序列化，是序列化的反向操作。

序列化和反序列化是和平台无关的，也就是说你可以在 Linux 系统序列化，然后在 Windows 操作系统做反序列化。

如果要序列化对象，需要使用 ObjectOutputStream 类的 writeObject() 方法。如果要做反序列化，则要使用 ObjectOutputStream 类的 readObject() 方法。

如下图所示，对象被转化为字节流后，被储存在了不同的介质中。这个流程就是序列化。在图的右边，也可以看到从不同的介质中，比如内存，获得字节流并转化为对象，这叫做反序列化。

 

为什么使用序列化

如果我们创建了一个 Java 对象，这个对象的状态在程序执行完毕或者退出后就消失了，不会得到保存。

所以，为了能解决这类问题，Java 提供了序列化机制。这样，我们就能把对象的状态做临时储存或者进行持久化，以供后续当我们需要这个对象时，可以通过反序列化把对象还原回来。

下面给出一些代码看看我们是怎么来做序列化的。

import java.io.Serializable;

public class Player implements Serializable {

    private static final long serialVersionUID = 1L;

    private String serializeValueName;
    private transient String nonSerializeValuePos;

    public String getSerializeValueName() {
        return serializeValueName;
    }

    public void setSerializeValueName(String serializeValueName) {
        this.serializeValueName = serializeValueName;
    }

    public String getNonSerializeValueSalary() {
        return nonSerializeValuePos;
    }

    public void setNonSerializeValuePos(String nonSerializeValuePos) {
        this.nonSerializeValuePos = nonSerializeValuePos;
    }

    @Override
    public String toString() {
        return "Player [serializeValueName=" + serializeValueName + "]";
    }
}
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class SerializingObject {
    public static void main(String[] args) {

        Player playerOutput = null;
        FileOutputStream fos = null;
        ObjectOutputStream oos = null;

        playerOutput = new Player();
        playerOutput.setSerializeValueName("niubi");
        playerOutput.setNonSerializeValuePos("x:1000,y:1000");

        try {
            fos = new FileOutputStream("Player.ser");
            oos = new ObjectOutputStream(fos);
            oos.writeObject(playerOutput);

            System.out.println("序列化数据被存放至Player.ser文件");

            oos.close();
            fos.close();

        } catch (IOException e) {

            e.printStackTrace();
        }
    }
}

Output: 序列化数据被存放至Player.ser文件

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class DeSerializingObject {

    public static void main(String[] args) {

        Player playerInput = null;
        FileInputStream fis = null;
        ObjectInputStream ois = null;

        try {
            fis = new FileInputStream("Player.ser");
            ois = new ObjectInputStream(fis);
            playerInput = (Player) ois.readObject();

            System.out.println("从Player.ser文件中恢复");

            ois.close();
            fis.close();

        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }

        System.out.println("player名字为 : " + playerInput.getSerializeValueName());
        System.out.println("player位置为 : " + playerInput.getNonSerializeValuePos());
    }
}

Output:

从Player.ser文件中恢复
player名字为 : niubi
player位置为 : null

关键特性

  1. 如果父类实现了 Serializable 接口那么子类就不必再实现 Serializable 接口了。但是反过来不行。
  2. 序列化只支持非 static 的成员变量
  3. static 修饰的变量和常量以及被 transient 修饰的变量是不会被序列化的。所以，如果我们不想要序列化某些非 static 的成员变量，直接用 transient 修饰它们就好了。
  4. 当反序列化对象的时候，是不会调用对象的构造函数的。
  5. 如果一个对象被一个要序列化的对象引用了，这个对象也会被序列化，并且这个对象也必须要实现 Serializable 接口。

顺便在这里说一下，我目前是在职Java开发，如果在学习Java的过程当中有遇见任何关于学习方法，学习路线等方面的问题，你都可以 点击  Java技术讨论，这里面聚集了很多正在学习Java技术的初学者，也有不少从事Java开发岗的大佬，与Java相关的问题都可以随时发出来讨论。

总结

首先，我们介绍了匿名类的定义，使用场景和使用方式。

其次，我们讨论了多线程和其生命周期以及多线程的使用场景。

再次，我们了解了同步，知道同步后，仅同时允许一个线程执行被同步的方法或者代码块。当一个线程在执行被同步的代码时，别的线程只能在队列中等待直到执行同步代码的线程释放资源。

最后，我们知道了序列化就是把对象状态储存起来以供后续使用。

IT1124
关注
BAT 大厂Java 面试题集锦之核心篇附参考答案
AI天才研究院
11-05 1万+
核心篇数据结构与算法网路:TCP/IP,HTTP操作系统, 文件, shell, CPU, IO, epoll, 非阻塞IO,进程/线程/协程,锁HashMap, Co...
你读完这一篇还不会学Java过来打我
05-04 304
前言 我写公众号差不多有一个月多点，也收获了一部分的粉丝，粉丝现在还不算多，也是因为我也没有如何宣传，也可能文章内容还需要改善 写公众号这一个多月收到了些留言，都是关于大学期间的迷惑问题，来看下 我首先说下我自己的情况吧，读的大学是燕山大学，在美丽的河北秦皇岛，美丽的旅游城市，个人还是很喜欢的，我们学校对面就是美丽的大海，感受一下撒 （秦皇岛17年的荧光海，真的美） 19年7月份毕业，先是就职于国家某网研发部门，肝了半年多，后跳槽到某厂研发部门。为什么跳槽呢？说个容易挨打的话，太闲了，钱的话，中规.
什么？听说这四个概念，很多 Java 老手都说不清
文章中资料均可获取，有需要请添加yunduoa2019即可
08-29 205
Java 是很多人一直在用的编程语言，但是有些 Java 概念是非常难以理解的，哪怕是一些多年的老手，对某些 Java 概念也存在一些混淆和困惑。 所以，在这篇文章里，会介绍四个 Java 中最难理解的四个概念，去帮助开发者更清晰的理解这些概念： 匿名内部类的用法 多线程 如何实现同步 序列化 匿名内部类 匿名内部类又叫匿名类，它有点像局部类(Local Class)或者内部类(Inner Class)，只是匿名内部类没有名字，我们可以同时声明并实例化一个匿名内部类。 一个匿名内部类仅适...
浅谈四个 Java 中最难理解的四个概念
yihuliunian的博客
09-15 189
转自：http://www.pinlue.com/article/2020/09/0123/5011161653544.html
java基础之难理解部分罗列
家楠168的博客
08-15 292
1. hashCode和equals方法的关系 quals相等，hashcode必相等；hashcode相等，equals可能不相等。 2
几个比较难理解的JAVA关键字总结
liuchuangjin的博客
06-19 1919
1.   abstract（抽象） 用法：类修饰符的一种，可以用来修饰类，方法，被修饰的类不能够实例化（即不能用new关键字得到对象），被修饰的方法不能够实现。一个抽象类中不一定要有抽象方法，但是一个类里面有抽象方法就一定是抽象类。如果由类要继承抽象类的话，必须要实现里面的抽象方法。构造方法和静态方法不可以修饰为抽象。 例子：        public abstract class Ani
java很难理解_我很难理解Java对象和类
weixin_34326484的博客
02-27 152
例1/***Program Name: Cis36L0411.java*Discussion: Class -- Data Members ONLY* Method Members ONLY*/class Cis36L0411{public static void main( String[] args ){DataOnly data1 = new ...
Java基础【狂神说Java笔记】
forever_lover_的博客
10-23 2933
Java基础【狂神说Java笔记】标识符注意点数据类型用户交互Scanner选择结构do...while循环While和do-While的区别:For循环增强for循环break & continue方法的定义方法的重载可变参数递归数组的定义小结:稀疏数组介绍初识面向对象面向过程&面向对象面向对象回顾方法及加深类与对象的关系创建与初始化对象封装:继承方法重写多态抽象类接口内部类异常Exception自定义异常实际应用中的经验总结 【狂神说Java】Java零基础学习视频通俗易懂 标识符注意
JAVA高并发多线程必须懂的50个问题
qq_43747015的博客
11-21 322
JAVA高并发多线程必须懂的50个问题
Thinking In Java 第四版(英文版)-练习题答案
02-16
12. **设计模式**：书中虽然没有专门章节讲解，但很多练习题会引导读者思考并应用常见的设计模式，如工厂模式、单例模式、观察者模式等。 通过深入学习和实践这些知识点，不仅可以掌握Java语言，更能培养出高效、...
bio nio aio demo
04-11
bio nio aio demo下载，可直接运行main方法。了解 bio nio aio基础用法
Java中小白难以理解的词汇
等风来的博客
04-29 1636
Java中小白难以理解的词汇
Java比较难理解的关键字
大道至简
04-23 202
[color=red][b]transient[/b][/color]： 把一个对象的表示转化为字节流的过程称为串行化serialization，从字节流中把对象重建出来称为反串行化deserialization，transient 为不应被串行化的数据提供了一个语言级的标记数据方法。 对象的序列化(serialization)非常影响I/O的性能,尽量少用。对...
java基础易错、难理解、易混淆知识点复习
吟游诗人——吟唱生命的不朽
12-27 1219
以下为学习java基础语法与原理过程中发现的一些与以往感觉不同、或者是不熟悉的地方，特此列出。只是提纲所以不是很详细，有些地方为了通俗易懂可能不是很严谨，尽请指正与补充。1、 java命令行编译与运行：javac Welcome.java -> java Welcome 2、 栈：形参、局部变量存在栈中，进入子程序分配，退出子程序释放 3、 堆：用new语句创建的内存在堆中，退出
Java的内部类真的那么难以理解？
li123128的博客
12-28 213
　　01 前言 　　 　　昨天晚上，我把车停好以后就回家了。回家后才发现手机落在车里面了，但外面太冷，冷到骨头都能感受到寒意——实在是不想返回一趟去取了（小区的安保还不错，不用担心被砸车玻璃），于是打定主意过几个小时的“世外桃源”生活——别人找不到我，我也找不到别人，这种与世隔绝的状态非常适合读书写作。 　　 　　把厚厚的《Java编程思想》摆在桌子上，正襟危坐，认认真真地读起了第十章——内部类。...
编程世界中难以理解的一些概念
clemente的博客
06-11 321
句柄 = 编号 (文件编号 ,窗口编号)
java学习笔记最难理解的多态
try
08-09 994
专题 封装和继承和多态 1、 封装：①方法②类③包 2、 继承： 使用父类的方法和属性。 子类会继承父类权限允许的属性和方法。 父类的构造方法不能被继承。 继承现象总结：     1. 子类重写父类方法，调用子类方法；     2. 子类属性与父类同名(不管子类属性前修饰符如何均允许)，如获取属性，看获取属性方法位置，如在父类中，获取的是父类属性，如在子类中，获取的是子类属性；
从啥都不懂开始学Java--帮你解决专业术语看不懂困难
weixin_45792612的博客
11-01 378
说起来小编刚开始接触Java的时候，真是一把鼻涕一把泪。一直想学编程，听说Java是现今最火的编程语言，就忙不迭地跑到图书馆里借了一本啥零基础开始学Java的书，结果看了几天，那些专业术语看得我晕头转向，看到怀疑人生。 针对此类这种状况，小编就稍微整理一下，用比较接地气的语言解释一下到底怎么才是个入门法，怎么才能更好地开启属于你的Java之旅。 目录一.Ja...
java基础面试题：BIO,NIO,AIO 有什么区别?
最新发布
qq_46285584的博客
01-31 1194
在AIO中，应用程序发送一个I/O请求后，可以继续执行其他操作，当I/O操作完成时，操作系统会通知应用程序进行后续处理。与NIO不同，AIO的I/O操作由操作系统完成，应用程序无需主动地等待I/O操作的完成。NIO提供了非阻塞的I/O操作，可以同时处理多个连接，使用较少的线程来处理更多的客户端请求，从而提高了系统的并发性能。阻塞 I/O（BIO）：BIO是传统的阻塞式I/O模型，它基于流（Stream）和阻塞调用，即当一个线程执行I/O操作时，会阻塞等待数据的到达或操作完成。
《Thinking In Java》第四版中文清晰版：Java编程经典指南
通过320个实用的Java程序示例，读者可以跟随作者的步伐，深入理解诸如继承、多态、网络编程、多线程处理、虚拟机性能优化以及与其他非Java代码交互等高级概念。每个例子都经过精心设计，旨在帮助读者直观地掌握抽象...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值