精华内容
下载资源
问答
  • Java关键字顺序
    千次阅读
    2022-02-22 11:31:18

    The Java Language Specification recommends listing modifiers in the following order:

    1. Annotations

    2. public

    3. protected

    4. private

    5. abstract

    6. static

    7. final

    8. transient

    9. volatile

    10. synchronized

    11. native

    12. strictfp

    Not following this convention has no technical impact, but will reduce the code's readability because most developers are used to the standard order.

    Noncompliant Code Example

    static public void main(String[] args) {   // Noncompliant
    }
    

    Compliant Solution

    public static void main(String[] args) {   // Compliant
    }
    更多相关内容
  • 在本文里我们给大家分享的是关于java volatile关键字作用及使用场景的相关知识点内容,需要的朋友们学习下。
  • 主要介绍了Java this 关键字的使用方法详解的相关资料,希望通过本文能帮助到大家,让大家彻底理解掌握这部分内容,需要的朋友可以参考下
  • Java super关键字使用

    2017-05-16 15:44:36
    Java super关键字使用demo
  • java统计关键字个数

    2018-08-03 10:39:57
    通过args传参,读取文件,统计java代码中的关键字个数
  • 主要介绍了Java synchronized关键字和Lock接口实现原理,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 初次遇见 native是在 java.lang.Object 源码中的一个hashCode方法:  public native int hashCode();  为什么有个native呢?这是我所要学习的地方。所以下面想要总结下native。  一、认识 native 即 JNI,Java...
  • 主要介绍了彻底理解Java中this 关键字的相关资料,非常不错,具有参考价值,需要的朋友可以参考下
  • volatile关键字虽然从字面上理解起来比较简单,但是要用好不是一件容易的事情。这篇文章主要介绍了Java中volatile关键字的作用与用法详解的相关资料,需要的朋友可以参考下
  • 主要介绍了Java Volatile关键字实现原理过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了Java synchronized关键字使用方式及特性解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了Java super关键字的使用方法详解的相关资料,希望通过本文能帮助到大家,让大家对super关键字彻底掌握,需要的朋友可以参考下
  • java volatile 关键字详解

    千次阅读 热门讨论 2021-04-03 15:30:49
    java volatile 关键字详解 一,什么是volatile关键字,作用是什么 ​ volatile是java虚拟机提供的轻量级同步机制 ​ 作用是: 1.保证可见性 2.禁止指令重排 3.不保证原子性 本篇具体就讲解 什么叫保证了可见性, 什么叫...

    java volatile 关键字详解

    一,什么是volatile关键字,作用是什么

    ​ volatile是java虚拟机提供的轻量级同步机制

    ​ 作用是: 1.保证可见性 2.禁止指令重排 3.不保证原子性

    本篇具体就讲解 什么叫保证了可见性, 什么叫禁止指令重排,什么是原子性

    而在这之前需要对JMM 有所了解

    二,什么是JMM

    ​ JMM(java 内存模型 Java Memory Model 简称JMM) 本身是一个抽象的概念,并不在内存中真实存在的,它描述的是一组规范或者规则,通过这组规范定义了程序中各个变量(实例字段,静态字段和构成数组对象的元素)的访问方式.

    JMM的同步规定:

    ​ 1.线程解锁之前,必须把共享变量刷新回主存

    ​ 2.线程加锁锁之前,必须读取主存的最新值到自己的工作空间

    ​ 3.加锁解锁必须是 同一把锁

    ​ 由于 JMM运行程序的实体是线程.而每个线程创建时JMM都会为其创建一个自己的工作内存(栈空间),工作内存是每个线程的私有 数据区域.而java内存模型中规定所有的变量都存储在主内存中,主内存是共享内存区域,所有线程都可以访问,但线程的变量的操作(读取赋值等)必须在自己的工作内存中去进行,首先要 将变量从主存拷贝到自己的工作内存中,然后对变量进行操作,操作完成后再将变量操作完后的新值写回主内存,不能直接操作主内存的变量,各个线程的工作内存中存储着主内存的变量拷贝的副本,因IC不同的线程间无法访问对方的工作内存,线程间的通信必须在主内存来完成, 其简要访问过程如下图:

    在这里插入图片描述

    三,可见性

    ​ 可见性:指当多个线程访问同一个变量时,一个线程修改了这个变量的值,其他线程能够立即看得到修改的值。

    ​ 通过前面的 JMM介绍,我们知道各个线程对主内存的变量的操作都是各个线程各自拷贝到自己的工作内存中进行操作,然后在写回主内存中

    ​ 这就可能存在一个线程a修改了共享变量X的值但还未写回主内存,又有一个线程b对共享变量X进行操作,但 此时线程a的工作内存的共享变量X对线程吧来说是不可见的,这种工作内存与主内存同步延迟的问题就造成了可见性问题

    四,不保证原子性

    ​ 原子性:某个线程在执行某项业务时,中间不可被加塞或分割,需要整体完整。要么同时成功,要么同时失败

        class MyData{volatile int number = 0;
    ​    Object object = new Object();
    
        public void addTo60(){
            this.number = 60;
        }
        
        public void addPlusPlus(){
            this.number++;
        }
        
        AtomicInteger atomicInteger = new AtomicInteger();
        
        public void addAtomic(){
            atomicInteger.getAndIncrement();
        }
    }
    
    /**
     * 验证volatile的可见性
    
     * 1.当number未被volatile修饰时,new Thread将number值改为60,但main线程并不知道,会一直在循环中出不来
    
     * 2.当number使用volatile修饰,new Thread改变number值后,会通知main线程主内存的值已被修改,结束任务。体现了可见性
     *
    
     * 验证volatile不保证原子性
    
     * 1.原子性是指,某个线程在执行某项业务时,中间不可被加塞或分割,需要整体完整。要么同时成功,要么同时失败
     *
    
     * 如何解决呢?
    
     * 1.使用synchronize
    
     * 2.使用AtomicInteger
     *
     */
    public class VolatileDemo {
        public static void main(String[] args) {
            //seeByVolatile();
            atomic();
        }
        //验证原子性
        public static void atomic() {
            MyData myData = new MyData();
            for (int i = 1; i <= 20; i++) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for (int j = 1; j <= 1000; j++) {
                            /*synchronized (myData.object){
                                myData.addPlusPlus();
                            }*/
                            myData.addPlusPlus();
                            myData.addAtomic();
                        }
                    }
                }).start();
            }
    
            //等待上面20个线程全部计算结束
            while (Thread.activeCount() > 2){
                Thread.yield();
            }
            
            System.out.println(Thread.currentThread().getName() + "int finally number is " + myData.number);
            System.out.println(Thread.currentThread().getName() + "AtomicInteger finally number is " + myData.atomicInteger);
        }
    
        //验证可见性的方法
        public static void seeByVolatile() {
            MyData myData = new MyData();
            //第一个线程
            new Thread(){
                public void run(){
                    System.out.println(Thread.currentThread().getName() + " come in");
                    try {
                        sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    myData.addTo60();
                    System.out.println(Thread.currentThread().getName() + " update number to " + myData.number);
                }
            }.start();
    
            //第二个线程 main
            while (myData.number == 0){
            
            }
            System.out.println(Thread.currentThread().getName() + "mission is over");
        }
    }
    

    number++在多线程下是非线程安全,不是原子性操作?

    在这里插入图片描述

    五,禁止指令重排

    ​ 计算机在执行程序时,为了提高性能,编译器和处理 器常常会对指令做重排,一般分为一下三种:

    在这里插入图片描述

    单线程的环境里指令重排确保最终执行的结果和代码顺序执行的结果一致

    处理器在进行指令重排是必须 要考虑指令之间的数据依赖性

    多线程的环境交替执行,由于编译器优化重排的存在,俩个线程使用变量能否保证一致性是无法确定的,无法预料的

    实例一:

    在这里插入图片描述

    实例二:

    在这里插入图片描述

    线程操作资源类,线程1访问method1,线程2访问method2,正常情况顺序执行,a=6
    多线程下假设出现了指令重排,语句2在语句1之前,当执行完flag=true后,另一个线程马上执行method2,a=5

    所以volatile 禁止指令重排,从而避免多线程的 环境下出现执行乱序 的情况

    六:使用volatile 的经典案例

     单例DCL的代码
    
    public class SingletonDemo {
        private static SingletonDemo instance = null;
    
        private SingletonDemo(){
            System.out.println(Thread.currentThread().getName() + "构造方法");
        }
        
        //DCL双端加锁机制
        public static SingletonDemo getInstance(){
            if (instance == null){
                synchronized (SingletonDemo.class){
                    if (instance == null){
                        instance = new SingletonDemo();
                    }
                }
            }
            return instance;
        }
    }
    

    这种写法在多线程条件下可能正确率为99.999999%,但可能由于指令重排出错

    原因在于某一个线程执行到第一次检测,读取到instance不为null,instance引用对象可能还没有完成初始化.

    instance = new SingletonDemo();; 分为一下三步

    1. memory = allocate() //分配内存
    2. ctorInstanc(memory) //初始化对象
    3. instance = memory //设置instance指向刚分配的地址

    2 ,3 步不存在数据依赖, 可以指令重排的执行顺序为 1 ,3 ,2,设置instance指向刚分配的地址,次数instance还没有初始化完

    但此时instance不为null了,若正好此时有一个线程来访问,就出现了线程安全问题

    所以需要添加volatile 关键字

    public class SingletonDemo {
        private static volatile SingletonDemo instance = null;
    
        private SingletonDemo(){
            System.out.println(Thread.currentThread().getName() + "构造方法");
        }
        //DCL双端加锁机制
        public static SingletonDemo getInstance(){
            if (instance == null){
                synchronized (SingletonDemo.class){
                    if (instance == null){
                        instance = new SingletonDemo();
                    }
                }
            }
            return instance;
        }
    }
    
    展开全文
  • Java常用关键字查询

    2022-03-24 16:55:16
    Java常用关键字查询看这一篇

    Java 关键字

    下面列出了 Java 关键字。这些保留字不能用于常量、变量、和任何标识符的名称。

    类别关键字说明
    访问控制private私有的
    protected受保护的
    public公共的
    default 默认
    类、方法和变量修饰符abstract声明抽象
    class
    extends扩充,继承
    final最终值,不可改变的
    implements实现(接口)
    interface接口
    native本地,原生方法(非 Java 实现)
    new新,创建
    static静态
    strictfp严格,精准
    synchronized线程,同步
    transient短暂
    volatile易失
    程序控制语句break跳出循环
    case定义一个值以供 switch 选择
    continue继续
    default默认
    do运行
    else否则
    for循环
    if如果
    instanceof实例
    return返回
    switch根据值选择执行
    while循环
    错误处理assert断言表达式是否为真
    catch捕捉异常
    finally有没有异常都执行
    throw抛出一个异常对象
    throws声明一个异常可能被抛出
    try捕获异常
    包相关import引入
    package
    基本类型boolean布尔型
    byte字节型
    char字符型
    double双精度浮点
    float单精度浮点
    int整型
    long长整型
    short短整型
    变量引用super父类,超类
    this本类
    void无返回值
    保留关键字goto是关键字,但不能使用
    const是关键字,但不能使用

    Java 的 null 不是关键字,类似于 true 和 false,它是一个字面常量,不允许作为标识符使用。

    展开全文
  • Java常用关键字总结

    2021-01-20 03:30:20
    1、public 关键字是可以应用于类、方法或字段(在类中声明的变量)的访问控制修饰符。 2、可以在其他任何类或包中引用 public 类、方法或字段。 3、除非存在特定的访问控制修饰符,否则,可以从同一个包中的任何类...
  • 主要介绍了java volatile关键字使用方法及注意事项的相关资料,当一个变量被声明为 volatile 后,java 内存模型确保所有使用该变量的线程能看到相同的、一致的值。,需要的朋友可以参考下
  • java PDF关键字定位

    2017-12-14 16:11:47
    java PDF关键字定位,所用jar为itextpdf-5.5.6.jar,jar自己去下载,这里只提供定位方式
  • java提取文章关键字

    2017-11-24 13:31:49
    java提取文章关键字,可随意更改提取关键字的个数、规则,内置jar包,下载即可运行
  • synchronized可以用来同步静态和非静态方法,下面就具体来看一下Java中synchronized关键字修饰方法同步的用法详解:
  • Java 保留字列表 (依字母排序 共14组) : Java保留字是指现有Java版本尚未使用 但以后版本可能会作为关键字使用
  • Java中所有的关键字及用法

    千次阅读 2021-09-16 16:17:06
    基本数据类型: int: int 基本数据类型 ,内存空间占8位 取值范围-128~127 int i=10; float float 基本数据类型 ,内存空间占32位 取值范围 -2^31~-2^31-1 float f=10.0f;...long 基本数据类型 内存空间占 64位 ...

    基本数据类型:

    int:

    int 基本数据类型 ,内存空间占8位  取值范围-128~127          int i=10;

    float

    float 基本数据类型 ,内存空间占32位 取值范围 -2^31-2^31-1      float f=10.0f;

    long

    long 基本数据类型 内存空间占 64位 取值范围    -2^63-2^63-1  long l=10l;

    short

    short 基本数据类型 内存空间占16位 取值范围    -2^15-2^15-1  short s=10;

    byte

    byte 基本数据类型 内存空间占8位 取值范围    -2^7-2^7-1  byte b=10;

    char

    char 基本数据类型 内存空间占16位 取值范围   0-2^16-1  char  c='c';

    double

    double 基本数据类型 内存空间占32位 取值范围  -2^63-2^63-1 double d=10.0d;

    boolean

    boolean 基本数据类型 内存空间占8位 取值范围  true~false boolean b=true;

    权限修饰符:

    public

    Java语言修饰符,翻译为公共的。被public修饰的类,属性和方法不仅可以跨类使用,还可以跨包使用。

    private

    Java语言修饰符,翻译为私有的。是java语言中,访问权限最窄的修饰符。被private修饰的属性和方法,只能由本类使用,其子类不可以访问,更不可以跨包访问。

    default

    Java语言权限修饰符,在java语句中,通常称为 默认修饰符,只允许同包的中的类进行访问。

    protected

    Java语言权限修饰符,在java语句中,介于public和private之间的修饰符,起到保护的作用,即使不是同包的子类也可以访问,被protected修饰的类,方法,属性只能被本身的方法和子类访问。

    条件判断语句:

    if       else

    if用于条件判断,一般配合 elseif  else使用

    public void test(){
    
    int a=10;
    int b=5;
    
    if(a>b){
    sout("a大于b");
    }
    elseif(b>a){
    sout("b大于a");
    }
    else{
    sout("a和b相等");
    }
    
    
    
    }

    switch一般和case和break一起联合使用

    String name="lixiaobin";
    switch(name){
    
    case "lixiaobin":
    sout("lixiaobin");
    break;
    
    case "lixiaobin":
    sout("zhangsan");
    break;
    
    case "lixiaobin":
    sout("lisi");
    break;
    default:
    sout("无效")
    }

    在switch中,查找name相同的值,如果不管找不找得到都break,跳出。

    1、switch分支语句中的表达式可以为byte,short,int,char型,常量值也是byte,short,int,char型,且常量值必须不同。注意:表达式的值不可以是long型数据,否则会导致编译错误。

    2、switch语句中,如果表达式的值和case后面的常量值相同,则执行其后语句,直到遇到break语句或执行至switch完结为止。如果表达式的值和case后面的常量值都不相同,则直接执行default后语句,若无default,switch不会有任何处理。
     

    循环语句

    while

    while一般和else 和continue break一起用

    public void test(){
    
    int i=1;
    whlie(true)
    
    sout(“学习java”);
    i++;
    if(i=5)
    {
    
    break;  
    //i=5的时候跳出循环
    }
    }

    continue

    continue为跳出本次循环

    public class Main {
        public static void main(String[] args) {
            int n=5,j=12;
            while(n<=j){
                System.out.print(n+"\t");
                n++;
                continue;
            }
            System.out.println("n="+n);
        }
    }
    

    do while

    语法结构:
    
    do{
    循环结构
    
    }while(判断条件);
    
    先执行do循环结构里面的代码,然后判断
    
    while里面的条件是否符合,直到不成立为止,
    
    所以do……while至少会被执行一次。

    for 语句 

    public void test(){
    
    int[] integers = {1, 2, 3, 4};
    for (int j = 0; j<integers.length; j++){
    
    int i = integers[j];
    
    System.out.println(i);
    
    }
    
    }

    for语句有一个加强foreach语句

    public void test(){
    
    int[]numbers={1,2,3,4,5,6,7}
    
    for(int num:numbers){
    
        sout(num)
    } 
    }
    
    
    

    abstract

    abstract解释为抽象的 ,可以用来修饰的结构:类、方法。

    Person p1=new Person();//一旦Person类抽象了就不可以实例化了。
    
    abstract class Person{
        
    }

    abstract修饰类:抽象类

    • 此类不能实例化

    • 抽象类中一定有构造器。便于子类实例化时调用、

    • 开发中,都会提供抽象类的子类,让子类对象实例化。完成相关的操作。

    abstract修饰方法:抽象方法。

    抽象方法只有方法的声明,没有方法体。
    包含抽象方法的类,一定是抽象类。反之,类如果是抽象类,不一定有抽象方法。
    若子类重写了父类中的所有的抽象方法后,此子类方可实例化。
    若子类没有重写父类中所有的抽象方法,则此子类也是个抽象类。需要用abstract修饰一下。
     

    static

    static被解释为静态方法,静态方法不需要依赖任何对象就可以访问,所有,对于静态方法来说,是没有this的,但是要注意的是,虽然在静态方法中不能访问非静态成员方法和非静态成员变量,但是在非静态成员方法中是可以访问静态成员方法/变量的。

        public class MyObject {
        	//非静态变量
        	private String str1 ="property";
        	//静态变量
        	private static String str2 ="staticProperty";
        	
        	public MyObject() {
        		
        	}
        	//非静态方法
        	public void print1() {
        		System.out.println(str1);
        		System.out.println(str2);
        		print2();
        	}
        	
        	//静态方法
        	public static  void print2() {
        		//这一句报错,报错信息是Cannot make a static reference to the non-static field str1
        		System.out.println(str1);
        		System.out.println(str2);
        		/*
        		 * 调用非静态的方法会报错,
        		 * Cannot make a static reference to the non-static method print1() from the type MyObject
        		 */
        		print1();
        	}
        }
    

    final

    1.当用final修饰一个类的时候,这个类不能被继承,如果你想让一个类永远不被继承,那么就可以用final修饰。final类中的成员变量需要根据需要设为final,但是要注意,final类中的所有成员方法都会被隐式的指定为final方法。

    finally

    是在异常处理时提供finally块来执行任何清除操作。不管有没有异常被抛出、捕获,finally块都会被执行。try块中的内容是在无异常时执行到结束。catch块中的内容,是在try块内容发生catch所声明的异常时,跳转到catch块中执行。finally块则是无论异常是否发生,都会执行finally块的内容,所以在代码逻辑中有需要无论发生什么都必须执行的代码,就可以放在finally块中。
     

    finalize

    finalize是方法名。java技术允许使用finalize()方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在object类中定义的,因此所有的类都继承了它。子类覆盖finalize()方法以整理系统资源或者被执行其他清理工作。finalize()方法是在垃圾收集器删除对象之前对这个对象调用的。
     

    extends

    在java中,extends是继承。 a extends b。 此处a为子类,b为父类。

    在java中,一个子类只可以有一个父类,但是一个父类可以有多个子类。

    super

    1.子类重写父类的方法。

    public class A {
    	
    	private String nameA="A";
    	
    	public void getName() {
    		System.out.println("父类"+nameA);
    	}
    	public static void main(String[] args) {
    	}
    	
    }
     
     
    public class B extends A{
    	private String nameB="B";
    	
    	@Override
    	public void getName() {
    		System.out.println("子类"+nameB);
    		super.getName();
    	}
    	
    	public static void main(String[] args) {
    		B b=new B();
    		b.getName();
    	
    	}
    }

    输出结果:

    子类B

    父类A

    在子类B中,我们重写了父类的getName()方法,如果在重新的getName方法中我们去调用父类的相同方法,必须要通过super关键字显示的指明出来。

    如果不表明出来,按照子类的优先原则,相当于还是在调用重写的getName方法,就形成了死循环。

    2.子类重新父类的变量。

    public class A {
    	
    	 String nameA="A";
     
    }
     
    public class B extends A{
    	 String nameA="B";
    	
    	
    	public void getName() {
    		System.out.println("子类"+nameA);
    		System.out.println("父类"+super.nameA);
    	}
    	
    	public static void main(String[] args) {
    		B b=new B();
    		b.getName();
    	
    	}
    }

    输出结果:

    子类B

    父类A

    在这段代码中,把B赋值给nameA。重写了父类的变量。在调用时,为了区分哪个是子类的变量,哪个是父类的变量,在父类变量前面加 super,指明这个是父类的变量

    3.在子类的构造方法中。

    1、调用父类被子类重写的方法;

    2、调用父类被子类重定义的字段(被隐藏的成员变量);

    3、调用父类的构造方法;

    其他情况,由于子类自动继承了父类相应属性方法,关键字super可以不显示写出来。

    4.关于构造器方法中的super

    如果一个类中没有写任何的构造方法,JVM会生成一个默认的无参构造方法。在继承关系中,由于在子类的构造方法中,在继承关系中,由于在子类的构造方法中,第一条语句默认为调用父类的无参构造方法(即默认为super(),一般这句话省略了)所以当在父类中定义了有参构造函数,还是没有定义无参构造函数时,IDE会强制要求我们定义一个相同参数类型的构造器。

    第一种情况:编译不通过

     不能直接继承A类,因为A类中存在有参构造函数

    第二种情况:编译不通过

     重写有参函数以后,还是报错,因为在子类的构造方法中,系统会默认这个有参函数是父类的,不是子类的。

    第三中情款:编译通过

     在子类的方法体中,调用super,这样就可以区分出来。哪个是父类的方法,哪个是子类的方法。

    异常处理:

    throw
    就是自己进行异常处理,throw一旦进入被执行,程序立即会转入异常处理阶段,后面的语句就不再执行, 而且所在的方法不再返回有意义的值!

    throws

    用来声明一个方法可能抛出的所有异常信息,将异常声明但是不处理,而是将异常往上传,谁调用我就 交给谁处理。

    try

    出现在方法体中,它自身是一个代码块,表示尝试执行代码块的语句。如果在执行过程中有某条语句抛出异 常,那么代码块后面的语句将不被执行

    catch

    出现在try代码块的后面,自身也是一个代码块,用于捕获异常try代码块中可能抛出的异常。catch关键字 后面紧接着它能捕获的异常类型,所有异常类型的子类异常也能被捕获。

    finally

    是在异常处理时提供finally块来执行任何清除操作。不管有没有异常被抛出、捕获,finally块都会被执行。try块中的内容是在无异常时执行到结束。catch块中的内容,是在try块内容发生catch所声明的异常时,跳转到catch块中执行。finally块则是无论异常是否发生,都会执行finally块的内容,所以在代码逻辑中有需要无论发生什么都必须执行的代码,就可以放在finally块中。

    this

         this关键字主要有三个应用:

    1. this调用本类中的属性,也就是类中的成员变量;
    2. this调用本类中的其他方法;
    3. this调用本类中的其他构造方法,调用时要放在构造方法的首行。

    调用成员变量

    public class Student{
        String name;
        private void SetName(String name){
            this.name = name;
        }
    }

    调用成员方法

    public class ThisTest {
        String name;
    
       private void setName(String name) {
            this.name = name;
            System.out.println("setName: " + this.name);
        }
    
    
        private void thisTest(String name) {
            this.setName(name);
            System.out.println("thisTest: " + this.name);
        }
    
        public static void main(String[] args) {
            ThisTest tt = new ThisTest();
    
            tt.setName("Yida");
            tt.thisTest("Jenny");
    
        }
    }
    

    调用构造方法

    public class Student { //定义一个类,类的名字为student。 
        public Student() { //定义一个方法,名字与类相同故为构造方法
            this(“Hello!”);
        }
        public Student(String name) { //定义一个带形式参数的构造方法
        }
    }
    

    package

    在package是包名

    return

    java中的return语句总是和方法有密切关系,return语句总是用在方法中,有两个作用,一个是返回值方法指定的类型的值(这个值总是确定的),一个是结束方法的执行(仅仅返回一个return)。

    return 有两种形式。

    一个是有返回值类型的,另一个是没有返回值类型的。

    一般方法前有void代表无返回值,没有void有返回值。

    public class TestReturn { 
        public static void main(String args[]) { 
           TestReturn t = new TestReturn(); 
            t.test1(); 
            System.out.println(t.test2()); 
        } 
     
     
        /** 
         * 无返回值类型的return语句测试 
         */ 
        public void test1() { 
            System.out.println("---------无返回值类型的return语句测试--------"); 
            for (int i = 1; ; i++) { 
                if (i == 4) return; 
                System.out.println("i = " + i); 
            } 
            //System.out.println("hello,this world");此句不能执行,不可达代码
        } 
     
     
        /** 
         * 有返回值类型的return语句测试 
         * @return String 
         */ 
        public String test2(){ 
            System.out.println("---------有返回值类型的return语句测试--------"); 
            return "返回一个字符串"; 
        } 
    }
    

    new

    new被翻译为“新的”。 在java中,创建一个实例,或者说有一个新的对象,都需要new。在new之前,它的属性,方法在内存中是不存在的。只有使用new之后,这个类的东西才会真实存在在内存中存在的,也就是说new出来之后,才能使用。

    interface

    在java中,interface被翻译为接口。

    在java中使用inplements关键字实现接口,并重写接口中的方法。

    inplements

    inplements也可以用作类的继承,不常用!

    类 A 继承 类 B 写成 class A implements B{}.

    class

    一般在java中,class用来创建对象。

    有三种获得Class对象的方式:

    1. Class.forName(“类的全限定名”)
    2. 实例对象.getClass()
    3. 类名.class (类字面常量)

    void

    在java中,void表示为null。所有没有返回值的方法都使用它来表示返回值类型。

    Void是void的封装类型,API上称其为占用符(placeholder)。

    声明一个 Void 变量通常是没有什么意义的,因为没有可为其赋值的实例,注意不能用 void 为其赋值(void 是类型而不是值)。
    Void 变量唯一能持有的是 null。

    import

    import就是在java文件开头的地方,先说明会用到那些类别。
    接着我们就能在代码中只用类名指定某个类,也就是只称呼名字,不称呼他的姓。

    在程序开头写

    import java.lang.System;

    import java.io.InputStream;

    import java.io.InputStreamReader;

    import java.io.BufferedReader;

    synchronized

    • 修饰实例方法,作用于当前实例加锁,进入同步代码前要获得当前实例的锁

    • 修饰静态方法,作用于当前类对象加锁,进入同步代码前要获得当前类对象的锁

    • 修饰代码块,指定加锁对象,对给定对象加锁,进入同步代码库前要获得给定对象的锁。

    作用于实例方法

    public class AccountingSync implements Runnable{
        //共享资源(临界资源)
        static int i=0;
    
        /**
         * synchronized 修饰实例方法
         */
        public synchronized void increase(){
            i++;
        }
        @Override
        public void run() {
            for(int j=0;j<1000000;j++){
                increase();
            }
        }
        public static void main(String[] args) throws InterruptedException {
            AccountingSync instance=new AccountingSync();
            Thread t1=new Thread(instance);
            Thread t2=new Thread(instance);
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println(i);
        }
        /**
         * 输出结果:
         * 2000000
         */
    }
    

    修饰静态方

    public class AccountingSyncClass implements Runnable{
        static int i=0;
    
        /**
         * 作用于静态方法,锁是当前class对象,也就是
         * AccountingSyncClass类对应的class对象
         */
        public static synchronized void increase(){
            i++;
        }
    
        /**
         * 非静态,访问时锁不一样不会发生互斥
         */
        public synchronized void increase4Obj(){
            i++;
        }
    
        @Override
        public void run() {
            for(int j=0;j<1000000;j++){
                increase();
            }
        }
        public static void main(String[] args) throws InterruptedException {
            //new新实例
            Thread t1=new Thread(new AccountingSyncClass());
            //new心事了
            Thread t2=new Thread(new AccountingSyncClass());
            //启动线程
            t1.start();t2.start();
    
            t1.join();t2.join();
            System.out.println(i);
        }
    }

    修饰代码块

    public class AccountingSync implements Runnable{
        static AccountingSync instance=new AccountingSync();
        static int i=0;
        @Override
        public void run() {
            //省略其他耗时操作....
            //使用同步代码块对变量i进行同步操作,锁对象为instance
            synchronized(instance){
                for(int j=0;j<1000000;j++){
                        i++;
                  }
            }
        }
        public static void main(String[] args) throws InterruptedException {
            Thread t1=new Thread(instance);
            Thread t2=new Thread(instance);
            t1.start();t2.start();
            t1.join();t2.join();
            System.out.println(i);
        }
    }
    

    strictfp (不常用)

    trictfp的意思是FP-strict,也就是说精确浮点的意思。在Java虚拟机进行浮点运算时,如果没有指定strictfp关键字时,Java的编译器以及运行环境在对浮点运算的表达式是采取一种近似于我行我素的行为来完成这些操作,以致于得到的结果往往无法令你满意。而一旦使用了strictfp来声明一个类、接口或者方法时,那么所声明的范围内Java的编译器以及运行环境会完全依照浮点规范IEEE-754来执行。因此如果你想让你的浮点运算更加精确,而且不会因为不同的硬件平台所执行的结果不一致的话,那就请用关键字strictfp。
    你可以将一个类、接口以及方法声明为strictfp,但是不允许对接口中的方法以及构造函数声明strictfp关键字。

    volatile(JMM线程安全的保证)

    volatile 是java虚拟机提供的轻量级同步机制

    transient

    (1)序列化
          Java中对象的序列化指的是将对象转换成以字节序列的形式来表示,这些字节序列包含了对象的数据和信息,一个序列化后的对象可以被写到数据库或文件中,也可用于网络传输。一般地,当我们使用缓存cache(内存空间不够有可能会本地存储到硬盘)或远程调用rpc(网络传输)的时候,经常需要让实体类实现Serializable接口,目的就是为了让其可序列化。当然,序列化后的最终目的是为了反序列化,恢复成原先的Java对象实例。所以序列化后的字节序列都是可以恢复成Java对象的,这个过程就是反序列化。
     
    (2)为什么要用transient关键字?
          在持久化对象时,对于一些特殊的数据成员(如用户的密码,银行卡号等),我们不想用序列化机制来保存它。为了在一个特定对象的一个成员变量上关闭序列化,可以在这个成员变量前加上关键字transient。
     
    (3)transient的作用
          transient是Java语言的关键字,用来表示一个成员变量不是该对象序列化的一部分。当一个对象被序列化的时候,transient型变量的值不包括在序列化的结果中。而非transient型的变量是被包括进去的。   注意static修饰的静态变量天然就是不可序列化的。
     

    goto 非常不常用

    Java中对标签的功能进行了限制,使它只能对迭代语句起作用,唯一的作用就是跳出循环嵌套

    展开全文
  • 主要介绍了Java super关键字调用父类过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了java实现查找PDF关键字所在页码及其坐标的方法,本文通过实例代码给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下
  • 主要介绍了Java编程实现提取文章中关键字方法,较为详细的分析了Java提取文章关键字的原理与具体实现技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • Java static关键字详解

    万次阅读 多人点赞 2018-08-07 17:30:21
    static关键字 在类中,用static声明的成员变量为静态成员变量,也成为类变量。类变量的生命周期和类相同,在整个应用程序执行期间都有效。 这里要强调一下: static修饰的成员变量和方法,从属于类 普通变量和...
  • synchronized关键字我们大家都知道是线程同步关键字.总结一下日常的使用方法,还有一个坑.
  • 主要介绍了java private关键字用法实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Java中Finally关键字

    2020-09-02 07:16:19
    与其他语言的模型相比,finally 关键字是对 Java 异常处理模型的最佳补充。接下来通过本文给大家介绍Java中Finally关键字及finally关键字的使用相关知识,感兴趣的朋友一起学习吧
  • Java super关键字(超详细!)

    万次阅读 多人点赞 2021-04-20 19:13:00
    super是一个关键字,全部小写。 2.怎么学?super和this对比着学习。 this: this能出现在实例方法和构造方法中。 this的语法是:“this.”、“this()” this 不能 使用在静态方法中。 this. 大部分情况下是可以省略...
  • java关键字

    2019-04-22 20:06:12
    java关键字 关键字也称为保留字,是指java语言中规定了特定含义的标示符。对于保留字,用户只能按照系统规定的方式使用,不能自行定义。Java中有50个常用关键字:

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 869,328
精华内容 347,731
关键字:

java 方法关键字

java 订阅