精华内容
下载资源
问答
  • 一:super关键字1:构造方法中的super关键字Java子类的构造方法中可以通过super关键字来调用父类的构造方法。其用法为:1) super(); 访问父类中的无参构造函数2) super (paras…); 用来调用父类中某个有参的构造...

    一:super关键字

    1:构造方法中的super关键字

    在Java子类的构造方法中可以通过super关键字来调用父类的构造方法。其用法为:

    1) super(); 访问父类中的无参构造函数

    2) super (paras…); 用来调用父类中某个有参的构造方法

    super()来调用父类无参的构造方法,但即使不使用super(),默认也会调用父类无参的构造方法。父类无参的构造方法可以是自定义的无参构造方法,也可以是编译器自动生成的默认构造方法。但如果父类中定义了有参的构造方法,但没有定义无参的构造方法,这时编译器不会生成默认构造函数,也就不能通过super()来调用构造方法。此外,如果父类中定义了private的无参构造方法,也不同通过super()来调用。

    super调用父类的构造方法,必须放在子类构造方法的第一行中执行。如果调用的有参的父类构造方法,在super的参数中不能用子类中的非static成员变量(可以使用static成员变量,因为static成员变量在构造方法执行前就已经初始化),也不能使用this或super的相关调用。例如super(super.getClass().getName());

    在构造方法中也可以使用super关键字来访问父类中的成员变量和成员函数。其用法和非构造方法中的super关键字用法相同。

    2:非构造方法中的super关键字

    在Java子类中可以通过通过super关键字来调用父类中的成员变量和方法。其用法是。

    1) super.xxx; 访问父类中的成员变量xxx

    2) super.yyy(paras…); 访问父类中的成员函数yyy

    super关键字访问父类的成员变量和成员函数时不能越过访问权限的控制,不能访问父类中private的成员变量和方法在有多层的继承关系时,super调用只能自身父类的成员变量和方法,不能越过父类直接调用父类的父类中的成员变量或方法。当然如果父类的父类中的成员变量或方法被父类继承,那么是可以通过super来调用该成员变量和方法的,但这时实际调用的是父类中的成员变量和方法。

    展开全文
  • Java语言包含两种内在的同步机制:同步块(或方法)和volatile变量,相比于synchronized(synchronized通常称为重量级锁),volatile更轻量级,因为它不会引起线程上下文的切换和调度。但是volatile变量的同步性较差...

    目录

    一、简介

    二、并发编程的3个基本概念

    三、锁的互斥和可见性

    四、Java的内存模型JMM以及共享变量的可见性

    五、volatile变量的特性

    六、volatile不适用的场景

    七、volatile原理

    八、单例模式的双重锁为什么要加volatile


    一、简介

    volatile是Java提供的一种轻量级的同步机制。Java 语言包含两种内在的同步机制:同步块(或方法)和 volatile 变量,相比于synchronized(synchronized通常称为重量级锁),volatile更轻量级,因为它不会引起线程上下文的切换和调度。但是volatile 变量的同步性较差(有时它更简单并且开销更低),而且其使用也更容易出错。

    二、并发编程的3个基本概念

    1.原子性

         定义即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断,要么就都不执行

        原子性是拒绝多线程操作的,不论是多核还是单核,具有原子性的量,同一时刻只能有一个线程来对它进行操作。简而言之,在整个操作过程中不会被线程调度器中断的操作,都可认为是原子性。例如 a=1是原子性操作,但是a++和a +=1就不是原子性操作。Java中的原子性操作包括:

    (1)基本类型的读取和赋值操作,且赋值必须是值赋给变量,变量之间的相互赋值不是原子性操作。

    (2)所有引用reference的赋值操作

    (3)java.concurrent.Atomic.* 包中所有类的一切操作

    2.可见性

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

       在多线程环境下,一个线程对共享变量的操作对其他线程是不可见的。Java提供了volatile来保证可见性,当一个变量被volatile修饰后,表示着线程本地内存无效,当一个线程修改共享变量后他会立即被更新到主内存中,其他线程读取共享变量时,会直接从主内存中读取。当然,synchronize和Lock都可以保证可见性。synchronized和Lock能保证同一时刻只有一个线程获取锁然后执行同步代码,并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。

    3.有序性

       定义:即程序执行的顺序按照代码的先后顺序执行。

       Java内存模型中的有序性可以总结为:如果在本线程内观察,所有操作都是有序的;如果在一个线程中观察另一个线程,所有操作都是无序的。前半句是指“线程内表现为串行语义”,后半句是指“指令重排序”现象和“工作内存主主内存同步延迟”现象。

       在Java内存模型中,为了效率是允许编译器和处理器对指令进行重排序,当然重排序不会影响单线程的运行结果,但是对多线程会有影响。Java提供volatile来保证一定的有序性。最著名的例子就是单例模式里面的DCL(双重检查锁)。另外,可以通过synchronized和Lock来保证有序性,synchronized和Lock保证每个时刻是有一个线程执行同步代码,相当于是让线程顺序执行同步代码,自然就保证了有序性。

    三、锁的互斥和可见性

       锁提供了两种主要特性:互斥(mutual exclusion) 和可见性(visibility)。

    (1)互斥即一次只允许一个线程持有某个特定的锁,一次就只有一个线程能够使用该共享数据。

    (2)可见性要更加复杂一些,它必须确保释放锁之前对共享数据做出的更改对于随后获得该锁的另一个线程是可见的。也即当一条线程修改了共享变量的值,新值对于其他线程来说是可以立即得知的如果没有同步机制提供的这种可见性保证,线程看到的共享变  量可能是修改前的值或不一致的值,这将引发许多严重问题。要使 volatile 变量提供理想的线程安全,必须同时满足下面两个条件:

        a.对变量的写操作不依赖于当前值。

        b.该变量没有包含在具有其他变量的不变式中。

      实际上,这些条件表明,可以被写入 volatile 变量的这些有效值独立于任何程序的状态,包括变量的当前状态。事实上就是保证操作是原子性操作,才能保证使用volatile关键字的程序在并发时能够正确执行。

    四、Java的内存模型JMM以及共享变量的可见性

     JMM决定一个线程对共享变量的写入何时对另一个线程可见,JMM定义了线程和主内存之间的抽象关系:共享变量存储在主内存(Main Memory)中,每个线程都有一个私有的本地内存(Local Memory),本地内存保存了被该线程使用到的主内存的副本拷贝,线程对变量的所有操作都必须在工作内存中进行,而不能直接读写主内存中的变量。

       对于普通的共享变量来讲,线程A将其修改为某个值发生在线程A的本地内存中,此时还未同步到主内存中去;而线程B已经缓存了该变量的旧值,所以就导致了共享变量值的不一致。解决这种共享变量在多线程模型中的不可见性问题,较粗暴的方式自然就是加锁,但是此处使用synchronized或者Lock这些方式太重量级了,比较合理的方式其实就是volatile。

      需要注意的是,JMM是个抽象的内存模型,所以所谓的本地内存,主内存都是抽象概念,并不一定就真实的对应cpu缓存和物理内存

    五、volatile变量的特性

     1.保证可见性,不保证原子性

      (1)当写一个volatile变量时,JMM会把该线程本地内存中的变量强制刷新到主内存中去;

      (2)这个写会操作会导致其他线程中的volatile变量缓存无效。

     2.禁止指令重排

        重排序是指编译器和处理器为了优化程序性能而对指令序列进行排序的一种手段。重排序需要遵守一定规则:

     (1)重排序操作不会对存在数据依赖关系的操作进行重排序。

      比如:a=1;b=a; 这个指令序列,由于第二个操作依赖于第一个操作,所以在编译时和处理器运行时这两个操作不会被重排序。

     (2)重排序是为了优化性能,但是不管怎么重排序,单线程下程序的执行结果不能被改变

      比如:a=1;b=2;c=a+b这三个操作,第一步(a=1)和第二步(b=2)由于不存在数据依赖关系, 所以可能会发生重排序,但是c=a+b这个操作是不会被重排序的,因为需要保证最终的结果一定是c=a+b=3。

        重排序在单线程下一定能保证结果的正确性,但是在多线程环境下,可能发生重排序,影响结果,下例中的1和2由于不存在数据依赖关系,则有可能会被重排序,先执行status=true再执行a=2。而此时线程B会顺利到达4处,而线程A中a=2这个操作还未被执行,所以b=a+1的结果也有可能依然等于2。

    public class TestVolatile{
    	int a = 1;
    	boolean status = false;
    	
    	//状态切换为true
    	public void changeStatus{
    		a = 2;   //1
    		status = true;  //2
    	}
    	
    	//若状态为true,则为running
    	public void run(){
    		if(status){   //3
    			int b = a + 1;  //4
    			System.out.println(b);
    		}
    	}
    
    }

         使用volatile关键字修饰共享变量便可以禁止这种重排序。若用volatile修饰共享变量,在编译时,会在指令序列中插入内存屏障来禁止特定类型的处理器重排序,volatile禁止指令重排序也有一些规则:

         a.当程序执行到volatile变量的读操作或者写操作时,在其前面的操作的更改肯定全部已经进行,且结果已经对后面的操作可见;在其后面的操作肯定还没有进行;

         b.在进行指令优化时,不能将对volatile变量访问的语句放在其后面执行,也不能把volatile变量后面的语句放到其前面执行。

         即执行到volatile变量时,其前面的所有语句都执行完,后面所有语句都未执行。且前面语句的结果对volatile变量及其后面语句可见。

    六、volatile不适用的场景

     1.volatile不适合复合操作

      例如,inc++不是一个原子性操作,可以由读取、加、赋值3步组成,所以结果并不能达到30000。.

      2.解决方法

     (1)采用synchronized

     (2)采用Lock

     (3)采用java并发包中的原子操作类,原子操作类是通过CAS循环的方式来保证其原子性的

    七、volatile原理

      volatile可以保证线程可见性且提供了一定的有序性,但是无法保证原子性。在JVM底层volatile是采用“内存屏障”来实现的。观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现,加入volatile关键字时,会多出一个lock前缀指令,lock前缀指令实际上相当于一个内存屏障(也成内存栅栏),内存屏障会提供3个功能:

    (1)它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置,也不会把前面的指令排到内存屏障的后面;即在执行到内存屏障这句指令时,在它前面的操作已经全部完成;

    (2)它会强制将对缓存的修改操作立即写入主存;

    (3)如果是写操作,它会导致其他CPU中对应的缓存行无效。

    八、单例模式的双重锁为什么要加volatile

    public class TestInstance{
    	private volatile static TestInstance instance;
    	
    	public static TestInstance getInstance(){        //1
    		if(instance == null){                        //2
    			synchronized(TestInstance.class){        //3
    				if(instance == null){                //4
    					instance = new TestInstance();   //5
    				}
    			}
    		}
    		return instance;                             //6
    	}
    }

     

       需要volatile关键字的原因是,在并发情况下,如果没有volatile关键字,在第5行会出现问题。instance = new TestInstance();可以分解为3行伪代码

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

       上面的代码在编译运行时,可能会出现重排序从a-b-c排序为a-c-b。在多线程的情况下会出现以下问题。当线程A在执行第5行代码时,B线程进来执行到第2行代码。假设此时A执行的过程中发生了指令重排序,即先执行了a和c,没有执行b。那么由于A线程执行了c导致instance指向了一段地址,所以B线程判断instance不为null,会直接跳到第6行并返回一个未初始化的对象。

    展开全文
  • Java transient关键字

    2017-08-03 14:24:12
    Java transient关键字@(JAVA)[java]Java transient关键字 transient的作用及使用方法 transient使用小结 transient使用细节被transient关键字修饰的变量真的不能被序列化吗 transient关键字用于修饰一个类的成员变量...

    Java transient关键字

    @(JAVA)[java]

    transient关键字用于修饰一个类的成员变量时,这个变量的值不会被序列化,这可以用于一些敏感信息,如密码等。

    此外,用static关键字修饰的变量也不会被序列化。

    以下内容转载自http://www.cnblogs.com/lanxuezaipiao/p/3369962.html

    1. transient的作用及使用方法

    我们都知道一个对象只要实现了Serilizable接口,这个对象就可以被序列化,java的这种序列化模式为开发者提供了很多便利,我们可以不必关系具体序列化的过程,只要这个类实现了Serilizable接口,这个类的所有属性和方法都会自动序列化。

    然而在实际开发过程中,我们常常会遇到这样的问题,这个类的有些属性需要序列化,而其他属性不需要被序列化,打个比方,如果一个用户有一些敏感信息(如密码,银行卡号等),为了安全起见,不希望在网络操作(主要涉及到序列化操作,本地序列化缓存也适用)中被传输,这些信息对应的变量就可以加上transient关键字。换句话说,这个字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。

    总之,java 的transient关键字为我们提供了便利,你只需要实现Serilizable接口,将不需要序列化的属性前添加关键字transient,序列化对象的时候,这个属性就不会序列化到指定的目的地中。

    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    /**
     * @description 使用transient关键字不序列化某个变量
     *        注意读取的时候,读取数据的顺序一定要和存放数据的顺序保持一致
     *        
     * @author Alexia
     * @date  2013-10-15
     */
    public class TransientTest {
    
        public static void main(String[] args) {
    
            User user = new User();
            user.setUsername("Alexia");
            user.setPasswd("123456");
    
            System.out.println("read before Serializable: ");
            System.out.println("username: " + user.getUsername());
            System.err.println("password: " + user.getPasswd());
    
            try {
                ObjectOutputStream os = new ObjectOutputStream(
                        new FileOutputStream("C:/user.txt"));
                os.writeObject(user); // 将User对象写进文件
                os.flush();
                os.close();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                ObjectInputStream is = new ObjectInputStream(new FileInputStream(
                        "C:/user.txt"));
                user = (User) is.readObject(); // 从流中读取User的数据
                is.close();
    
                System.out.println("\nread after Serializable: ");
                System.out.println("username: " + user.getUsername());
                System.err.println("password: " + user.getPasswd());
    
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
    
    class User implements Serializable {
        private static final long serialVersionUID = 8294180014912103005L;  
    
        private String username;
        private transient String passwd;
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public String getPasswd() {
            return passwd;
        }
    
        public void setPasswd(String passwd) {
            this.passwd = passwd;
        }
    
    }
    

    输出为:

    read before Serializable: 
    username: Alexia
    password: 123456
    
    read after Serializable: 
    username: Alexia
    password: null
    

    密码字段为null,说明反序列化时根本没有从文件中获取到信息。

    2. transient使用小结

    1)一旦变量被transient修饰,变量将不再是对象持久化的一部分,该变量内容在序列化后无法获得访问。

    2)transient关键字只能修饰变量,而不能修饰方法和类。注意,本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量,则该类需要实现Serializable接口。

    3)被transient关键字修饰的变量不再能被序列化,一个静态变量不管是否被transient修饰,均不能被序列化。

    第三点可能有些人很迷惑,因为发现在User类中的username字段前加上static关键字后,程序运行结果依然不变,即static类型的username也读出来为“Alexia”了,这不与第三点说的矛盾吗?实际上是这样的:第三点确实没错(一个静态变量不管是否被transient修饰,均不能被序列化),反序列化后类中static型变量username的值为当前JVM中对应static变量的值,这个值是JVM中的不是反序列化得出的,不相信?好吧,下面我来证明:

    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    /**
     * @description 使用transient关键字不序列化某个变量
     *        注意读取的时候,读取数据的顺序一定要和存放数据的顺序保持一致
     *        
     * @author Alexia
     * @date  2013-10-15
     */
    public class TransientTest {
    
        public static void main(String[] args) {
    
            User user = new User();
            user.setUsername("Alexia");
            user.setPasswd("123456");
    
            System.out.println("read before Serializable: ");
            System.out.println("username: " + user.getUsername());
            System.err.println("password: " + user.getPasswd());
    
            try {
                ObjectOutputStream os = new ObjectOutputStream(
                        new FileOutputStream("C:/user.txt"));
                os.writeObject(user); // 将User对象写进文件
                os.flush();
                os.close();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                // 在反序列化之前改变username的值
                User.username = "jmwang";
    
                ObjectInputStream is = new ObjectInputStream(new FileInputStream(
                        "C:/user.txt"));
                user = (User) is.readObject(); // 从流中读取User的数据
                is.close();
    
                System.out.println("\nread after Serializable: ");
                System.out.println("username: " + user.getUsername());
                System.err.println("password: " + user.getPasswd());
    
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
    
    class User implements Serializable {
        private static final long serialVersionUID = 8294180014912103005L;  
    
        public static String username;
        private transient String passwd;
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public String getPasswd() {
            return passwd;
        }
    
        public void setPasswd(String passwd) {
            this.passwd = passwd;
        }
    
    }
    

    运行结果为:

    read before Serializable: 
    username: Alexia
    password: 123456
    
    read after Serializable: 
    username: jmwang
    password: null
    

    这说明反序列化后类中static型变量username的值为当前JVM中对应static变量的值,为修改后jmwang,而不是序列化时的值Alexia。

    3. transient使用细节——被transient关键字修饰的变量真的不能被序列化吗?

    思考下面的例子:

    import java.io.Externalizable;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInput;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutput;
    import java.io.ObjectOutputStream;
    
    /**
     * @descripiton Externalizable接口的使用
     * 
     * @author Alexia
     * @date 2013-10-15
     *
     */
    public class ExternalizableTest implements Externalizable {
    
        private transient String content = "是的,我将会被序列化,不管我是否被transient关键字修饰";
    
        @Override
        public void writeExternal(ObjectOutput out) throws IOException {
            out.writeObject(content);
        }
    
        @Override
        public void readExternal(ObjectInput in) throws IOException,
                ClassNotFoundException {
            content = (String) in.readObject();
        }
    
        public static void main(String[] args) throws Exception {
    
            ExternalizableTest et = new ExternalizableTest();
            ObjectOutput out = new ObjectOutputStream(new FileOutputStream(
                    new File("test")));
            out.writeObject(et);
    
            ObjectInput in = new ObjectInputStream(new FileInputStream(new File(
                    "test")));
            et = (ExternalizableTest) in.readObject();
            System.out.println(et.content);
    
            out.close();
            in.close();
        }
    }
    

    content变量会被序列化吗?好吧,我把答案都输出来了,是的,运行结果就是:

    是的,我将会被序列化,不管我是否被transient关键字修饰

    这是为什么呢,不是说类的变量被transient关键字修饰以后将不能序列化了吗?

    我们知道在Java中,对象的序列化可以通过实现两种接口来实现,若实现的是Serializable接口,则所有的序列化将会自动进行,若实现的是Externalizable接口,则没有任何东西可以自动序列化,需要在writeExternal方法中进行手工指定所要序列化的变量,这与是否被transient修饰无关。因此第二个例子输出的是变量content初始化的内容,而不是null。

    展开全文
  • JAVA关键字

    2018-03-29 17:02:48
    1.java关键字(keyword)由多少个? 51+2个保留字=53个关键字java关键字都是小写的)2.java的保留字(reserve word)有多少个 2个保留字 const 用于修改字段或者局部变量的声明。它指定字段或者局部变量的值是...
    1.java的关键字(keyword)由多少个?
    51+2个保留字=53个关键字(java的关键字都是小写的)
    2.java的保留字(reserve word)有多少个
    2个保留字
    const 用于修改字段或者局部变量的声明。它指定字段或者局部变量的值是常数,不能被修改
    goto 指定跳转到标签
    3.访问修饰关键字
    public 公有的 可以跨包
    protected 受保护的 当前包内可用
    private 私有的 当前类可用
    4.定义类,接口,抽象类和实现接口,继承关系,实例化对象
    class 类 public class A(){}大括号里有已实现方法体,类名需要与文件名相同。
    interface 接口 public interface B (){} 大括号里有方法体,但没有实现,方法后面用分号结束。
    abstract 抽象类 public abstract B (){} 介于类与接口中间,可以有也可以没有中自己的已经实现的方法体。
    implement 实现 用于类或者接口实现接口
    extends 继承 用于继承类
    new 创建一个类
    5.包的关键字
    import 引入包的关键字。
    package 定义包的关键字
    6.数据类型关键字
    byte 字节型 一个字节
    char 字符型 2个字节
    boolean 布尔型
    shot 短整形 2个字节
    int 整形 4个字节
    long 长整形 8个字节
    float 浮点数(单精度) 4个字节
    double 双精度 8个字节
    void 表示当前方法没有返回 其他 的 与return 配合使用
    null 表示空值
    true 真
    false 假
    7.条件循环(流程控制)
    if 如果 if(){}如果小括号里面的值为真的时候,大括号就执行
    else 否则 常与if连用,用法相同
    while 当什么时候 while(){}小括号的条件成立了,大括号就执行
    for 一个条件 for(;;){}
    switch case default 开关判断
    eg:switch(表达式)
    {
    case 常量表达式1:语句1;
    case 常量表达式2:语句2;
    ......
    default :语句;//可以省略
    }
    do 运行 常与while连用 do {} while();
    break 跳出循环
    continue 继续 中断本次循环,并开始下一次。
    return 返回 return 一个返回值类型 还可以做终止使用。
    instanceof 实例 一个二元操作符 和==,>,<是同一类的, 这个对象是否是这个特定类或者是它的子类的一个实例,返回boolean类型的数据。

    符:break与continue的区别:

    break;是跳出整个循环,continue 是结束本次循环,继续下面的循环的
    8.修饰方法,类,属性和变量
    static 静态的
    fianl 最终的不可以被改变的
    super 调用父类的方法
    this 当前对象的引用
    native 本地
    strictfp 严格,精准的
    synchronized 线程,同步
    transient 短暂
    volatile 易失


    9.异常处理
    try catch finally
    throw 抛出一个异常对象 throw new exception("a为null"); 语句处理异常
    throws 声明一个异常可能被抛出 异常交给他的上级管理,自己不进行异常处理。 方法抛出异常


    10.其他
    enume 枚举类申明
    eg:public enum Color {
    RED,BULE,GREEN,BLACK;
    }
    assert 断言
    展开全文
  • Java关键字及保留字

    千次阅读 2020-01-01 18:36:15
    Java关键字及保留字Java关键字及保留字Java关键字Java关键字列表访问控制修饰符(共3个)类、方法和变量修饰符(共15个)程序控制语句(共12个)错误处理(共5个)包相关(共2个)基本类型(共10个)其他(共...
  • Java this 关键字用法

    万次阅读 多人点赞 2015-03-21 13:42:12
    介绍Java中this关键字的用法,包括在构造方法中this关键字的用法,非在构造方法中this关键字的用法,继承关系下this关键字含义的变化,以及super和this关键字的异同。
  • Java并发关键字-volatile

    千次阅读 多人点赞 2019-10-06 18:40:18
    文章目录volatile简介volatile...在上一篇文章中我们深入理解了Java关键字-synchronized,我们知道在java中还有一大神器就是关键volatile,可以说是和synchronized各领风骚,其中奥妙,我们来共同探讨下。 通过上一...
  • JAVA 常用关键字

    2020-10-10 15:32:16
    1 关键字概念:被java语言赋予特定含义的单词  2 关键字的特点:全部小写:有特俗的颜色标记  3 学一个记一个, 不需要特意去记所有的关键字 定义数据类型关键字  /* 定义数据类型关键字  * class  * interface...
  • Java volatile关键字

    2014-05-23 21:14:16
    Java volatile关键字java线程并发处理中,有一个关键字volatile的使用目前存在很大的混淆,以为使用这个关键字,在进行多线程并发处理的时候就可以万事大吉。 Java语言是支持多线程的,为了解决线程并发的问题...
  • java关键字和保留字

    千次阅读 2018-12-28 22:13:18
    关键字和保留字的区别  正确识别java语言的...保留字是为java预留的关键字,他们虽然现在没有作为关键字,但在以后的升级版本中有可能作为关键字。  识别java语言的关键字,不要和其他语言如c/c++的关键字混淆。...
  • Java import关键字

    2016-08-01 09:36:08
    Java import关键字参考:http://www.educity.cn/java/500811.html简单的说package就是为了要区分相同的类名,而import的作用就是帮你把类名前面的package补上,编译器看到没有package的类就回到java.lang里找,所以...
  • java关键字

    2021-05-22 22:45:54
    关键字(keyword): 定义:用作专门用途的字符串(单词) 特点:关键字中所有的字母都为小写 用于定义数据类型的关键字 class interface enum byte short int long float double char boolean void 用于定义流程控制的...
  • Java关键字

    2019-10-04 20:01:55
    相关内容: 关键字: 定义 ...用于定义数据类型的关键字 ...用于定义类与类之间的关系关键字 用于定义建立实例及引用实例,判断实例的关键字 用于异常处理的关键字 用于包的关键字...
  • 哎,虽然自己熟的是Java,但很多Java基础知识都不知道,比如transient关键字以前都没用到过,所以不知道它的作用是什么,做笔试题时发现有一题是关于这个的,于是花个时间整理下transient关键字的使用,涨下姿势~~~...
  • java常用关键字

    2016-11-08 14:58:08
    java关键字介绍 java关键字也称为保留字,在语言中具有特殊作用,按照系统规定方式使用。关键字不能作为变量名,函数名等,否则编译器会提示错误。 一.用于定义数据类型的关键字 1.class 说明:表示一个类 所占字节...
  • java volatile 关键字

    2014-08-27 09:16:45
    java线程并发处理中,有一个关键字volatile的使用目前存在很大的混淆,以为使用这个关键字,在进行多线程并发处理的时候就可以万事大吉。 Java语言是支持多线程的,为了解决线程并发的问题,在语言内部引入了...
  • JAVA关键字THIS和关键字SUPER图解 父类 package demo10; public class Fu { int num=10; public void method(){ System.out.println("父类方法"); } } 子类 package demo10; import java.util.zip....
  • Java_关键字和标识符

    2019-08-16 11:08:13
    一.关键字 1.概述 是指在程序中,Java已经定义好的单词,具有特殊含义. 2.特点 关键字中所有字母都为小写 3.常见关键字 ...定义类与类之间关系关键字:abstract final static synchronized 类与类之间关系的...
  • JAVA全部关键字

    千次阅读 多人点赞 2018-04-03 19:52:16
    零、关键字一览:abstract continue for new switchassert*** default goto* package synchronizedboolean do if private thisbreak double implements protected throwbyte else import public ...
  • 1.Java有多少个关键字与保留字 Java关键字:50多个 保留字:2个 const,goto 2.关键字介绍 定义类,接口,抽象类,枚举:class,interface,abstract,enum,extends,implements 实例化对象: new 循环,条件:for,while...
  • Java部分关键字整理

    2020-03-03 16:15:52
    Java学习的笔记整理——关键字 用于定义数据类型的关键字 class interface byte short int long float double ...
  • Java并发关键字-synchronized

    万次阅读 多人点赞 2019-10-06 18:32:04
    文章目录synchronized简介synchronized实现原理对象锁(monitor)机制synchronized的happens-before关系锁获取和锁释放的内存语义synchronized优化CAS操作什么是CAS?CAS的操作过程CAS的应用场景CAS的问题Java对象头...
  • Java常见关键字

    2020-03-11 10:59:22
    有些关键字在之前的内容已经提到过,这里做一个总结 一、final、static、abstract 1.static 修饰符 被 static 关键字修饰的方法或者变量不需要依赖于对象来进行访问,只要类被加载了,就可以通过类名去进行访问。 ...
  • java常见关键字

    2019-03-18 11:39:25
    private关键字 A: private关键字特点 a:是一个权限修饰符 b:可以修饰成员变量和成员方法 c:被其修饰的成员只能在本类中被访问 this关键字 A: 为什么要有this 当我们的局部变量和成员变量相同的时候,如果我们不使用...
  • Java transient关键字使用小记  哎,虽然自己最熟的是Java,但很多Java基础知识都不知道,比如transient关键字以前都没用到过,所以不知道它的作用是什么,今天做笔试题时发现有一题是关于这个的,于是花...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 260,233
精华内容 104,093
关键字:

java关系关键字

java 订阅