什么是Java中最终的，抽象的，同步的非访问修饰符？

抽象关键字用于声明方法抽象方法和抽象类。一旦方法被声明为抽象，我们就不应该为这些方法指定主体。一旦类被声明为抽象，就无法实例化。

示例

abstract class Employee {
   private String name;
   private String address;
   private int number;
   
   public Employee(String name, String address, int number) {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   public double computePay() {
      System.out.println("Inside Employee computePay");
      return 0.0;
   }
   public void mailCheck() {
      System.out.println("Mailing a check to " + this.name + " " + this.address);
   }
   public String toString() {
      return name + " " + address + " " + number;
   }
}
public class AbstractDemo extends Employee{
      public AbstractDemo(String name, String address, int number) {
      super(name, address, number);
   }
   public static void main(String [] args) {
      Employee e = new AbstractDemo("George W.", "Houston, TX", 43);
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

输出结果

Constructing an Employee
Call mailCheck using Employee reference--
Mailing a check to George W. Houston, TX

在最后的修饰可以与方法，类和变量相关。一旦声明为final，就无法实例化final类，就不能覆盖final方法。最终变量不能重新分配。

示例

class TestExample {
   final int value = 10;
   public static final int BOXWIDTH = 6;
   static final String TITLE = "Manager";
   
   public final void changeName() {
      System.out.println("This is a final method");
   }
}
final class Demo{ }
public class FinalExample extends TestExample {
   public static void main(String args[]){
      FinalExample obj = new FinalExample();
      System.out.println(obj.value);
      System.out.println(obj.BOXWIDTH);
      System.out.println(obj.TITLE);
      obj.changeName();
   }
}

输出结果

10
6
Manager
This is a final method

的同步关键字用于指示的方法只能由一个th2hread在一个时间访问。同步修改器可以与四个访问级别修改器中的任何一个一起应用。

示例

public class TestThread {
   public static Object Lock1 = new Object();
   public static Object Lock2 = new Object();
   
   public static void main(String args[]) {
      ThreadDemo1 T1 = new ThreadDemo1();
      ThreadDemo2 T2 = new ThreadDemo2();
      T1.start();
      T2.start();
   }
   private static class ThreadDemo1 extends Thread {
      public void run() {
         synchronized (Lock1) {
            System.out.println("Thread 1: Holding lock 1...");
            try { Thread.sleep(10); }
            catch (InterruptedException e) {}
            System.out.println("Thread 1: Waiting for lock 2...");
            
            synchronized (Lock2) {
               System.out.println("Thread 1: Holding lock 1 & 2...");
            }
         }
      }
   }
   private static class ThreadDemo2 extends Thread {
      public void run() {
         synchronized (Lock2) {
            System.out.println("Thread 2: Holding lock 2...");
            try { Thread.sleep(10); }
            catch (InterruptedException e) {}
            System.out.println("Thread 2: Waiting for lock 1...");
            
            synchronized (Lock1) {
               System.out.println("Thread 2: Holding lock 1 & 2...");
            }
         }
      }
   }
}

输出结果

Thread 1: Holding lock 1...
Thread 2: Holding lock 2...
Thread 1: Waiting for lock 2...
Thread 2: Waiting for lock 1...