Java 的 default 关键字

2025年1月6日 | 阅读 8 分钟

Java default 关键字 是一种访问修饰符。如果我们不为变量、方法、构造函数和类分配任何访问修饰符，默认情况下，它就被视为默认访问修饰符。default 关键字是一个多功能且强大的工具，在语言的各个方面都起着至关重要的作用。

注意事项

默认访问修饰符只能在同一个包内访问。
与 private 和 protected 不同，我们可以通过不为外部类分配任何访问修饰符来创建默认的外部类。在这种情况下，它不限制类名与程序名相同。
如果我们重写任何方法，被重写的方法（即在子类中声明的方法）的访问级别不能比父类的方法更严格。因此，不允许使用 private 访问修饰符来修饰默认方法或变量。

在接口中使用 default 关键字

在 Java 中，接口传统上定义了类必须通过实现接口中声明的所有方法来遵守的契约。然而，当开发人员想要用新方法扩展接口，而又不强制所有实现类提供这些新方法的实现时，这会带来挑战。

default 关键字通过允许接口方法具有默认实现来解决此问题。这些方法隐式地是 public 的，并且如果需要，可以被实现类重写。通过允许向接口添加新方法而不会破坏现有代码，它有助于实现向后兼容性。

文件名：DefaultExample.java

interface Vehicle {   
    // Abstract method declaration for starting the vehicle
    void start();
    // Default method declaration for stopping the vehicle
    default void stop() {
        // Default behavior for stopping the vehicle
        System.out.println("Vehicle stopped.");
    }
}
// Example implementation of Vehicle interface
class Car implements Vehicle {
    // Implementing the start method
    @Override
    public void start() {
        System.out.println("Car started.");
    }
}
public class DefaultExample {
    public static void main(String[] args) {
        // Create an instance of Car
        Car car = new Car();        
        // Call methods
        car.start(); // Output: Car started.
        car.stop();  // Output: Vehicle stopped.
    }
}

输出

Car started.
Vehicle stopped.

带有 default 方法的多重继承

由于菱形问题，Java 不支持类的多重继承。然而，随着接口中 default 方法的引入，Java 有效地允许了行为的多重继承。如果一个类实现了具有冲突的 default 方法的多个接口，它必须显式地重写该方法，从而解决冲突。

文件名：UseOfDefault.java

// Define two interfaces with conflicting default methods
interface Interface1 {
    default void display() {
        System.out.println("Interface1");
    }
}
interface Interface2 {
    default void display() {
        System.out.println("Interface2");
    }
}
// Implementing class resolving the conflict
class MyClass implements Interface1, Interface2 {
    // Override the conflicting default method
    @Override
    public void display() {
        Interface1.super.display(); // Call the default method of Interface1
        Interface2.super.display(); // Call the default method of Interface2
    }
}
// Main class to demonstrate the usage
public class UseOfDefault {
    public static void main(String[] args) {
        // Create an instance of MyClass
        MyClass obj = new MyClass();     
        // Call the overridden method
        obj.display(); // Output: Interface1 Interface2
    }
}

输出

Interface1
Interface2

default 方法和接口演进

引入 default 方法的主要动机之一是为了在不破坏现有代码的情况下支持接口的演进。通过添加具有默认实现的具体方法，接口可以随着时间的推移而演进，同时保持与实现类的向后兼容性。

文件名：DefaultExample.java

interface Shape {    
    // Abstract method declaration for calculating area
    double calculateArea();    
    // Default method providing a default implementation for describing the shape
    default String describe() {
        return "This is a shape.";
    }
}
// Example implementation of Shape interface for a Rectangle
class Rectangle implements Shape {
    private double width;
    private double height;    
    // Constructor
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }    
    // Implementing the calculateArea method for Rectangle
    @Override
    public double calculateArea() {
        return width * height;
    }    
    // Overriding the default method describe to provide custom description for Rectangle
    @Override
    public String describe() {
        return "This is a rectangle with width " + width + " and height " + height + ".";
    }
}
// Example implementation of Shape interface for a Circle
class Circle implements Shape {
    private double radius;   
    // Constructor
    public Circle(double radius) {
        this.radius = radius;
    }    
    // Implementing the calculateArea method for Circle
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}
public class DefaultExample {
    public static void main(String[] args) {
        // Create instances of Rectangle and Circle
        Rectangle rectangle = new Rectangle(5, 3);
        Circle circle = new Circle(4);        
        // Calculate and output the areas
        System.out.println("Area of rectangle: " + rectangle.calculateArea()); // Output: Area of rectangle: 15.0
        System.out.println("Area of circle: " + circle.calculateArea());       // Output: Area of circle: 50.26548245743669        
        // Describe the shapes using default method
        System.out.println(rectangle.describe()); // Output: This is a rectangle with width 5.0 and height 3.0.
        System.out.println(circle.describe());    // Output: This is a shape.
    }
}

输出

Area of rectangle: 15.0
Area of circle: 50.26548245743669
This is a rectangle with width 5.0 and height 3.0.
This is a shape.

在 switch 语句中使用 default 关键字

Java 12 引入了 switch 表达式，它通过允许 switch 表达式返回值来增强传统的 switch 语句。default 关键字在 switch 表达式中用于指定当没有其他 case 匹配时执行的默认 case。

文件名：SwitchDefault.java

public class SwitchDefault{
    public static void main(String[] args) {
        // Using a switch statement to get the day name based on the day of the week
        int dayOfWeek = 5;
        String dayName;
        switch (dayOfWeek) {
            case 1:
                dayName = "Sunday";
                break;
            case 2:
                dayName = "Monday";
                break;
            case 3:
                dayName = "Tuesday";
                break;
            case 4:
                dayName = "Wednesday";
                break;
            case 5:
                dayName = "Thursday";
                break;
            case 6:
                dayName = "Friday";
                break;
            case 7:
                dayName = "Saturday";
                break;
            default:
                throw new IllegalArgumentException("Invalid day of the week: " + dayOfWeek);
        }
        // Output the day name
        System.out.println("Day name: " + dayName); // Output: Thursday
    }
}

输出

Day name: Thursday

default 关键字示例

示例 1

让我们看一个示例，以确定默认变量是否可以在包外访问。

文件名：A.java

package com.java;

public class A {

 String msg="Try to access default variable outside the package";
	 
}

文件名：DefaultExample1.java

package com.javatpoint;
import com.java.A;

public class DefaultExample1 {
public static void main(String[] args) {
	A a=new A();
   System.out.println(a.msg);
	
}
}

输出

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	The field A.msg is not visible

示例 2

让我们看一个示例，以确定默认变量是否可以在包内类外访问。

文件名：DefaultExample2.java

class A {

 String msg="Try to access the default variable outside the class within the package";
	 
}

public class DefaultExample2 {
public static void main(String[] args) {
	A a=new A();
   System.out.println(a.msg);
	
}
}

输出

Try to access the default variable outside the class within the package

示例 3

让我们看一个示例，以确定默认方法是否可以在包外访问。

文件名：A.java

//save by A.java

package com.java;

public class A {

void msg()
 {
	 System.out.println("Try to access default method outside the package ");
 }
	 
}

文件名：DefaultExample3.java

package com.javatpoint;
import com.java.A;

public class DefaultExample3 {
public static void main(String[] args) {
	A a=new A();
   a.msg();
	
}
}

输出

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	The method msg() from the type A is not visible

示例 4

让我们看一个示例，以确定是否可以使用继承在包外访问默认方法。

文件名：A.java

//save by A.java

package com.java;

public class A {

  void msg()
 {
	 System.out.println("Try to access default method outside the package using inheritance");
 }
	 
}

文件名：DefaultExample4.java

package com.javatpoint;
import com.java.A;

public class DefaultExample4 extends A {
public static void main(String[] args) {
	DefaultExample4 a=new DefaultExample4();
   a.msg();
	
}
}

输出

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	The method msg() from the type A is not visible

示例 5

让我们看一个示例，以确定我们是否可以使用默认外部类。

文件名：DefaultExample5.java

class DefaultExample5 {
void display()
{
	System.out.println("Try to access outer default class");
}
public static void main(String[] args) {
	DefaultExample5 p=new DefaultExample5();
	p.display();
	
}
}

输出

Try to access outer default classs

示例 6

让我们看一个示例，以确定我们是否可以从类外部创建默认构造函数的实例。

文件名：com.java

package com.java;

public class A
{
 String msg;
A(String msg)
 {
	this.msg=msg;
 }
public void display()
{
	System.out.println(msg);
}
	 
}

文件名：DefaultExample6.java

package com.javatpoint;
import com.java.A;
	
public class DefaultExample6 {
public static void main(String[] args) {
	A a=new A("Try to create the instance of default constructor outside the package");	
	a.display();

	
}
}

输出

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	The constructor A(String) is not visible

示例 7

让我们看一个示例，以确定是否可以使用默认访问修饰符将默认方法重写到子类。

文件名：A.java

class A
{
	void msg()
	{
		System.out.println("Try it");
	}
}

文件名：DefaultExample7.java

class DefaultExample7 extends A {  
    void msg()  
{  
    System.out.println("Try to access the overridden method");  
}  
public static void main(String[] args) {  
    DefaultExample7 p=new DefaultExample7();  
    p.msg();  
      
}  
}  

输出

Try to access the overridden method

示例 8

让我们看一个示例，以确定是否可以使用 private 访问修饰符将默认方法重写到子类。

文件名：DefaultExample8.java

class A
{
	void msg()
	{
		System.out.println("Try it");
	}
}

class DefaultExample8 extends A {
	private void msg()
{
	System.out.println("Try to access the overridden method");
}
public static void main(String[] args) {
	DefaultExample8 p=new DefaultExample8();
	p.msg();
	
}
}

输出

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	Cannot reduce the visibility of the inherited method from A

示例 9

让我们看一个示例，以确定是否可以使用默认访问修饰符将默认方法重写到子类。

文件名：DefaultExample9.java

class A
{
	void msg()
	{
		System.out.println("Try it");
	}
}

class DefaultExample9 extends A {
	protected void msg()
{
	System.out.println("Try to access the overridden method");
}
public static void main(String[] args) {
	DefaultExample9 p=new DefaultExample9();
	p.msg();
	
}
}

输出

Try to access the overridden method

示例 10

让我们看一个示例，以确定是否可以使用 public 访问修饰符将默认方法重写到子类。

文件名：DefaultExample10.java

class A
{
	void msg()
	{
		System.out.println("Try it");
	}
}

class DefaultExample10 extends A {
	public void msg()
{
	System.out.println("Try to access the overridden method");
}
public static void main(String[] args) {
	DefaultExample10 p=new DefaultExample10();
	p.msg();
	
}
}

输出

Try to access the overridden method

下一主题Longest-happy-string-in-java

Java 的 default 关键字

注意事项

在接口中使用 default 关键字

带有 default 方法的多重继承

default 方法和接口演进

在 switch 语句中使用 default 关键字

default 关键字示例

示例 1

示例 2

示例 3

示例 4

示例 5

示例 6

示例 7

示例 8

示例 9

示例 10

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 的 default 关键字

注意事项

在接口中使用 default 关键字

带有 default 方法的多重继承

default 方法和接口演进

在 switch 语句中使用 default 关键字

default 关键字示例

示例 1

示例 2

示例 3

示例 4

示例 5

示例 6

示例 7

示例 8

示例 9

示例 10

相关帖子

Java 中的图像处理

Java 程序演示非线程安全的懒惰初始化

Java 中的数组类型

Java 中 ChoiceFormat equals() 方法及示例

MinguoDate equals() method in Java with Examples

What is constructor chaining in Java

Java 中向方法传递对象

Java 中使用多线程进行快速排序

Java 中的最小 XOR 值对

Java 中两个已排序链表的交集

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器