精华内容
下载资源
问答
  • 显式调用隐式调用

    千次阅读 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

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

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

    2020-09-15 09:26:16
    接着会调用父类的一个或多个构造器执行初始化,这个调用即可通过 super 显示调用,也可隐式调用。 假设有如下继承关系: Object—>parent—>mid—>sub import java.util.Arrays; public class test { ...

    一、结论

    当调用某个类的构造器来创建Java对象时,系统总会先调用父类的非静态初始化块进行初始化,这个调用是隐式的。接着会调用父类的一个或多个构造器执行初始化,这个调用即可通过 super 显示调用,也可隐式调用(当没用显示调用时,就会使用隐式调用无参数构造函数)。

    假设有如下继承关系:
    Object—>parent—>mid—>sub

    import java.util.Arrays;
    
    public class test {
        public static void main(String[] args) {
            new Sub(111);
    
        }
    
    }
     class parent{
        public parent(){
            System.out.println("parent 无参数构造器");
    
        }
        public  parent(String name){
    //使用this调用另一个无参数的构造器
            System.out.println("parent 带参数构造器:"+name);
    
        }
         {
             System.out.println("parent 非静态初始化");
         }
    }
    class mid extends  parent{
        public mid(){
            System.out.println("mid 无参数构造器");
    
        }
        public  mid(String name){
            super(name);//显式调用父类带一个参数的构造器
            System.out.println("mid 带参数构造器:"+name);
    
        }
        public  mid(String name,int age){
            this(name);
    
            System.out.println("mid 带两个参数构造器:"+age);
    
        }
        {
            System.out.println("mid 非静态初始化");
        }
    }
    class Sub extends mid {
    
        public Sub() {
    
            System.out.println("Sub 类无参构造器");
        }
    
        public Sub(int a) {
            this();
            System.out.println("Sub 类带一个参数构造器, a: " + a);
            System.out.println();
        }
    
        {
            System.out.println("Sub 类非静态初始化块");
        }
    
    
    }
    

    则构造器的执行顺序为:
    1、执行Object类的非静态初始化块;
    2、隐式或显式调用Object类的一个或多个构造器执行初始化;
    3、执行Parent累的非静态初始化块;
    4、隐式或显式调用Parent类的一个或多个构造器执行初始化;
    5、执行Mid累的非静态初始化块;
    6、隐式或显式调用Mid类的一个或多个构造器执行初始化;
    7、执行Sub累的非静态初始化块;
    8、隐式或显式调用Sub类的一个或多个构造器执行初始化;

    因此执行顺序为:
    1、父类的非静态初始化块,构造器;
    2、本类的非静态初始化块,构造器。

    注:

    1. super用于显示调用父类的构造器,this用于显示调用本类中另一个重载的构造器;
    2. super 调用和this 调用都只能在构造器中使用,并且都必须作为构造器的第一行代码;
    3. super 调用和 this 调用最多只能使用其中之一, 而且最多只能调用一次。
      https://blog.csdn.net/u012099869/article/details/51027236
    展开全文
  • 那所谓显式和隐式锁即Locksynchronized的区别。 一、构成不同 ->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提供的底层指令。

    展开全文
  • 下面是关于父类构造方法调用的实验:当父类子类都没有定义构造方法时,系统为父类、子类提供一个无参构造方法,并在子类中隐式调用父类无参构造方法:class Father {} class Son extends Father {}我们可以自己写...

    下面是关于父类构造方法调用的实验:

    当父类子类都没有定义构造方法时,系统为父类、子类提供一个无参构造方法,并在子类中隐式调用父类无参构造方法:

    class Father {}
    
    class Son extends Father {}
    我们可以自己写代码来完成同样的工作:
    class Father {
    	public Father(){}
    }
    
    class Son extends Father {
    	public Son(){
    		super();
    	}
    }

    如果我们在Father构造方法中添加一个参数:

    class Father {
    	public Father(int a){
            }
    }
    
    class Son extends Father {
    	public Son(){ //编译器报错: The constructor Father() is undefined
    		super();
    	}
    }

    印证了一点: 如果父类已经定义了一个构造方法,则系统不会再提供无参的构造方法了。

    在这种情况下, 尝试把super()删掉:
        编译器报错:Implicit super constructor Father() is undefined. Must explicitly invoke another constructor,即父类的Father无参构造方法没有定义,说明还是会隐式调用父类的无参构造方法,但是系统没有提供。

    如果我们再把Son中的构造方法也删掉:

        编译器再报错:Implicit super constructor Father() is undefined for default constructor. Must define an explicit constructor,说明还是会尝试调用父类的无参构造方法

    然后我们尝试在Father中添加一个无参构造方法:

    class Father {
    	public Father(){}
    	public Father(int a){}
    }
    
    class Son extends Father {
    	
    }

    就不会报错了。


    结论:
      子类的每一个构造方法都必须显式或隐式调用父类的一个构造方法。如果不显式调用, 则系统隐式调用super(),即父类的无参构造方法(如果父类无任何构造方法, 则系统为父类自动提供一个无参构造方法; 如果父类已经有一个构造方法, 系统不会额外提供无参的构造方法,此时, 如果父类仅定义了有参构造方法, 并且子类没有定义任何的构造方法(系统会为它提供一个无参构造方法, 然后隐式调用父类无参构造方法), 或子类定义的构造方法中没有显式调用父类的有参构造方法(会隐式调用父类的无参构造方法), 就都会因为父类没有无参构造方法而报错。




    展开全文
  • java 显示调用和隐式调用 示例

    千次阅读 2018-03-26 21:14:37
    /** * java 显示调用和隐式调用 * @author raytseng * */class grandfather { public grandfather() {  System.out.println("调用grandfather的无参构造函数"); } public grandfather(String ...
  • 显式调用 隐式调用 别名 动态调用, 运行时加载 静态调用, 载入时加载 理解技巧 比较露骨,在调用处能看出来它是调用库中的函数,不需要lib 比较含蓄,仅看调用处你可能都不知道自己调用的是库中的函数,依赖lib lib...
  • 显式加载: ClassLoader.loadClass(className) :只执行装载过程。 Class.forName(className):执行类的装载、链接、初始化过程。https://www.cnblogs.com/heyjia/p/11338612.html Class.forName(className)是...
  • 接着会调用父类的一个或多个构造器执行初始化,这个调用即可通过 super 显示调用,也可隐式调用。假设有如下继承关系:则构造器的执行顺序为: 1、执行Object类的非静态初始化块; 2、隐式或显式调用Object类的一...
  • Java 显示调用和隐式调用

    千次阅读 2015-07-26 16:55:46
    举个例子: package com.test6;//显示调用和隐式调用原则//定义一个生物类 class Creature{ { System.out.println(“Creature的非静态初始化块”); } //两个构造器 public Creature(){ ///
  • 显式和隐式锁都是为了保证线程安全Java官方提出来的解决办法,它们的区别简而言之就是 是否能自动锁自动开锁,能自动开关锁的属于隐式锁,需要程序员操作进行开关锁的属于显示锁。先看一下显示锁与隐式锁的使用...
  • java继承中对构造函数是不继承的,只是调用隐式显式)。 以下是例子:  public class FatherClass {  public FatherClass() {  System.out.println(100);  }  public FatherClass(int age) {  ...
  • 首先需要明白的是,当创建java对象时,程序总是依次调用每个父类的非静态初始化块、父类构造器(总是从Object开始)执行初始化,最后才调用该类的非静态初始化块、构造器执行初始化。 如果你不明白初始化的本质,请...
  • Java并发之显式和隐式锁的区别 在面试的过程中有可能会问到:在Java并发编程中,锁有两种实现:使用隐式使用显示锁分别是什么?两者的区别是什么?所谓的显式和隐式锁的区别也就是说说Synchronized...
  • Selenium(Java)-显式等待和隐式等待

    千次阅读 2018-06-15 10:47:43
    在自动化测试中,有时你需要等待一个任务结束后才能进行下一个任务,所以两个任务之间就需要间隔一段等待时间,而...一、显式等待WebDriver driver = new ChromeDriver(); driver.get("https://www.baidu.com...
  • Intent intent2 = new Intent(); // 第一个参数是包名,第二个参数是包下的类名。包名可以直接用getPackageName()方法代替,也可以直接输入当前包的环境 //intent2.setClassName(... ... startActivity(intent2);
  • java 显式参数隐式参数 The implicit parameter in Java is the object that the method belongs to. It's passed by specifying the reference or variable of the object before the name of the method.An ...
  • 隐式参数:方法的调用者 假定有一个员工类,员工类有salary属性以下方法: public void raiseSalary(double byPercent){ double raise = salary * byPercent / 100; salary = salary + raise; } //考虑下面...
  • java 隐式调用和显示调用

    千次阅读 2014-10-09 10:02:31
    当我们在调用lei
  • 原文详解:java隐式参数显示参数 原文链接: http://licocom.com/archives/1199 早起来公司看书,看见了一个叫做隐式参数显示参数, 竟然不知道是什么意思,哈哈。。。便查询做以记录 定义如下: 显示参数:在...
  • 隐式锁,谁调用该方法谁就是锁对象 显示锁 ReentrantLock类的lock()/unlock()方法 显式锁,有程序员决定在那开启/关闭锁 一、构成不同 Sync Lock 的出身(原始的构成)不同: Sync:Java中的关键字,是由...
  • package 第3章;...import java.time.*;public class 第3章a { public static void main(String[] args) { Employee[] man=new Employee[2]; man[0]=new Employee("hello",200000,2003,2,8); m

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 45,715
精华内容 18,286
关键字:

java显式调用和隐式调用

java 订阅