Java 开发者最困惑的四件事,值得一看!,BAT面试文档

HarmonyOS学习 2021-11-25 18:56:27
java 面试 编程语言 后端开发

}

}

//?end?of?class?scope.

  1. 创建匿名类时可以使用任何构造方法。注意这里也使用了构造方法的参数。

  2. 匿名类可以扩展顶层类,并实现抽象类或接口。所以,访问控制的规则依然适用。我们可以访问protected变量,而改成private就不能访问了。

  3. 由于上述代码中扩展了Football类,我们不需要重载所有方法。但是,如果它是个接口或抽象类,那么必须为所有未实现的方法提供实现。

  4. 匿名类中不能定义静态初始化方法或成员接口。

  5. 匿名类可以有静态成员变量,但它们必须是常量。

匿名类的用途:

  1. **更清晰的项目结构:**通常我们在需要随时改变某个类的某些方法的实现时使用匿名类。这样做就不需要在项目中添加新的*.java文件来定义顶层类了。特别是在顶层类只被使用一次时,这种方法非常好用。

  2. **UI事件监听器:**在图形界面的应用程

《一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》

【docs.qq.com/doc/DSmxTbFJ1cmN1R2dB】 完整内容开源分享

序中,匿名类最常见的用途就是创建各种事件处理器。例如,下述代码:

button.setOnClickListener(new?View.OnClickListener()?{

public?void?onClick(View?v)?{

//?your?handler?code?here

}

});

我们创建了一个匿名类,实现了setOnClickListener接口。当用户点击按钮时会触发它的onClick方法。

多线程

Java中的多线程能够同时执行多个线程。线程是轻量级的子进程,也是处理的最小单位。使用多线程的主要目的是最大化CPU的使用率。我们使用多线程而不是多进程,因为线程更轻量化,也可以共享同一个进程内的内存空间。多线程用来实现多任务。

线程的生命周期

Java 开发者最困惑的四件事,值得一看!,BAT面试文档_面试

如上图所示,线程的生命周期主要有5个状态。我们来依次解释每个状态。

  1. New:创建线程的实例后,它会进入new状态,这是第一个状态,但线程还没有准备好运行。

  2. Runanble:调用线程类的start()方法,状态就会从new变成Runnable,意味着线程可以运行了,但实际上什么时候开始运行,取决于Java线程调度器,因为调度器可能在忙着执行其他线程。线程调度器会以FIFO(先进先出)的方式从线程池中挑选一个线程。

  3. Blocked:有很多情况会导致线程变成blocked状态,如等待I/O操作、等待网络连接等。此外,优先级较高的线程可以将当前运行的线程变成blocked状态。

  4. Waiting:线程可以调用wait()进入waiting状态。当其他线程调用notify()时,它将回到runnable状态。

  5. Terminated:start()方法退出时,线程进入terminated状态。

为什么使用多线程?

使用线程可以让Java应用程序同时做多件事情,从而加快运行速度。用技术术语来说,线程可以帮你在Java程序中实现并行操作。由于现代CPU非常快,还可能包含多个核心,因此仅有一个线程就没办法使用所有的核心。

需要记住的要点

  • 多线程可以更好地利用CPU。

  • 提高响应性,提高用户体验

  • 减少响应时间

  • 同时为多个客户端提供服务

创建线程的方法主要有两种:

  1. 扩展Thread类

  2. 实现Runnable接口

通过扩展Thread类来创建线程

创建一个类扩展Thread类。该类应当重载Thread类中的run()方法。线程在run()方法中开始生命周期。我们创建新类的对象,然后调用start()方法开始执行线程。在Thread对象中,start()会调用run()。

public?class?MultithreadingTest?extends?Thread{

public?void?run()

{

try{

System.out.println(“Thread?”+Thread.currentThread().getName()+“?is?now?running”);

}catch?(Exception?ex)?{

ex.printStackTrace();

}

}

public?static?void?main(String[]?args)

{

for(int?i=0;i<10;i++)

{

MultithreadingTest?multithreadingTest?=?new?MultithreadingTest();

multithreadingTest.start();

}

}

}

也可以通过接口创建类。

下面的代码创建了一个类,实现java.lang.Runnable接口并重载了run()方法。然后我们实例化一个Thread对象,调用该对象的start()方法。

public?class?MultithreadingTest?implements?Runnable{

@Override

public?void?run()?{

System.out.println(“Thread?”+Thread.currentThread().getName()+“?is?now?running”);?//To?change?body?of?generated?methods,?choose?Tools?|?Templates.

}

public?static?void?main(String[]?args)

{

for(int?i=0;i<10;i++)

{

Thread?thread?=?new?Thread(new?MultithreadingTest());

thread.start();

}

}

}

Thread类与Runnable接口

  • 扩展Thread类,就无法扩展更多的类,因为Java不允许多重继承。多重继承可以通过接口实现。所以最好是使用接口而不是Thread类。

  • 如果扩展Thread类,那么它还包含了一些方法,如yield()、interrupt()等,我们的程序可能用不到。而在Runnable接口中就没有这些派不上用场的方法。

同步

同步指的是多线程的同步。synchronized的代码块在同一时刻只能被一个线程执行。Java中的同步是个很重要的概念,因为Java是多线程语言,多个线程可以并行执行。在多线程环境中,Java对象的同步,或者说Java类的同步非常重要。

为什么要同步?

如果代码在多线程环境下执行,那么在多个线程中共享的对象之间需要同步,以避免破坏状态,或者造成任何不可预料的行为。

在深入同步的概念之前先来理解一下这个问题。

class?Table?{

void?printTable(int?n)?{//method?not?synchronized??

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?{

Table?t;

MyThread1(Table?t)?{

this.t?=?t;

}

public?void?run()?{

t.printTable(5);

}

}

class?MyThread2?extends?Thread?{

Table?t;

MyThread2(Table?t)?{

this.t?=?t;

}

public?void?run()?{

t.printTable(100);

}

}

class?TestSynchronization1?{

public?static?void?main(String?args[])?{

Table?obj?=?new?Table();//only?one?object??

MyThread1?t1?=?new?MyThread1(obj);

MyThread2?t2?=?new?MyThread2(obj);

t1.start();

t2.start();

}

}

运行这段代码就会注意到,输出结果非常不稳定,因为没有同步。我们来看看程序的输出。

输出:

100?5?200?10?300?15?20?400?500?25?

class?Table?{

synchronized?void?printTable(int?n)?{//synchronized?method??

for?(int?i?=?1;?i?<=?5;?i++)?{

System.out.print(n?*?i+“?”);

try?{

Thread.sleep(400);

}?catch?(Exception?e)?{

System.out.println(e);

}

}

}

}

class?TestSynchronization3?{

public?static?void?main(String?args[])?{

final?Table?obj?=?new?Table();//only?one?object??

Thread?t1?=?new?Thread()?{

public?void?run()?{

obj.printTable(5);

}

};

Thread?t2?=?new?Thread()?{

public?void?run()?{

obj.printTable(100);

}

};

t1.start();

t2.start();

}

}

给printTable()方法加上synchronized,那么synchronized的方法在执行结束之前不会让其他线程进入。下面的输出结果就非常稳定了。

输出:

5?10?15?20?25?100?200?300?400?500?

类似地,Java的类和对象也可以同步。

**注意:**我们并不一定需要同步整个方法。有时候最好是仅同步方法的一小部分。Java的synchronized代码段可以实现这一点。

序列化

Java中的序列化是一种机制,可以将对象的状态写入到字节流中。相反的操作叫做反序列化,将字节流转换成对象。

序列化和反序列化的过程是平台无关的,也就是说,在一个平台上序列化对象,然后可以在另一个平台上反序列化。

序列化时调用ObjectOutputStream的writeObject()方法,反序列化调用ObjectInputStream类的readObject()方法。

下图中,Java对象被转换成字节流,然后存储在各种形式的存储中,这个过程叫做序列化。图右侧,内存中的字节流转换成Java对象,这个过程叫做反序列化。

Java 开发者最困惑的四件事,值得一看!,BAT面试文档_后端开发_02

为什么要序列化

显然,创建的Java类在程序执行结束或终止后,对象就销毁了。为了避免这个问题,Java提供了序列化功能,通过它可以将对象存储起来,或者将状态进行持久化,以便稍后使用,或者在其他平台上使用。

下面的代码演示了该过程。

public?class?Employee?implements?Serializable?{

private?static?final?long?serialVersionUID?=?1L;

private?String?serializeValueName;

private?transient?int?nonSerializeValueSalary;

public?String?getSerializeValueName()?{

return?serializeValueName;

}

public?void?setSerializeValueName(String?serializeValueName)?{

this.serializeValueName?=?serializeValueName;

}

public?int?getNonSerializeValueSalary()?{

return?nonSerializeValueSalary;

}

public?void?setNonSerializeValueSalary(int?nonSerializeValueSalary)?{

this.nonSerializeValueSalary?=?nonSerializeValueSalary;

}

@Override

public?String?toString()?{

return?“Employee?[serializeValueName=”?+?serializeValueName?+?“]”;

}

}

import?java.io.FileOutputStream;

import?java.io.IOException;

import?java.io.ObjectOutputStream;

public?class?SerializingObject?{

public?static?void?main(String[]?args)?{

Employee?employeeOutput?=?null;

FileOutputStream?fos?=?null;

ObjectOutputStream?oos?=?null;

employeeOutput?=?new?Employee();

employeeOutput.setSerializeValueName(“Aman”);

employeeOutput.setNonSerializeValueSalary(50000);

try?{

fos?=?new?FileOutputStream(“Employee.ser”);

oos?=?new?ObjectOutputStream(fos);

oos.writeObject(employeeOutput);

System.out.println(“Serialized?data?is?saved?in?Employee.ser?file”);

oos.close();

fos.close();

}?catch?(IOException?e)?{

e.printStackTrace();

}?

}

}

输出:

Serialized?data?is?saved?in?Employee.ser?file.

import?java.io.FileInputStream;

import?java.io.IOException;

import?java.io.ObjectInputStream;

public?class?DeSerializingObject?{

public?static?void?main(String[]?args)?{

Employee?employeeInput?=?null;

FileInputStream?fis?=?null;

ObjectInputStream?ois?=?null;

try?{

fis?=?new?FileInputStream(“Employee.ser”);

ois?=?new?ObjectInputStream(fis);

employeeInput?=?(Employee)ois.readObject();

最后

现在其实从大厂招聘需求可见,在招聘要求上有高并发经验优先,包括很多朋友之前都是做传统行业或者外包项目,一直在小公司,技术搞的比较简单,没有怎么搞过分布式系统,但是现在互联网公司一般都是做分布式系统。

所以说,如果你想进大厂,想脱离传统行业,这些技术知识都是你必备的,下面自己手打了一份Java并发体系思维导图,希望对你有所帮助。

Java 开发者最困惑的四件事,值得一看!,BAT面试文档_Java_03

本文已被 CODING开源项目:【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

版权声明
本文为[HarmonyOS学习]所创,转载请带上原文链接,感谢
https://blog.51cto.com/u_15438507/4690497

  1. 图解 Kafka 线程模型及其设计缺陷
  2. Add data files for Oracle tablespaces or temporary tablespaces
  3. Intellij IDEA神器居然还有这些小技巧,mysql集群搭建视频
  4. IntelliJ IDEA(2019)之Web项目创建,掌门一对一java面试题
  5. InnoDB(2,如何访问Redis中的海量数据
  6. InheritableThreadLocal使用详解,java多线程面试题及答案整理
  7. How does Oracle modify the data type of a column
  8. Oracle 12C 12.1.0.1.0 management control file official document translation instructions
  9. Oracle 10g 10.2.0.1 in Oracle Linux 5.4 32bit RAC installation manual (Yimo Xiyang)
  10. Oracle 12C in Oracle Linux 6.5 64bit installation manual
  11. 一天十道Java面试题----第一天(面向对象-------》ArrayList和LinkedList)
  12. Schéma du modèle de fil Kafka et de ses défauts de conception
  13. Starting and shutting down Oracle RAC database cluster
  14. CRS_ Oracle CRS stack is already configured and will be running under init(1M)
  15. Common skills of Oracle stored procedure
  16. Check the number of CPUs, core books and threads of the Linux system
  17. jQuery-实例方法
  18. Oracle de duplicated data
  19. jQuery-dom和jQuery,入口函数(基本知识)
  20. Oracle creates unique constraints on columns that already have duplicate data
  21. JavaScript-拷贝
  22. JavaScript-this指向问题
  23.  There is ^ [[a garbled code problem in the up and down keys in Oracle sqlplus
  24. JavaScript-封装与继承(两种)
  25. JavaScript-包装类型
  26. JavaScript-传值(引用类型,基本类型)
  27. JavaScript-面向对象(构造函数,实例成员,静态成员)
  28. JavaScript-解构赋值
  29. JavaScript-箭头函数
  30. JavaScript-参数
  31. JavaScript-预解析(变量提升)
  32. JavaScript-闭包closure
  33. JavaScript-声明变量的关键字
  34. JavaScript - mot - clé pour déclarer une variable
  35. Fermeture de fermeture JavaScript
  36. JavaScript Pre - parse (promotion des variables)
  37. Paramètres JavaScript
  38. Fonction de flèche JavaScript
  39. JavaScript - déconstruction assignations
  40. Common annotations in springboot
  41. Building CentOS 7.6 with Linux
  42. JavaScript - orienté objet (constructeur, membre d'instance, membre statique)
  43. JavaScript value Transfer (reference type, Basic type)
  44. JavaScript - type d'emballage
  45. linux deepin/ubuntu安装flameshot火焰截图
  46. JavaScript - encapsulation et héritage (deux)
  47. JavaScript JS method for writing 99 multiplication table
  48. 從零開始學java - 第二十五天
  49. Apprendre Java à partir de zéro - jour 25
  50. Les voitures d'hiver, les voitures électriques et les voitures à essence ne sont pas les mêmes?
  51. JavaScript - ceci pointe vers le problème
  52. Copie JavaScript
  53. Spring boot quickly integrates swagger
  54. linux deepin/ubuntu安裝flameshot火焰截圖
  55. Capture d'écran de flamme de l'installateur de flamme Linux deepin / Ubuntu
  56. Jquery DOM et jquery, fonctions d'entrée (bases)
  57. Méthode d'instance jquery
  58. Méthode et démonstration de code dans l'interface de liste en Java
  59. Démarrage du Zookeeper
  60. Java oom Cognition