精华内容
下载资源
问答
  • //显示调用和隐式调用原则//定义一个生物类class Creature{{System.out.println(“Creature的非静态初始化块”);}//两个构造器public Creature(){/// 6System.out.println(“Creature无参数的构造器”);}public ...

    举个例子:

    package com.test6;

    //显示调用和隐式调用原则

    //定义一个生物类

    class Creature{

    {

    System.out.println(“Creature的非静态初始化块”);

    }

    //两个构造器

    public Creature(){

    /// 6

    System.out.println(“Creature无参数的构造器”);

    }

    public Creature(String name){

    //使用this调用另一个重载的、无参数的构造器 5

    this();

    System.out.println(“Creature带有name参数的构造器,name参数:”+name);

    }

    }

    class Animal extends Creature{

    {

    System.out.println(“Animal的非静态初始化块”);

    }

    public Animal(String name){

    // 4

    super(name);

    System.out.println("Animal带一个参数的构造器,name参数:"+name);

    }

    public Animal(String name , int age){

    //使用this调用另一个重载的构造器 3

    this(name);

    System.out.println("Animal带两个参数的构造器,age"+age);

    }

    }

    class Wolf extends Animal{

    {

    System.out.println("Wolf的非静态初始化块");

    }

    public Wolf(){

    //显示调用父类带两个参数的构造器 2

    super("灰太狼",3);

    System.out.println("Wolf无参数的构造器");

    }

    public Wolf(double weight){

    //使用this 调用另一个重载的构造器 1

    this();

    System.out.println("Wolf的带weight参数的构造器,weight参数:"+weight);

    }

    }

    public class InitTest {

    /**

    * @param args

    */

    public static void main(String[] args) {

    // TODO Auto-generated method stub

    new Wolf(5.6);

    }

    }

    运行结果:

    Creature的非静态初始化块

    Creature无参数的构造器

    Creature带有name参数的构造器,name参数:灰太狼

    Animal的非静态初始化块

    Animal带一个参数的构造器,name参数:灰太狼

    Animal带两个参数的构造器,age3

    Wolf的非静态初始化块

    Wolf无参数的构造器

    Wolf的带weight参数的构造器,weight参数:5.6

    程序初始化步骤:执行非静态初始化块(如果有的话)->隐式或显示调用类的一个或多个构造器执行初始化。 只要在程序中创建Java对象,系统总是先调用最顶层父类的初始化操作,包括初始化块和构造器。然后依次向下调用父类初始化操作,最后执行本类的初始化操作。至于调用父类的哪个构造器来执行初始化,分为三种情况: a、子类构造器执行体的第一行使用super显示调用父类构造器,根据传入的参数来确定调用父类的哪个构造器; b、子类构造器执行庭的第一行使用this显示调用本类中的重载构造器,根据传入的参数确定本类的另一个构造器; c、都没有,系统将会在执行子类构造器之前,隐式调用父类无参数的构造器;

    展开全文
  • 那所谓显式和隐式锁即Lock和synchronized的区别。 一、构成不同 ->Sync:Java中的关键字,是由JVM来维护的,是JVM层面的锁。 Sync 底层是通过 monitorenter 进行加锁(底层是通过 monitor 对象来完成的,其中...

    Java线程不安全问题有三种解决方案,所谓显式锁和隐式锁即Lock和synchronized的区别。
    在这里插入图片描述

    一、构成不同

    Sync:Java中的关键字,是由JVM来维护的,是JVM层面的锁。
    Sync 底层是通过 monitorenter 进行加锁(底层是通过 monitor 对象来完成的,其中的wait/notify等方法也 是依赖于 monitor 对象的。只有在同步代码块或者同步方法中才可以调用wait/notify等方法。因为只有在同步代码块或者是同步方法中,JVM才会调用 monitory 对象);通过 monitorexit 来退出锁。
    Lock:是JDK5以后才出现的具体的类。使用 Lock 是调用对应的API,是API层面的锁。
    而 Lock 是通过调用对应的API方法来获取锁和释放锁。

    二、使用方式不同

    Sync是隐式锁,Lock是显示锁。

    所谓的显示和隐式就是在使用的时候,使用者要不要手动写代码去获取锁和释放锁的操作。
    ->在使用sync关键字的时候,程序能够自动获取锁和释放锁。因为当sync代码块执行完成之后,系统会自动让程序释放占用的锁。Sync是由系统维护的,如果非逻辑问题的话,是不会出现死锁的。
    ->Lock:手动获取和释放,不然可能导致出现死锁的现象。
    Demo:
    在这里插入图片描述

    三、等待是否可中断

    Sync是不可中断的,除非抛出异常或者正常运行完成。
    Lock可以中断的。
    中断方式:
    1、调用设置超时方法tryLock(long timeout ,timeUnit unit)
    2、调用lockInterruptibly()放到代码块中,然后调用interrupt()方法可以中断

    四、加锁的时候是否可以公平

    Sync:非公平锁。即排队抢锁。
    Lock:两者都可以的。默认是非公平锁。在其构造方法的时候可以传入Boolean值。
    true:公平锁。即Lock lo = new ReentrantLock(true)
    false:非公平锁

    五、锁绑定多个条件来condition

    Sync:要么随机唤醒一个线程,要么是唤醒所有等待的线程。
    Lock:用来实现分组唤醒需要唤醒的线程,可以精确的唤醒,而不是像sync那样,不能精确唤醒线程。

    六、性能比较

    Sync是托管给JVM执行的。在JDK5中,前者因为需要调用接口操作,可能加锁等消耗时间更长。但在JDK6后,sync进行很多优化,有适应自旋、锁消除、锁粗化、轻量级锁、偏向锁等,性能也不比lock差。
    Lock是java写的控制锁的代码。对象性能更高点。

    之前的sync使用悲观锁的机制,即线程独占锁,其它线程只能依靠阻塞来等待线程释放的锁,而线程阻塞时会引起线程的上下文切换,当有很多线程竞争锁的时候,会引起CPU频繁的上下文切换导致效率很低。

    而Lock使用乐观锁的方式。所谓乐观锁就是,每次不加锁而是假设没有冲突而去完成某项操作,如果因为冲突失败就重试,直到成功为止。乐观锁的实现方式是CAS机制(Compare And Swap),调用的是CPU提供的底层指令。

    展开全文
  • 显式调用隐式调用

    千次阅读 2017-03-14 09:45:26
    Android 开发中,对于组件(Activity,Service)的调用有两种方式:显示调用和隐式调用,我们通过一个例子,展示一下二者的差异。 新建一个项目,里面包含TestActivity.java和WinService.java两个类,public class ...

    Android 开发中,对于组件(Activity,Service)的调用有两种方式:显示调用和隐式调用,我们通过一个例子,展示一下二者的差异。
    新建一个项目,里面包含TestActivity.java和WinService.java两个类,

    public class MainActivity extends AppCompatActivity {
    
        private ServiceConnection mConn = new ServiceConnection()
        {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service)
            {
                //绑定服务
            }
    
            @Override
            public void onServiceDisconnected(ComponentName name)
            {
                //解绑服务
            }
        };
    
        @Override
        protected void onCreate(Bundle savedInstanceState)
        {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            //开始绑定服务
            bindServiceInvoked();
        }
    
        @Override
        protected void onDestroy()
        {
            super.onDestroy();
            unbindService(mConn);
        }
    
    }
    

    1. 显示调用:

    private void bindServiceInvoked() {
         final Intent intent = new Intent(this, WinService.class);
         bindService(intent, mConn, Context.BIND_AUTO_CREATE);
         Log.e(TAG, "bindService invoked !");
    }

    在AndroidManifest.xml中,service 如下定义:

    <service
        android:name=".WinService"
        android:enabled="true">
    </service>

    2. 隐式调用

    首先,在AndroidManifest.xml中,service 定义是:

    <service
        android:name=".WinService"
        android:enabled="true">
        <intent-filter>
           <action android:name="com.win.test"></action>
           <category android:name="android.intent.category.DEFAULT" />
         </intent-filter>
    </service>

    绑定服务的实现逻辑如下:

    private void bindServiceInvoked() {
       final Intent intent = new Intent("com.win.test");
       bindService(intent, mConn, Context.BIND_AUTO_CREATE);
       Log.e(TAG, "bindService invoked !");
    }

    在Android5.0以后,google出于安全的考虑,规定service的intent一定要显性声明,所以隐式调用在Android5.0及之后的版本,编译时会报错:

    IllegalArgumentException: Service Intent must be explicit:intent

    日常开发中,最好采用显示调用,代码的安全性更高 而且版本兼容性更好。

    展开全文
  • 显式加载: ClassLoader.loadClass(className) :只执行装载过程。 Class.forName(className):执行类的装载、链接、初始化过程。https://www.cnblogs.com/heyjia/p/11338612.html Class.forName(className)是...

    类加载方式:

    显式加载(传入类全限定名的加载)、动态加载(编译时类可以缺席的加载):

        ClassLoader.loadClass(className) :只执行装载过程。

        Class.forName(className):执行类的装载、链接、初始化过程。https://www.cnblogs.com/heyjia/p/11338612.html

    Class.forName(className)是初始化类,newInstance()是实例化类。new是初始化加实例化类。(new关键字和Class类的newInstance()的区别:https://blog.csdn.net/qq_33704186/article/details/86596614

    隐式加载(非传入类全限定名的加载)、静态加载(编译时类不可以缺席的加载):

             创建类对象
             使用类的静态域
             创建子类对象
             使用子类的静态域

    其他特殊的隐式加载:
    在JVM启动时,BootStrapLoader会加载一些JVM自身运行所需的class
    在JVM启动时,ExtClassLoader会加载指定目录下一些特殊的class
    在JVM启动时,AppClassLoader会加载classpath路径下的class,以及main函数所在的类的class文件。

    https://blog.csdn.net/jiyiqinlovexx/article/details/51090751

    方法调用方式: 

    显式调用(写明调用方法)、隐式调用(未写明调用方法)举例:
    (1)toString()调用:
    显式调用:System.out.println(object.toString());
    隐式调用:System.out.println(object);
    (2)父类无参构造方法调用:
    显式调用:

    public class Person {
        public Person (){
            System.out.println("Person ()");
        }
    }
    
    public class Student extends Person {
        public Student(){
            super();
        }
    
        public static void main(String[] args) {
            new Student();
        }
    }

    隐式调用:

    public class Person {
        public Person (){
            System.out.println("Person ()");
        }
    }
    
    public class Student extends Person {
        public Student(){
        }
    
        public static void main(String[] args) {
            new Student();
        }
    }

     

    方法分派方式:
    动态分派:根据实际类型(变量实例类型)分派方法版本。如子类给父类赋值,父类调用方法时,根据实例类型,即子类类型匹配子类方法。运行阶段确定方法版本,由JVM负责。
    静态分派:根据静态类型(变量声明类型)分派方法版本。如方法重载,根据参数声明类型匹配方法。编译阶段确定方法版本,由编译器负责。

    Java是静态多分派,动态单分派语言。

     

    展开全文
  • 显式和隐式锁都是为了保证线程安全Java官方提出来的解决办法,它们的区别简而言之就是 是否能自动锁自动开锁,能自动开关锁的属于隐式锁,需要程序员操作进行开关锁的属于显示锁。先看一下显示锁与隐式锁的使用...
  • 当创建任何 Java 对象时,程序总会先依次调用每个父类非静态初始化块、父类构造器(总是从 Object 开始,因为Java 程序里所有类的最终父类都是 java....这个调用隐式执行的,而且父类的静态初始化块总是会被执行...
  • 显式跳转在已知包名类名的情况下常用的跳转方法:是nt mIntent = new Intent();mInIntetent.setClassName("com.android.settings","com.android.settings.Settings");mContext.startActivity(mIntent);我们也常...
  • 学习Java对象与类的有关知识时,第一次遇到了显式参数和隐式参数的概念,故通过查询资料得知其区别。 它们分别是这样定义的: 显式参数:平时见到的在方法名后括号中间的参数,即所谓能看得见的参数。 隐式参数:在...
  • 当你没有使用父类默认的构造方法时,此时在子类的构造方法中就需要显示的调用父类定义的构造方法。比如:父类:class Animal{ private String name; //如果你定义一个新的构造方法 public Animal(String name) { ...
  • 什么是显式和隐式锁,区别是什么? - 所谓的显式和隐式锁,主要是指的synchronized关键字和ReentrantLock类。 他们的区别是: 1 底层不同 synchronized是Java中的关键字,是JVM层面的锁 ReentranLock是JDK5以后...
  • 隐式调用和显式调用

    2020-09-15 09:26:16
    接着会调用父类的一个或多个构造器执行初始化,这个调用即可通过 super 显示调用,也可隐式调用。 假设有如下继承关系: Object—>parent—>mid—>sub import java.util.Arrays; public class test { ...
  • 接着会调用父类的一个或多个构造器执行初始化,这个调用即可通过 super 显示调用,也可隐式调用。假设有如下继承关系:则构造器的执行顺序为: 1、执行Object类的非静态初始化块; 2、隐式或显式调用Object类的一...
  • 所谓显式和隐式锁,主要指的就是 synchronized关键字和ReentrantLock类。 下面具体聊一聊二者之间的区别: 1底层不同 synchronized是java中的关键字,是JVM层面的锁。 ReentrantLock是是JDK5以后出现的具体...
  • 接着会调用父类的一个或多个构造器执行初始化,这个调用既可以通过super进行显式调用,也可以隐式调用。  当所有父类的非静态初始化块,构造器依次调用完成后,系统才调用本类的非静态初始化块,构造器执行初始化块...
  • 1.构造器写一个Java类,首先要先从构造器开始,构造器与类同名,在构造类的对象时会先从构造器开始。构造器总是伴随着new操作符的执行而被调用。构造器主要是用来初始化类的实例域。构造器的特点:构造器与类同名。...
  • 隐式锁,谁调用该方法谁就是锁对象 显示锁 ReentrantLock类的lock()/unlock()方法 显式锁,有程序员决定在那开启/关闭锁 一、构成不同 Sync Lock 的出身(原始的构成)不同: Sync:Java中的关键字,是由...
  • java隐式参数和显式参数

    千次阅读 2018-11-29 12:49:56
    或者说是当前方法的对象, 一般我们会使用this关键字来使用隐式参数,this表示调用该方法的当前类的当前实例,使用this关键字可以很好的把显式参数和隐式参数分离开。  显示参数:是通常所说的参数在方法名括号...
  • 写一个Java类,首先要先从构造器开始,构造器与类同名,在构造类的对象时会先从构造器开始。 构造器总是伴随着new操作符的执行而被调用。 构造器主要是用来初始化类的实例域。 构造器的特点: 构造器与类...
  • Java运行时多态性:继承接口的实现一文中,我们曾详细介绍了Java实现运行时多态性的动态方法调度;今天我们再次深入Java核心,一起学习Java中多态性的实现。“polymorphism(多态)”一词来自希腊语,意为“多种...
  • 写一个Java类,首先要先从构造器开始,构造器与类同名,在构造类的对象时会先从构造器开始。 构造器总是伴随着new操作符的执行而被调用。 构造器主要是用来初始化类的实例域。 构造器的特点: 构造器与类...
  • 显式参数:显式参数是在方法中括号中声明的参数,例如:在这个方法中,ns就是显式参数 隐式参数:隐式参数表示在方法中使用,但是没有写在方法参数中也没有在方法体内声明的变量(在类中声明的变量),例如:上边...
  • Java隐式锁:synchronized;显式锁:lock synclock的区别 一:出身不同 从synclock的出身(原始的构成)来看看两者的不同。 Sync:Java中的关键字,是由JVM来维护的。是JVM层面的锁。 Lock:是JDK5以后才出现的...
  • Java的构造器和隐式参数和显式参数

    千次阅读 2016-06-10 18:11:33
     写一个java类,首先要先从构造器开始,构造器与类同名,在构造类的对象时会先从构造器开始。  构造器总是伴随着new操作符的执行而被调用。  构造器主要是用来初始化类的实例域。  构造器的特点: 构造器与类...
  • 下面我们就来看看什么是隐式参数显示参数。显式参数,就是平时见到的在方法名括号中间的参数,就是所谓能看得见的参数。隐式参数,是在类的方法中调用了类的实例域。这个被调用的实例域就是隐式参数。在以下的这个...
  • Java锁体系】五、隐式显氏锁的区别(SynchronizedLock的区别) 在Java并发编程中,Java隐式锁有synchronized,显氏锁有Lock。 1.两者的出身不同 synchronized是Java中的关键字,由JVM维护,是JVM层面的锁; ...
  • 隐式参数和显式参数

    2020-02-13 11:19:51
    摘自Java核心技术卷I 第10版 108页 方法用于操作对象以及存取它们的实例域。例如方法: public void raiseSalary(double byPercent) { double raise = salary * byPercent / 100; salary += raise; } 将调用这个...

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 227
精华内容 90
关键字:

java显式调用和隐式调用

java 订阅