[冲击SSP|八股速成】JAVA基础(一)

前言:

承蒙大家的厚爱,以后不搞抽象了,现在我把我秋招面经的笔记分享出来,希望大家能多多支持。

1. Java和C++的区别?

简答:

  1. 都是⾯向对象的语⾔,都⽀持封装、继承和多态;
  2. Java 不提供指针来直接访问内存,程序内存更加安全;
  3. Java 的类是单继承的,C++ ⽀持多重继承;虽然 Java 的类不可以多继承,但是接⼝可以多继承;
  4. Java 有⾃动内存管理机制,不需要程序员⼿动释放⽆⽤内存;
  5. 在 C 语⾔中,字符串或字符数组最后都会有⼀个额外的字符‘\0’来表示结束。但是,Java 语⾔中没有结束符这⼀概念。

详解:

1.指针

  JAVA 语言让编程者无法找到指针来直接访问内存无指针,并且增添了自动的内存管理功能,从而有效地防止了c/c++语言中指针操作失误,如野指针所造成的系统崩 溃。但也不是说JAVA没有指针,虚拟机内部还是使用了指针,只是外人不得使用而已。这有利于Java程序的安全。

2.多重继承

  c++ 支持多重继承,这是c++的一个特征,它允许多父类派生一个类。尽管多重继承功能很强,但使用复杂,而且会引起许多麻烦,编译程序实现它也很不容易。 Java不支持多重继承,但允许一个类继承多个接口(extends+implement),实现了c++多重继承的功能,又避免了c++中的多重继承实 现方式带来的诸多不便。

3.数据类型及类

  Java是完全面向对象的语言,所有函数和变量部必须是类 的一部分。除了基本数据类型之外,其余的都作为类对象,包括数组。对象将数据和方法结合起来,把它们封装在类中,这样每个对象都可实现自己的特点和行为。 而c++允许将函数和变量定义为全局的。此外,Java中取消了c/c++中的结构和联合,消除了不必要的麻烦。

4.自动内存管理

  Java程序中所有的对象都是用new操作符建立在内存堆栈上,这个操作符类似于c++的new操作符。下面的语句由一个建立了一个类Read的对象,然后调用该对象的work方法:

  Read r=new Read(); r.work();

  语句Read r=new Read();在堆栈结构上建立了一个Read的实例。Java自动进行无用内存回收操作,不需要程序员进行删除。而c十十中必须由程序贝释放内存资源, 增加了程序设计者的负扔。Java中当一个对象不被再用到时,无用内存回收器将给它加上标签以示删除。JAVA里无用内存回收程序是以线程方式在后台运行 的,利用空闲时间工作。

5.操作符重载

  Java不支持操作符重载。操作符重载被认为是c十十的突出特征,在Java中虽然类大体上可以实现这样的功能,但操作符重载的方便性仍然丢失了不少。Java语言不支持操作符重载是为了保持Java语言尽可能简单。

6.预处理功能

  Java不支持预处理功能。c/c十十在编译过程中都有一个预编泽阶段,即众所周知的预处理器。预处理器为开发人员提供了方便,但增加丁编译的复杂性。JAVA虚拟机没有预处理器,但它提供的引入语句(import)与c十十预处理器的功能类似。

7. Java不支持缺省函数参数,而c十十支持

  在c中,代码组织在函数中,函数可以访问程序的全局变量。c十十增加了类,提供了类算法,该算法是与类相连的函数,c十十类方法与Java类方法十分相似,然而,由于c十十仍然支持c,所以不能阻止c十十开发人员使用函数,结果函数和方法混合使用使得程序比较混乱。

  Java没有函数,作为一个比c十十更纯的面向对象的语言,Java强迫开发人员把所有例行程序包括在类中,事实上,用方法实现例行程序可激励开发人员更好地组织编码。

8 字符串

  c和c十十不支持字符串变量,在c和c十十程序中使用Null终止符代表字符串的结束,在Java中字符串是用类对象(strinR和stringBuffer)来实现的,这些类对象是Java语言的核心,用类对象实现字符串有以下几个优点:

  (1)在整个系统中建立字符串和访问字符串元素的方法是一致的;

  (2)J3阳字符串类是作为Java语言的一部分定义的,而不是作为外加的延伸部分;

  (3)Java字符串执行运行时检空,可帮助排除一些运行时发生的错误;

  (4)可对字符串用“十”进行连接操作。

2. 你理解Java程序的主类和应用程序、小游戏的主类有什么不同吗?

1. Java应用程序主类(Application Main Class):

定义: Java应用程序主类是指包含main方法的类,它是整个Java应用程序的入口点。main方法是Java程序的起始点,JVM会从这个方法开始执行。

特点: 应用程序主类主要用于独立的Java应用程序,这些应用程序通常是由开发人员编写并在命令行或通过脚本启动的。应用程序主类负责启动整个应用程序的执行过程。

示例:

public class MyApp {
    public static void main(String[] args) {
        System.out.println("Hello, Java Application!");
    }
}

2. Java小程序主类(Applet Main Class):

定义: Java小程序主类是指包含main方法的类,用于启动Java小程序。Java小程序是一种基于Applet技术的轻量级、嵌入式的Java程序,通常用于Web浏览器中的Java Applet。

特点: 小程序主类主要用于启动Java小程序,这些小程序在Web浏览器中运行。Java小程序通常以Applet的形式嵌入到HTML页面中,由浏览器解释执行。

示例:

import java.applet.Applet;
import java.awt.Graphics;

public class MyApplet extends Applet {
    public void paint(Graphics g) {
        g.drawString("Hello, Java Applet!", 20, 20);
    }

    public static void main(String[] args) {
        // 主类的main方法,但在小程序中不会直接调用
    }
}

不同之处:

  1. ⼀个程序中可以有多个类,但只能有⼀个类是主类。在 Java 应⽤程序中,这个主类是指包含main()⽅法的类。⽽在 Java ⼩程序中,这个主类是⼀个继承⾃系统类 JApplet 或 Applet 的⼦类。
  2. 应⽤程序的主类不⼀定要求是 public 类,但⼩程序的主类要求必须是 public 类。主类是 Java程序执⾏的⼊⼝点。
  3. 应⽤程序是从主线程启动(也就是 main() ⽅法)。applet ⼩程序没有 main() ⽅法,主要是嵌在浏览器⻚⾯上运⾏(调⽤ init() 或者 run() 来启动)。

3. Java⾯向对象编程的三大特性是哪些?

一、封装(Encapsulation)

封装是将数据和对数据的操作封装在一个单元中,对外部隐藏具体实现细节的过程。在Java中,封装通过类的定义实现,包括以下方面:

  1. 访问修饰符:使用private、public、protected等访问修饰符来限制对类成员的访问。
  2. Getter和Setter方法:通过提供公共的Getter和Setter方法,控制对私有成员变量的访问和修改。
  3. 数据隐藏:将数据成员声明为私有(private),并通过公共方法提供对数据的访问和操作。

封装的优势:

  1. 隐藏实现细节:封装可以将类的实现细节隐藏起来,使得其他代码只能通过公共接口访问和操作数据。
  2. 提高安全性:封装可以保护数据的完整性,防止未经授权的访问和修改。
  3. 提高可维护性:封装使得修改类的内部实现时只需修改类内部的代码,而不会影响到其他代码。

二、继承(Inheritance)

继承是指一个类(子类)从另一个类(父类)继承属性和方法的过程。在Java中,通过关键字"extends"实现类的继承关系。继承具有以下特点:

  1. 单继承:Java中每个类只能直接继承一个父类,但可以通过实现接口来实现多重继承。
  2. 继承关系:子类继承了父类的属性和方法,可以直接使用父类的成员。
  3. 重写(Override):子类可以对继承的父类方法进行重写,以实现自己的逻辑。

继承的优势:

  1. 代码复用:继承可以使得子类复用父类的属性和方法,减少了代码的重复编写。
  2. 继承层次:通过继承可以创建类的层次结构,使得代码更加有组织和易于理解。
  3. 多态支持:继承是实现多态的基础,子类对象可以作为父类对象使用,提高了代码的灵活性和扩展性。

三、多态(Polymorphism)

多态是指同一类型的对象,在不同情况下表现出不同的行为。在Java中,多态可以通过继承和接口实现。多态的特点:

  1. 编译时多态:通过继承和方法重写,子类对象可以被当作父类对象使用。
  2. 运行时多态:通过方法的动态绑定,根据对象的实际类型确定调用哪个方法。

多态的优势:

  1. 灵活性和可扩展性:多态使得代码可以根据不同的对象实现不同的行为,增加了代码的灵活性和可扩展性。
  2. 代码重用:通过多态,可以通过父类类型引用指向不同子类的对象,减少了代码的重复编写。
  3. 统一接口:多态可以通过接口实现,提供了统一的接口定义,使得代码更加通用和可维护。

4. 字符型常量和字符串常量有什么区别?

形式

  • 字符常量:由单引号 ' 引起的一个字符。
char letter = 'A';
  • 字符串常量:由双引号 " 引起的 0 个或若干个字符。
String greeting = "Hello, world!";

含义

  • 字符常量:相当于一个整型值(ASCII 值),可以参加表达式运算。例如,字符 'A' 的 ASCII 值为 65,可以用于算术运算。
char letter = 'A';
int asciiValue = letter; // asciiValue 的值为 65
  • 字符串常量:代表一个地址值,即该字符串在内存中的存放位置。字符串在Java中是对象,因此可以调用字符串的方法。
String greeting = "Hello";
int length = greeting.length(); // length 的值为 5

内存占用

  • 字符常量:在Java中,char 类型占用2个字节。
char letter = 'A';
System.out.println("字符型常量占用的字节数为:" + Character.BYTES); // 输出:2
  • 字符串常量:占若干个字节,具体取决于字符串的长度和编码方式。在UTF-8编码中,每个字符通常占用1个字节,但对于一些特殊字符可能会占用更多字节。

以下代码展示了字符型常量和字符串常量的定义及其内存占用情况:

public class StringExample {
    // 字符型常量
    public static final char LETTER_A = 'A';
    
    // 字符串常量
    public static final String GREETING_MESSAGE = "Hello, world!";
    
    public static void main(String[] args) {
        System.out.println("字符型常量占用的字节数为:" + Character.BYTES);
        System.out.println("字符串常量占用的字节数为:" + GREETING_MESSAGE.getBytes().length);
    }
}

深入剖析

实际应用场景
  1. 字符常量的应用:用于表示单个字符,如性别、标识符等。在字符运算和位运算中使用,例如加密算法中的字符位移。
  2. 字符串常量的应用:用于表示文本信息,如用户输入、日志信息、配置参数等。在字符串处理和操作中广泛应用,如拼接、拆分、替换等。

5. 你能解释一下什么是JVM、JDK和JRE吗?它们之间有何关系?

04 JDK、JRE与JVM的关系

JDK、JRE与JVM之间的关系可以分为以下几个关键点进行详细描述:

1 定义与功能

  • JDK(Java Development Kit):JDK是Java开发者的主要工具包,它包含了JRE(Java运行环境)以及Java开发工具,如编译器(javac)和调试器(jdb)等。JDK主要用于开发Java应用程序,它提供了编译、运行和调试Java程序所需的所有工具。
  • JRE(Java Runtime Environment):JRE是Java程序的运行环境,它包含了JVM(Java虚拟机)以及Java类库。JRE的主要作用是提供Java程序运行所需的运行时环境,使得开发者能够在不同的操作系统上运行Java程序。
  • JVM(Java Virtual Machine):JVM是Java程序的核心运行环境,它负责解释和执行Java字节码。JVM具有跨平台性,能够在不同的操作系统上运行相同的Java程序。

2 关系与层次

  • JVM与JRE的关系:JVM是JRE的核心组件,JRE包含了JVM以及Java类库。JVM提供了Java程序的运行环境,而Java类库则提供了丰富的功能和工具,使得开发者能够更方便地开发Java程序。
  • JRE与JDK的关系:JRE是JDK的一部分,JDK包含了JRE以及Java开发工具。JDK是开发Java程序的主要工具包,而JRE则是运行Java程序所必需的运行时环境。
  • 三者之间的层次关系:从层次结构上看,JDK是最顶层,它包含了JRE;而JRE又包含了JVM。这种层次关系体现了Java平台的构建原则,即“一次编写,到处运行”。

3 作用与重要性

  • JVM的作用:JVM是Java程序的核心运行环境,它负责解释和执行Java字节码。JVM的跨平台性使得Java程序能够在不同的操作系统上运行,而无需对代码进行任何修改。
  • JRE的作用:JRE提供了Java程序运行所需的运行时环境,包括JVM和Java类库。JRE使得开发者能够在不同的操作系统上运行Java程序,而无需关心底层操作系统的细节。
  • JDK的作用:JDK是Java开发者的主要工具包,它提供了开发Java程序所需的所有工具和库。JDK使得开发者能够更方便地编写、编译、调试和运行Java程序。

6. 你知道Java语⾔有哪些主要特点吗?

  1. Java是简单易学的
  2. Java是完全面向对象的(封装、继承、多态)
  3. 平台无关性,Java虚拟机实现平台无关性、跨平台,可移植
  4. 安全性(编写的都是中间语言,最后jvm解析)
  5. 健壮性(垃圾回收机制,异常处理机制)
  6. Java支持多线程,C++语言没有内置的多线程机制,因此必须调用操作系统的多线程功能来进行多线程
  7. 程序设计,而Java语言却提供了多线程支持
  8. Java是编译与解释并存类型的(比编译型的慢,但可跨平台)
  9. Java是高性能的(翻译class文件是即时的,用到才解析)
  10. 支持网络编程并且很方便(Java语言诞生本身就是为简化网络编程设计的,因此Java语言不仅支持网络编程而且很方便

7. 你了解Oracle JDK和OpenJDK的有哪些区别吗?

1. OpenJDK是Oracle JDK的精简版本

虽然说OpenJDK与Oracle JDK绝大部分相同,但是还是得小心这种情况:本地代码测试OK,上了sit环境发现各种莫名其妙的问题,这时候需要看下部署sit环境的JDK是不是和本地一致了。其次OpenJDK是不包含部署功能的,比如:Browser Plugin、Java Web Start、以及Java控制面板。

2. 授权协议不同

OpenJDK采用GPL V2协议, SUN JDK则采用JRL。说白了,使用OpenJDK就不要想使用JAVA商标了。

3. 版本对比

OpenJDK的特点是更新频繁,实现快速迭代和高效试错,为Oracle JDK LTS版本打下基础。Oracle JDK的特点是单版本长期支持,提供稳定可用的商业版本,商用收费,学习研究免费。

8. String、StringBuffer和StringBuilder有什么不同?

区别主要分三个方面即可变性、线程安全性和性能。

从可变性来看

String是不可变的,因为在String类中使用final关键字修饰字符数组来保存字符串。

StringBuffer和StringBuilder都继承自AbstractStringBuilder类,在AbstractStringBuilder类虽然也是使用字符数组来保存字符串,但没有使用final修饰,所以可变。

从线程安全性来看

String是不可变的,也可看做常量,因此线程安全。而StringBuffer虽然是可变的,但因为其对方法加了同步锁或对调用的方法加了同步锁,所以也是线程安全的。StringBuilder并没有对方法加同步锁,所以是线程不安全的。

从性能来看

每次对String类型进行改变的时候,都会生成一个新的String对象,然后将指针指向新的String对象。StringBuffer和StringBuilder可以对本身进行操作,不用生成新的对象并改变引用。因此三者中String性能最差。StringBuilder是线程不安全的,比StringBuffer性能要好。

9. 构造器Constructor可以被覆盖(override)吗?

构造器不能被重写(Override)

由于构造器是用于创建对象的特殊方法,它不是类成员方法的一部分,所以它不能像普通方法那样被子类继承并重写。重写是指子类提供了父类方法的不同实现,而构造器在继承时并不会被传递,因此无法进行重写。

构造器可以被重载(Overload)

重载是指在同一个类中,定义多个方法名相同但参数列表不同的方法。构造器可以有多个版本,每个版本参数列表不同,这就是构造器的重载。

重载代码:

class Person {
    private String name;
    private int age;
 
    // 无参数构造器
    public Person() {
        this.name = "Unknown";
        this.age = 0;
    }
 
    // 一个参数的构造器
    public Person(String name) {
        this.name = name;
        this.age = 0;
    }
 
    // 两个参数的构造器
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}
 
public class Main {
    public static void main(String[] args) {
        Person p1 = new Person(); // 调用无参数构造器
        Person p2 = new Person("Alice"); // 调用一个参数的构造器
        Person p3 = new Person("Bob", 25); // 调用两个参数的构造器
 
        p1.display(); // 输出: Name: Unknown, Age: 0
        p2.display(); // 输出: Name: Alice, Age: 0
        p3.display(); // 输出: Name: Bob, Age: 25
    }
}

10. 重载和重写有什么区别?

  1. 定义不同:重载是定义相同的方法名、参数不同,重写是子类重写父类的方法
  2. 范围不同:重载是在一个类中,重写是子类与父类之间的
  3. 多态不同:重载是编译时的多态性,重写是运行时的多态性
  4. 参数不同:重载的参数个数、参数类型、参数的顺序可以不同,重写父类子方法参数必须相同
  5. 修饰不同:重载对修饰范围没有要求,重写要求重写方法的修饰范围大于被重写方法的修饰范围

11. 在静态方法中调用非静态成员为什么是不允许的?

一、静态方法与静态成员的基本概念

(一)静态方法

静态方法是使用 static 关键字修饰的方法。它属于类本身,而不是类的某个实例。调用静态方法时,不需要创建类的对象,可以直接通过类名来调用。例如:

public class MathUtils {
    public static int add(int a, int b) {
        return a + b;
    }
}

// 调用静态方法
int result = MathUtils.add(3, 5);

(二)静态成员

静态成员包括静态变量和静态方法。静态变量同样使用 static 关键字修饰,它也属于类,被类的所有实例共享。静态变量在类加载时就会被初始化,并且在内存中只有一份拷贝。例如:

public class Counter {
    public static int count = 0;

    public static void increment() {
        count++;
    }
}

二、静态方法只能调用静态成员的规定

(一)规则示例

public class StaticExample {
    private static int staticVariable = 10;
    private int instanceVariable = 20;

    public static void staticMethod() {
        // 可以调用静态变量
        System.out.println("静态变量的值: " + staticVariable);
        // 错误:静态方法不能调用非静态变量
        // System.out.println("实例变量的值: " + instanceVariable); 

        // 可以调用静态方法
        anotherStaticMethod();
        // 错误:静态方法不能调用非静态方法
        // instanceMethod(); 
    }

    public static void anotherStaticMethod() {
        System.out.println("这是另一个静态方法");
    }

    public void instanceMethod() {
        System.out.println("这是一个实例方法");
    }
}

在上述代码中,staticMethod 是一个静态方法,它可以访问静态变量 staticVariable 和调用静态方法 anotherStaticMethod,但不能访问非静态变量 instanceVariable 和调用非静态方法 instanceMethod

(二)原因分析

1.内存分配角度

  1. 静态成员在类加载时就会被分配内存,并且在整个程序运行期间一直存在于内存中。
  2. 而实例成员是在创建类的对象时才会被分配内存,不同的对象有各自独立的实例成员副本
  3. 当调用静态方法时,可能还没有创建类的任何实例,此时如果静态方法要访问实例成员,由于实例成员还未分配内存,就会导致错误。

2.面向对象编程角度

  1. 静态方法属于类,它不依赖于类的任何实例。
  2. 而实例成员是与具体的对象相关联的,体现了对象的特定状态和行为。
  3. 如果允许静态方法调用实例成员,就会破坏这种类和对象之间的清晰界限,违背了面向对象编程的设计原则。

12. 在Java中定义一个没有参数、什么都不做的构造方法有什么作用?

作用

  1. Java程序在执行子类的构造方法之前,如果没有用super()来调用父类特定的构造方法,则会调用父类中“没有参数的构造方法”
  2. 因此,如果父类中只定义了有参数的构造方法,而在子类的构造方法中又没有用super()来调用父类中特定的构造方法,则编译时将发生错误,因为Java程序在父类中找不到没有参数的构造方法可供执行。
  3. 解决办法是在父类里加上一个不做事且没有参数的构造方法。

举例:

  • 父类
package objectOrientedTest.valiable;

public class Father {

    private String name;

    /**
    * 父类只定义了有参数的构造方法
    */
    public Father(String name){
        this.name=name;
    }
}

  • 子类
package objectOrientedTest.valiable;

public class Son extends Father{

    /**
    * 子类重写父类的带参数的构造方法
    */
    public Son(String name) {
        super(name);
    }
}
  • 测试

此时调用的无参的构造方法,就会报错,因为找不到父类中无参的构造方法

  • 解决方式:

在父类中添加无参的构造方法

 /**
    * 在父类中添加一个无参的构造方法
    */
    public Father(){}
1234

子类添加无参的构造方法,并且调用父类的super()

    /**
    * 新增子类的构造方法,调用super()
    */
    public Son(){
        super();
    }

这个时候调用就不会出错了

13. 面向对象和面向过程的区别有哪些?

1 区别:

  1. 抽象级别:面向过程主要关注解决问题的步骤和过程,以函数为基本单位,强调算法和流程控制。而面向对象则更关注问题领域中的实体和对象,强调将问题划分为多个相互关联的对象,并通过对象之间的交互来解决问题。
  2. 数据和行为:面向过程将数据和行为分离,强调数据的处理和操作,而面向对象则将数据和行为封装在一个单元中,即对象,对象包含了自身的状态(数据)和行为(方法)。
  3. 可重用性和扩展性:面向对象具有良好的可重用性和扩展性,通过继承、封装和多态等机制可以更方便地创建和扩展新功能。而面向过程缺乏这样的机制,代码复用和扩展相对较为困难。

2 联系:

  1. 对象:面向对象的核心概念是对象,而面向过程也可以使用结构体或记录等方式表示对象的概念。无论是面向对象还是面向过程,都需要处理数据和执行操作。
  2. 封装和模块化:封装是面向对象编程的基本原则,通过将数据和方法封装在对象中,可以提高代码的可维护性和安全性。而面向过程也可以使用模块化的方式将功能划分为多个独立的函数,以实现类似的效果。
  3. 设计原则:面向对象和面向过程都依赖于良好的设计原则,如单一职责原则、开放封闭原则等。不论是哪种编程范式,良好的设计原则都有助于构建高质量的软件系统。

14. 自动装箱和拆箱是什么?

自动装箱

把基本类型用它们对应的引用类型封装起来,使它们具有对象的特质,可以调用toString()、hashCode()、getClass()、equals()等方法。

如下:

 Integer a=3;//这是自动装箱1

其实编译器调用的是static Integer valueOf(int i)这个方法,valueOf(int i)返回一个表示指定int值的Integer对象,那么就变成这样:

 Integer a=3; => Integer a=Integer.valueOf(3);1

自动拆箱

跟自动装箱的方向相反,将Integer及Double这样的引用类型的对象重新简化为基本类型的数据。

如下:

 int i = new Integer(2);//这是拆箱1

编译器内部会调用int intValue()返回该Integer对象的int值

注意:自动装箱和拆箱是由编译器来完成的,编译器会在编译期根据语法决定是否进行装箱和拆箱动作。

15. Java应用程序和小程序(比如安卓小程序)之间有哪些不同?

1. 运行环境

Java应用程序

Java应用程序是一种独立运行的程序,通常通过Java虚拟机(JVM)执行。它可以在任何支持JVM的操作系统上运行,无需依赖浏览器。Java应用程序可以通过命令行、图形用户界面(GUI)、或者作为后台服务来运行。应用程序的入口点通常是一个带有main方法的类,例如:

public class MyApp {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

用户可以直接运行这个程序,无需借助其他外部应用程序或环境。

Java小程序

Java小程序是一种嵌入在网页中的小型程序,通常通过浏览器中的Java插件运行。小程序的运行环境依赖于浏览器及其内嵌的Java插件,这意味着它不能独立运行,而必须嵌入到HTML页面中,通过浏览器来加载和执行。小程序的生命周期由浏览器控制,典型的小程序类不包含main方法,而是通过一系列生命周期方法(如initstartstopdestroy)进行管理:

import java.applet.Applet;
import java.awt.Graphics;

public class MyApplet extends Applet {
    public void paint(Graphics g) {
        g.drawString("Hello, World!", 20, 20);
    }
}

这种程序只能在支持Java插件的浏览器中运行,这也限制了它的适用范围。

2. 安全性

Java应用程序

Java应用程序的安全性主要由JVM和操作系统本身来保障。独立运行的Java应用程序通常具有完全的访问权限,能够访问文件系统、网络、外部设备等资源。因此,Java应用程序在执行敏感操作时,需要特别注意安全性,比如使用安全编码实践、加密数据传输、限制权限等。

然而,如果Java应用程序是通过Web启动(如Java Web Start),它的权限可能会受到限制。这种情况下,应用程序运行在一个受限的环境中,只有在获得用户授权的情况下才能执行某些特权操作。

Java小程序

Java小程序的设计初衷是为了在不信任的网络环境中安全地运行,这就要求它具有更严格的安全机制。小程序默认运行在受限的“沙箱”(Sandbox)环境中,在这种环境下,小程序无法访问本地文件系统、打印机等资源,也不能随意建立网络连接。这种限制极大地降低了小程序对用户系统的潜在威胁。

不过,Java小程序可以通过数字签名和用户授权来获取更多的权限。如果一个小程序被签名并获得用户许可,它可以突破某些沙箱限制,获得更多的系统访问权限。但总体来说,小程序的权限控制比独立的Java应用程序要严格得多。

3. 应用场景

Java应用程序

Java应用程序的适用范围广泛,几乎涵盖了所有的桌面应用、企业级应用和后台服务。以下是一些常见的Java应用程序场景:

  • 桌面应用程序:利用Java Swing或JavaFX开发的图形用户界面应用程序,例如文本编辑器、计算器等。
  • 企业级应用:Java EE(现称为Jakarta EE)是开发企业级应用的主要平台,它提供了一整套用于构建复杂、可扩展、高可用性应用程序的框架和API,适用于开发分布式系统、Web应用、微服务架构等。
  • 后台服务:Java常用于开发后台服务,如处理大规模并发请求的Web服务器、消息队列处理器等。
  • 移动应用程序:尽管Android使用的是一种经过修改的Java语言(Android API),但Java在移动应用开发中仍然占据了重要位置。
Java小程序

Java小程序主要用于网页中的小型交互式程序,在早期Web开发中扮演了重要角色。典型的应用场景包括:

  • 网页动画:早期的网页动画常通过Java小程序实现,例如广告、滑动字幕等。
  • 小游戏:一些简单的网页游戏通过Java小程序实现,允许用户在浏览器中直接玩游戏。
  • 表单验证和交互:在JavaScript广泛使用之前,Java小程序经常用于实现表单的客户端验证和复杂的用户交互。
  • 教育和培训工具:Java小程序用于创建互动学习工具,如模拟实验、计算器、测验等。

然而,随着浏览器技术的进步和JavaScript的崛起,Java小程序逐渐被淘汰,特别是在现代Web环境中,它们的使用已经非常少见。

4. 开发方式

Java应用程序

开发Java应用程序通常需要完整的开发环境(IDE),如Eclipse、IntelliJ IDEA或NetBeans。开发者可以使用Java的标准库和第三方库来构建应用程序。应用程序可以在开发环境中调试,然后通过打包工具(如Maven或Gradle)打包成JAR或WAR文件,最终部署到用户的操作系统或服务器上。

Java小程序

Java小程序的开发相对简单,但也受到一些限制。小程序通常由一个或多个类文件组成,必须遵循Applet API的约定。开发者需要确保小程序能够在受限的沙箱环境中正常运行,并且要特别注意性能和加载速度,因为小程序是通过网络加载的,用户体验很容易受到网络条件的影响。

小程序的部署方式也与Java应用程序不同。小程序必须嵌入在HTML页面中,通过<applet>标签加载:

<applet code="MyApplet.class" width="300" height="300"></applet>
1

5. 生命周期管理

Java应用程序

Java应用程序的生命周期完全由开发者控制。开发者决定应用程序的启动、运行和退出方式。应用程序通常从main方法开始执行,当所有非守护线程结束时,应用程序终止。开发者可以使用退出钩子(Shutdown Hooks)来在应用程序退出时执行清理操作。

Java小程序

Java小程序的生命周期由浏览器控制,通常包括以下四个阶段:

  • init:在小程序加载时调用,用于执行初始化操作。
  • start:在小程序开始执行时调用,通常在用户访问包含小程序的页面时触发。
  • stop:在用户离开页面或浏览器关闭时调用,用于暂停小程序的执行。
  • destroy:在小程序卸载时调用,用于释放资源和进行清理操作。

由于小程序的生命周期与浏览器的页面生命周期紧密相关,因此小程序开发者必须处理页面刷新、离开和重新加载等事件。

#宁德时代求职进展汇总##java##面经##牛客创作赏金赛##节后第一天上班,我的精神状态#
剑指大厂后端SSP通关指南 文章被收录于专栏

(1)全网最精简八股整理,各个头部公司最新面经整理(2)面试时非技术问题的话术整理;价格随着内容增加而增加,早订阅早享受

全部评论
mark
点赞 回复 分享
发布于 05-28 23:42 北京

相关推荐

06-13 00:06
门头沟学院 Java
点赞 评论 收藏
分享
评论
2
9
分享

创作者周榜

更多
牛客网
牛客网在线编程
牛客网题解
牛客企业服务