Android + Java 基础知识

蔚落 2022-11-17 05:05 284阅读 0赞

***1、抽象类和接口的区别***

<table> 
 <thead> 
  <tr> 
   <th>抽象类</th> 
   <th>接口类</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Java中被abstract关键字修饰的类称为抽象类，被abstract关键字修饰的方法叫做抽象方法</td> 
   <td>Java中接口使用interface关键字修饰的被称为接口</td> 
  </tr> 
  <tr> 
   <td>抽象类不能被实例化，只能被继承</td> 
   <td>在接口中可以定义成员变量，但是这些成员变量默认都是public static final的常量</td> 
  </tr> 
  <tr> 
   <td>包含抽象方法的一定是抽象类，但是抽象类不一定含有抽象方法</td> 
   <td>一个类实现某个接口，必须要实现接口中定义的所有方法</td> 
  </tr> 
  <tr> 
   <td>抽象类可以包含属性、方法、构造方法，但是构造方法不能用于实例化</td> 
   <td>一个类可以实现多个接口</td> 
  </tr> 
  <tr> 
   <td>不能被实例化</td> 
   <td>不能被实例化</td> 
  </tr> 
  <tr> 
   <td>抽象类可以有定义与实现，方法可在抽象类中实现</td> 
   <td>接口只能有定义，不能有方法的实现</td> 
  </tr> 
  <tr> 
   <td>继承抽象类的关键字为extends</td> 
   <td>实现接口的关键字为implements</td> 
  </tr> 
  <tr> 
   <td>一个类只能继承一个抽象类</td> 
   <td>一个类可以实现多个接口</td> 
  </tr> 
  <tr> 
   <td>抽象类提高了类和类的内聚程度，减少了代码量</td> 
   <td>接口降低了类和类的耦合度，但是增加了代码量</td> 
  </tr> 
 </tbody> 
</table>

***2、Android的消息机制***  
Android通过Looper、Handler、MessageQueue来实现消息的循环机制；首先会在UI线程中创建一个Handler对象，然后重写对应的handlerMessage方法，然后创建一个子线程，在子线程需要更新UI的时候，新建一个Message对象，并把需要传递的消息记录在Message里面，通过Handler的sendMessage方法把这个Message发送出去，之后这个消息就会进入到MessageQueue（单链表结构），此时MessageQueue的管家Looper（启动应用的时候Android默认会创建一个主的Looper）就会不停从MessageQueue中取出对应的消息，然后将消息传递给相对应的Handler处理。[Handler的更多细节请点这][Handler]

***3、Android中两种启动Service的方式***  
Service（服务）是Android中一种可以在后台执行长时间运行操作而没有用户界面的应用组件，eg：播放音乐、执行文件I/O等，所有这一切均可在后台进行，Service的启动主要有以下两种(附上生命周期)：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODg5NDc2_size_16_color_FFFFFF_t_70]

a、通过startService启动服务：

*  onCreate：如果Service还未创建，那么调用startService()的时候回执行onCreate()回调；如果Service已经被创建，那么执行startService()的时候不会执行该回调，也就是说，onCreate()只会在第一次创建Service的时候会被调用，其余时候都不会被调用；
 *  onStartCommand：当执行了Connext的startService()时，那么onStartCommand()也会随之执行，跟onCreate()不同的是，如果多次调用startService()，那么onStartCommand()也会相应的被调用多次，我们可以对该方法中根据传入的Intent参数进行实际的操作；
 *  onBind：Service中的onBind()方法是抽象方法，Service类本身就是抽象类，所以onBind()方法是必须重写的，即使我们用不到；
 *  onDestory：在销毁的时候会执行改回调；

b、通过bindService启动服务：

*  onBind：  
    当另一个组件通过调用bindService()与服务绑定时，系统将调用此方法；
 *  onUnbind：  
    当另一个组件通过调用unbindService()与服务解绑时，系统将调用此方法；
 *  onRebind：  
    当旧的组件与服务解绑后，另一个新的组件与服务绑定，onUnbind()返回true时，系统将调用此方法；

两种方法都可以启动Service,但是它们的适用场合有所不同。使用startService方法启用服务，调用者与服务之间没有关联，即使调用者退出，服务仍然运行，需要调用stopService或Service内部调用Service的stopSelf停止服务。使用bindService 方法启用服务，调用者与服务绑定在一起，调用者一旦退出，服务也就终止；

***4、Android中如何保证Service不被杀死？***  
a、修改onStartCommand()方法的返回值为START\_STICKY可实现停止服务之后重启服务（详情请阅读官方文档）  
b、提升service优先级，在清单文件中对intent-filter可以通过android:priority = "1000"这个属性设置最高优先级，1000是最高值  
c、提高service的进程，如果应用进程关闭了，那么Service也会跟着销毁。若服务想获得更长的时间，可以设置为前台服务（前台进程>可视进程>次要服务进程>后台进程>内容供应节点>空进程）  
d、当service走到onDestroy()时，发送一个自定义广播，当收到广播时，重新启动service

***5、Android中两种广播的注册方式？***

*  静态广播：通过AndroidManifest.xml清单文件来声明BroadcastReceiver，静态广播一但注册之后，android不能自动销毁广播接收器，也就是说，即使用户关闭了应用程序，但是广播接收器依然还是存在的；
 *  动态广播：通过AMS.registerReceiver()的方式来注册广播，动态注册更为灵活，可在不需要时通过unregisterReceiver()取消注册，也就是说，当程序关闭时，这个广播也会跟着销毁，也可以调用unregisterReceiver()进行销毁；

***5、Android中的四种启动模式？***  
activity有四种启动模式，分别为standard，singleTop，singleTask，singleInstance。

*  standard：Android默认的启动模式，如果一个Activity的启动模式被设置为standard，那么这种情况下的Activity可以被多次实例化，也就是说在同一个任务中可以存在多个Activity的实例，例如：如果Activity A的启动模式被设置为standard，并且Activity A 已经启动，在A中再次启动Activity A，应用会在Activity A的上面再次启动一个A的实例，栈中的状态会变成AA，启动两次的话栈中的状态就AAA，当点击返回的时候，栈中状态AA，也就是你得点击两次返回才能回到最初的那个状态；
 *  singleTop：如果一个以singleTop启动模式的Activity的实例存在于栈顶，那么再次启动该Activity的话，系统不会创建新的实例，而是直接重用栈顶的那个Activity，并且会调用该实例的onNewIntent()方法将Intent对象传递到这个实例里面。例如，有一个singleTop的Activity A存在于栈顶，然后在A里面继续启动Activity A，那么这个时候是不会重新创建一个实例A，而是直接复用栈顶的A，然后调用A里面的onNewIntent()方法，如果A不在栈顶，那么还是会对应的创建一个新的实例；
 *  singleTask：若须要创建的Activity（启动模式设置为singleTask）已经处于栈中时，此时不会创建新的Activity，而是将存在栈中的Activity上面的其他Activity所有销毁，使它成为栈顶，然后只会调用一次onNewIntent()方法。
 *  singleInstance： SingleInstance比較特殊，是全局单例模式，是一种加强的SingleTask模式。它除了具有它所有特性外，还加强了一点：具有此模式的Activity仅仅能单独位于一个任务栈中。

***6、Android中IntentService与Service的区别？***  
先来说说两者的区别吧，Service不是单独的一个进程，也不是一个线程，它是依附于启动它的进程，是运行在主线程中的，所以不能做耗时的操作，否则会报ANR。而IntentService中会单独的开启线程处理，不会阻塞主线程，需要实现onHandlerIntent方法，这个方法也是在Service中没有的；  
IntentService是继承Service的，包含了Service的所有特性，包括生命周期，大家都知道，Service中会提供一个方法，那么对应的IntentService也会有，如下：

@Override
        public int onStartCommand(Intent intent, int flags, int startId) {
        
            onStart(intent, startId);
            return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
        }

启动IntentService会调用该方法，该方法又调用了onStart：

@Override
        public void onStart(Intent intent, int startId) {
        
            Message msg = mServiceHandler.obtainMessage();
            msg.arg1 = startId;
            msg.obj = intent;
            mServiceHandler.sendMessage(msg);
        }

会发现有个mServiceHandler，那么这个Handler又是哪里来的呢，接着往下看：

@Override
        public void onCreate() {
        
            // TODO: It would be nice to have an option to hold a partial wakelock
            // during processing, and to have a static startService(Context, Intent)
            // method that would launch the service & hand off a wakelock.
    
            super.onCreate();
            HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
            thread.start();
    
            mServiceLooper = thread.getLooper();
            mServiceHandler = new ServiceHandler(mServiceLooper);
        }

IntentService在onCreate的时候就创建了一个线程HandlerThread,并获得了当前线程队列管理的looper，并且在onStart的时候，把消息置入了消息队列

private final class ServiceHandler extends Handler {
        
            public ServiceHandler(Looper looper) {
        
                super(looper);
            }
    
            @Override
            public void handleMessage(Message msg) {
        
                onHandleIntent((Intent)msg.obj);
                stopSelf(msg.arg1);
            }
        }

在消息被handler接受并且回调的时候，执行了onHandlerIntent方法，该方法的实现是子类去做的，IntentService是通过Handler looper message的方式实现了一个多线程的操作，同时耗时操作也可以被这个线程管理和执行，同时不会产生ANR；

***7、Android切换横竖屏的时候生命周期的变化？***

*  不设置Activity的android:configChanges的时候，切换横竖屏会重新调用各个生命周期，切横屏的时候会执行一次，切竖屏的时候会执行两次；
 *  设置Activity的android:configChanges="orientation"的时候，切屏会重新调用各个生命周期，横屏竖屏都只调用一次；
 *  设置Activity的android:configChanges="orientation | keyboardHidden"的时候，切屏不会重新调用各个生命周期，只会执行onConfigurationChanged方法;

***8、Android中 SP和 DP的区别？***

*  使用sp作为字体大小单位,会随着系统的字体大小改变；
 *  使用dp作为字体大小单位,不会随着系统的字体大小改变；

***9、String,StringBuffer,StringBuilder的区别？***  
简单来说，String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String；而如果是使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下；StringBuilder一个可变的字符序列是5.0新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步，所以在大部分情况下 StringBuilder 效率会大于 StringBuffer，但是如果是在多线程的环境下的话要使用StringBuffer，因为StringBuffer是线程安全的（StringBuffer中很多方法可以带有synchronized关键字），而StringBuilder 是线程不安全的；

***10、什么是ANR 如何避免它？***  
ANR：在Android上，如果你的应用程序有一段时间响应不够灵敏，系统会向用户显示一个对话框，这个对话框称作应用程序无响应（ANR：Application Not Responding）对话框。用户可以选择让程序继续运行，但是，他们在使用你的应用程序时，并不希望每次都要处理这个对话框。一般来说，应用在5s内没有响应输入的事件、广播10s内没有执行完毕或者服务20s内没有反应就会导致应用发生ANR（Android应用程序通常是运行在一个单独的线程里。这意味着你的应用程序所做的事情如果在主线程里占用了太长的时间的话，就会引发ANR对话框）。

那么如何避免呢？

*  避免在主线程上进行复杂耗时的操作，比如说发送接收网络数据/进行大量计算等。这个可以通过使用AsyncTask或者使用HandlerThread等来实现；
 *  广播要进行复杂操作的的时候，可以在onReceive()方法中启动一个Service来处理，还可以加一个进度条之类的；
 *  避免在生命周期onCreate()、onResume()上做耗时操作，尽可能简单化；

***10、如何在Service中创建Dialog对话框？***  
对话框这控件大家都有开发过吧，但是大多数人都是在activity里面进行创建的，但是现在是在Service里面进行创建，没有了依赖那该咋办，不慌，只要在拿到dialog对象后给他加多一行代码就可以了（需要带上权限：SYSTEM\_ALERT\_WINDOW），但是这个是以系统的对话框的形式进行弹出的，代码如下：

dialog.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);

***11、HttpClient和HttpURLConnection的主要区别？***

**HttpURLConnection**

1.  HttpURLConnection对象不能直接构造，需要通过URL类中的openConnection()方法才可以获得对象；
2.  HttpURLConnection调用connect()方法，实际上只是建立了一个与服务器的TCP连接，并没有发送HTTP请求，发起HTTP请求实际上直到我们去获取服务器的响应数据的时候才会正式发起（如getInputStream()、getResoponseCode()）；
3.  对HttpURLConnection对象的配置都需要放置在connect()方法之前；
4.  HttpURLConnection是基于HTTP协议的，底层的实现是通过socket完成的，如果不设置超时时长，在网络不稳定的情况下，可能会导致程序僵死而不继续往下执行；
5.  HTTP正文是通过OutputStream流写入的，向流中写入数据不会立即发送到网络，而是存在于内存缓冲区中，等待流关闭时，根据写入的内容生成HTTP正文；
6.  发起请求之后会调用getInputStream()方法，返回一个输入流，用于获取服务器响应的数据；
7.  API简单，体积较小，压缩和缓存机制可以有效地减少网络访问的流量，在提升速度和省电方面也起到了较大的作用；

try {
        
                // 1. 得到访问地址的URL
                URL url = new URL("xxxxxxxxxxxxxxxx");
                // 2. 得到网络访问对象java.net.HttpURLConnection
                HttpURLConnection connection = (HttpURLConnection) url.openConnection();
                /* 3. 设置请求参数（过期时间，输入、输出流、访问方式），以流的形式进行连接 */
                // 设置是否向HttpURLConnection输出
                connection.setDoOutput(false);
                // 设置是否从httpUrlConnection读入
                connection.setDoInput(true);
                // 设置请求方式
                connection.setRequestMethod("GET");
                // 设置是否使用缓存
                connection.setUseCaches(true);
                // 设置此 HttpURLConnection 实例是否应该自动执行 HTTP 重定向
                connection.setInstanceFollowRedirects(true);
                // 设置超时时间
                connection.setConnectTimeout(3000);
                // 连接
                connection.connect();
                // 4. 得到响应状态码的返回值 responseCode
                int code = connection.getResponseCode();
                // 5. 如果返回值正常，数据在网络中是以流的形式得到服务端返回的数据
                String msg = "";
                if (code == 200) {
         // 正常响应
                    // 从流中读取响应信息
                    BufferedReader reader = new BufferedReader(
                            new InputStreamReader(connection.getInputStream()));
                    String line = null;
    
                    while ((line = reader.readLine()) != null) {
         // 循环从流中读取
                        msg += line + "\n";
                    }
                    reader.close(); // 关闭流
                }
                // 6. 断开连接，释放资源
                connection.disconnect();
                // 显示响应结果
                System.out.println(msg);
            } catch (IOException e) {
        
                e.printStackTrace();
            }

**HttpClient**

1.  可以直接创建HttpClient对象；
2.  如果需要发送GET请求，创建HttpGet对象；如果需要发送POST请求，创建HttpPost对象；
3.  调用HttpClient对象的execute(HttpUriRequest request)发送请求，执行该方法返回一个HttpResponse；
4.  调用HttpResponse的getAllHeaders()、getHeaders(String name)等方法可获取服务器的响应头；
5.  调用HttpResponse的getEntity()方法可获取HttpEntity对象，该对象包装了服务器的响应内容；

// 1. 创建HttpClient对象
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        // 2. 创建HttpGet对象
        HttpGet httpGet = new HttpGet("xxxxxxxxxxxxxxxxxxxxxxxx");
        CloseableHttpResponse response = null;
        try {
        
                // 3. 执行GET请求
                response = httpClient.execute(httpGet);
                System.out.println(response.getStatusLine());
                // 4. 获取响应实体
                HttpEntity entity = response.getEntity();
                // 5. 处理响应实体
                if (entity != null) {
        
                    System.out.println("长度：" + entity.getContentLength());
                    System.out.println("内容：" + EntityUtils.toString(entity));
                }
            } catch (ClientProtocolException e) {
        
                e.printStackTrace();
            } catch (IOException e) {
        
                e.printStackTrace();
            } finally {
        
                // 6. 释放资源
                try {
        
                    response.close();
                    httpClient.close();
                } catch (IOException e) {
        
                    e.printStackTrace();
                }
            }

在Android 2.2版本之前，HttpClient拥有较少的bug，因此使用它是最好的选择。  
而在Android 2.3版本及以后，HttpURLConnection则是最佳的选择。

***12、Android中显式Intent和隐式Intent的区别？***

*  Intent代表意图，主要是用来启动一个Activity，也可以带参数；
 *  显式Intent会指明要启动哪个Activity，而隐式Intent则需要在AndroidManifest.xml里面配置action来隐式启动Activity；
 *  显式Intent不能跨应用启动Activity，隐式Intent是可以跨应用启动Activity的；
 *  如果隐式Intent不想被跨应用启动对应的Activity，则可以在AndroidManifest.xml里面加上“android:exported=false”即可；

***13、final、finally、finalize？***

*  final：java中的关键字，修饰符。如果一个类被final所修饰，那么就意味着这个类不能派生出新的子类，不能作为父类被继承。一个类不能被同时声明为final和abstract抽象类；如果变量中或方法被声明为final，就能保证他们在使用的过程中不会被改变，变量必须保证在声明的时候进行赋值，后续的引用中只读，被声明的final方法只能使用，不能重载；
 *  finally：java中一种异常处理机制。java异常处理模型try-catch的最佳补充，finally的代码块总会被执行，在关闭数据库连接时，如果把数据库连接的close()方法放到finally中，就会减少出错的可能；
 *  finalize：java中的一个方法名，该方法是在GC将对象从内存中清除之前，做必要的清理工作。这个方法是由垃圾收集器确定这个对象没被引用的时候调用的。它在Object类中定义，因此所有类都继承了它。子类可以覆盖该方法来整理资源和清理；

***14、基本数据类型和引用数据类型的区别？***

<table> 
 <thead> 
  <tr> 
   <th>基本数据类型</th> 
   <th>引用数据类型</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>数据直接存储在栈中</td> 
   <td>存储在栈中的是对象的引用地址，真实的对象数据存放在堆内存里面</td> 
  </tr> 
 </tbody> 
</table>

***15、浅拷贝和深拷贝区别？***

<table> 
 <thead> 
  <tr> 
   <th>浅拷贝</th> 
   <th>深拷贝</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>对于基础数据类型来说是直接赋值，对于引用数据类型来说，只是复制了对象的引用地址，新对象和旧对象指向同一个内存地址，修改其中一个对象的值，另一个对象的值也会随之改变；</td> 
   <td>对于基础数据类型来说是直接赋值，对于引用数据类型来说 ，是开辟一个新的内存空间，在新的内存空间里面复制一个一模一样的对象，新旧对象相互不影响，修改其中一个对象的值，不会影响到另外一个对象的值；</td> 
  </tr> 
 </tbody> 
</table>

***16、Java 中的 final 关键字的用法？***

*  修饰类：final修饰了一个类的话，那么这个类不能作为父类被继承，也不能派生出新的子类；
 *  修饰方法：这个方法不能被子类重写；
 *  修饰变量：修饰一个变量的话，那么这个变量在声明的时候必须要赋值，之后只能读取，不能修改；

***17、wait() 和 sleep() 方法的区别？***

*  sleep()不会影响到同步锁的行为，如果当前线程持有锁的情况下，调用sleep()不会让线程释放锁的，而调用wait()的话则会让线程释放锁，让别的线程进入synchronized代码块；两者的区别在于sleep()可以在任何地方进行调用，而wait()只能在同步控制块里面进行使用，不然会抛出异常；但是线程在调用了wait()方法之后与需要再调用notify()或者notifyAll()才可以重新唤醒线程继续工作，而sleep()是时间到了就会继续执行对应的代码块；

***18、线程中的 join()方法是干嘛的？***

*  join()方法主要用于等待当前线程终止，举个例子，线程A中执行了B.join()语句，意思就是让线程A等待线程B执行完之后才从B.join()返回继续执行线程A的代码；

***19、实现多线程的方式？***

*  继承 Thread 类
 *  实现 Runnable 接口
 *  实现 Callable 接口

Thread和Callable是实现了Runnable接口，但是Callable是有返回值的，而Runnable没有返回值；

注：持续更新中…

[Handler]: https://blog.csdn.net/qq_42889476/article/details/114935603?spm=1001.2014.3001.5501
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyODg5NDc2_size_16_color_FFFFFF_t_70]: /images/20221022/c9e386ab7ce74c44a3a18eda672d1630.png