面试笔记记录

1.AsyncTask 用法

onPreExecute()
在UI thread调用显示一个进度条

doInBackground(void......params)
通过调用publishProgress（）方法实时更新进度触发onProgressUpdate

onProgressUpdate(Integer...values)

onPostExecute(Boolean result) 更新UI

2.JNI用法
(1).新建一个jni文件
public class JniTest{

private JniTest(){}

public static JniTest instance=null;

public static JniTest getInstance(){
    if(instance==null){
         instance=new JniTest();

     }
     return instance;

}


 static{
 
     System.loadLibrary("JniTest");
 }
  

 public static native String getJniString();

}

(2).build--->make project 在build目录下找到生成的JniTest.class文件

(3).切换到更目录下，执行javah -jni com.example.firstndk.JniTest 生成
com_example_firstndk_JniTest.h文件

(4).新建一个JNI文件夹，并在此文件夹下来新建一个.c文件，将.h文件中的内容拷贝到
.c文件中，并且实现里面的空方法。

(5).在JNI文件下新建android.mk和application.mk文件,然后Terminal切换到JNI目录下，
执行ndk-build ,生成so库文件

3.AIDL用法
1.新建一个aidl的文件，同时建立一个aidl的接口文件，比如BookManager.aidl，如果是Bean类型，必须parcelable序列化，客户端和服务端aidl文件同时存在，且是一样的。

2.服务端的AIDLService 要实现这个Booknamager.aidl接口，并通过onBind()方法返回该接口的实例化对象

3.客户端通过bindService方法建立链接，实现ServiceConnection接口，在onServiceConnected方法中把IBinder对象转换成

aidl接口的实例化对象，一旦链接成功，客户端就可以和服务端进行通信了。

private void attemptToBindService() {
Intent intent = new Intent();
intent.setAction("com.lypeer.aidl");
intent.setPackage("com.lypeer.ipcserver");
bindService(intent, mServiceConnection, Context.BIND_AUTO_CREATE);
}

4.BroadCastReceiver
(1).常驻型广播-->静态注册（manifes中注册）

(2).非常驻型广播-->动态注册

IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction(String); //为BroadcastReceiver指定action，使之用于接收同action的广播
registerReceiver(BroadcastReceiver,intentFilter);

一般动态注册的广播，要在onDestory中解除注册，否则会导致内存泄露。

5.ContentProvider
https://www.jianshu.com/p/5e13d1fec9c9

(1).ContentProvider的作用是为不同的应用之间的数据共享，提供统一的接口

(2).自定义
MyContentPovider extends ContentProvider{

指定authority="com.shuijian.authority"

实现 inster，delete，update,query

}

(3).其他应用操作ContentProvider中的数据

获得contentResolver=getContentResolver();

根据authority="com.shui.jian.authority"生成一个Uri，contentResolver通过这个Uri就可以操作

其他应用中的ContentProvider中的数据了，实现了数据的共享。

6.设计模式

A：单例模式7种(getInstance 方法一定要是public)
饿汉式
(1).
public class SingleTon{
private SingleTon(){}
private static SingleTon instance=new SingleTon();

private static getInstance（）{xxxxxxxxx

 return instance;

}

(2).静态代码块
public class SingleTon{
private SingleTon(){}
private static SingleTon instance;
static{
instance=new SingleTon()
}
private static getInstance（）{ xxxxxx
return instance;
}

}
(3).静态内部类(holder)
public class SingleTon{
private SingleTon(){}
private static class SingleTonHolder{
private static SingleTon instance=new SingleTon();

}
private static getInstance（）{ xxxxxx
return SingleTonHolder.instance;
}

}

(4)懒汉线程不安全
public class SingleTon{
private SingleTon(){}
private static SingleTon instance;

private static getInstance（）{xxxxx
if(instance==null){
instance=new SingleTon();
}

 return instance;

}

(5)懒汉线程安全
public class SingleTon{
private SingleTon(){}
private static SingleTon instance;

private static synchrozied getInstance（）{xxxxxxxx
if(instance==null){
instance=new SingleTon();
}

 return instance;

}

}
(6)懒汉线程安全
public class SingleTon{
private SingleTon(){}
private static SingleTon instance;

private static synchrozied getInstance（）{xxxxxx
if(instance==null){
synchrozied（SingleTon.class){
if(instance==null){
instance=new SingleTon();
}
}
}

 return instance;

}

}
(7)
public enum SingleTon{
Instance;
}

B.工厂模式
public interface Sender{

public void send();

}

public Sender SMSSender implements Sender{

public void send(){
    System.out.print("sms);

}

}

public Sender QQSender implements Sender{

public void send(){
    System.out.print("QQsms);

}

}

（1).普通工厂模式

public class FactoryOne{

 poublic Sender produce(String type){
   if(type equals "sms"){
         return new SmsSender();
    }else if(type equals "QQ"){
 

      return new QQSmsSender();
    }

}

}

(2).工厂方法模式
public class FactoryTwo{
public Sender smsSender(){

        return SmsSender();
 }
  public Sender qqSender(){

        return QQSender();
 }

}

（3）.静态工厂方法模式

public class FactoryTwo{
public static Sender smsSender(){

        return SmsSender();
 }
  public staic Sender qqSender(){

        return QQSender();
 }

}

（4）.抽象工厂模式

public interface Provider{
void produce();

}

public class FactorySms implements Provider{

public void produce（）{
        return new SmsSender();

 }

}

public class FactoryQq implements Provider{

public void produce（）{
        return new QQSender();

 }3

}

3.观察者模式
public interface Observer {
void update();
}

public interface Observerable(){

void registerObserver(Observer observer);
void removerObserver(Observer observer);
void notifyObservers();

}

public class User1 implements Observer(){
public void update(){
System.print.out("收到消息1");
}
}

public class User2 implements Observer(){
public void update(){
System.print.out("收到消息2");
}
}
public class Watcher implements Observerable{
public List list=new ArrayList();

public registerObserver(Observer observer){
    list.add(observer);
}
  public removeObserver(Observer observer){
    list.remove(observer);
}

public void notifyObservers(){
   for(list:item){
     item.update();
   }   
}

public void opration(){

    notifyObservers();

}
}

4.适配器模式
interface PS2{ void isPS2}
interface USB { void isUsb}
public class Usber implements usb{ public void isUsb(){ }}

（1）.类适配器

public AdapterOne extends Usber implements PS2{ public void isPs2{ isUsb()}}

(2).对象适配器

public AdapterOne implements PS2{ public AdapterOne(Usber usber){ this.usber=usber;} public void isPs2{

usber.isUsb()}}
（3).接口适配器

interface A { void A（），void B（），void C}

public abstract class Adapter implemntA{
void A（）{} void B（）{} void C（）{}

public class MyAdapter extends Adpater{

  void A（）{}......

}

5.策略模式

6.Builder模式（AlertDialog）
AlertDialog.Builder bulider= new AlertDialog.Builder(context).setTitle(R.string.app_name).setMessage("此版本已是最新版

本")
.setPositiveButton("好的", null);
AlertDialog alertDialog=bulider.show();

7.责任链模式

(1).构造Request{ name ,reason,days, groupLeaderInfo ,managerInfo,departLeaderInfo}对象和Result{ isRatify ,info}结果对象

(2).interface Chain { Request request();//获取当前的Request Result proceed(Request request)//转发Request}

(3).interface Ratify{ Result deal(Chain chain)}

(4). GroupLeader implements Ratify ( Result deal( return chain.proceed()or new Result))
Manager implements Ratify
CustomeLeader implements Ratify

(5)
RealChain implements Chain{
List list;
RealChain(List list,Requst requst ,int index){}

       request(){  return this.request}

       proceed（Request request）{
         Result result=null;
         if(list.size>index){
           Ratify ratify=list.get(index);//得到当前的责任人
           Realchain chain=new Realchain(list,request,index+1);//初始化责任的位置，以便转发过来的时候使用心得责任人
           result= ratify.deal(chain);
           
         }
         return result

        }

}
(6).新建链条客户端类
ChainClient {

List list;
addRatify(){ list.add()}//增加自定义的责任人

void executed(Request request){
List listNew= new List()
listNew.addAll(list);
listNew.add(new GroupLeader());
listNew.add(new Mannger());
listNew.add(new departLeader());
RealChain chain=new RealChain(list,request,0);

}

8.代理模式

public DynamicProxyHandle implements InvocationHandler{

  public DynamicProxyHandle(Object obj){
     this.obj=obj;
  }
  public Object invoke(Object proxy,Method method,Object[] args{

     Object proxy=method.invoke(obj,args);

     return proxy;

}

IBuy home=new Home();

DynamicProxyHandler dynamicHandler=new DynamicProxy(home);

Ibuy dynamicProxy=Proxy.newProxyInstance(home.getclass.getclassLoader,new Class[]{IBuy.class},dynamicHandler);

dynamicProxy.buy();

10.SQLite
(1).创建一个extendsSQLiteOpenHelper的类，并实现onOnCreate（建立表格的代码）和onUpgrade（删除原来表格，重新建立表格）方法

。

当表结构发生变化的时候，会自动触发onUpgrad()方法，删除原来的表，并重写创建新的表结构。

(2).在创建一个OrderDao用于处理所有的数据操作。
insert ,delete ,update, searchs

11.XML解析解析速度快，占用内存少，一旦开始无法暂停
(1).Sax解析，基于DefaultHandler，继承DefaultHandler 实现5大方法

startDocument endDocument startElement endElement characters 函数驱动型

(2).Dom解析占用的内存比较大，容易OOM 双层for循环， getElementByTagName()遍历

(3).解析速度快，消耗内存少，很灵活,Pull解析提供了开始标签START_TAG,END_TAG，while循环，更具标签进行解析,可以根据需要跳

出解析（parse.next）

12.Git常用命令

git init
git add index.html
git commit -m " beizhu"

git commit -am "添加并提交"

git log git status 项目目前的状态

git branch 查看当前分支

git branch develop 创建分支

git branch develop origin/test

git checkout develop 切换倒develop分支

git checkout -b develop 创建develop并切换到develop

git merge develop

git branch -d develop 删除本地分支

git branch -r -d origin/develop 删除远程分支

git push -u origin master

git remote add origin http://自己的仓库地址注册远程版本库的地址

git remote remove origin 删除远程版本库地址

git tag 1.0

git push origin 1.0

git show 1.0

13.Java面向对象

（1）封装
属性封装（private protected public ）
方法封装
内部类（成员内部类，静态内部类，方法内部类）

（2）继承

(3)多态

引用多态：Animal animal=new Animal()
Animal dog=new Dog();
方法多态：

Animal animal=new Animal() 可以访问Animal本类中的非private属性和方法

Animal dog=new Dog(); 可以只能访问Animal本类中的非private属性和方法，如果有重写父类的方法，调用的时调用的自己重写的，还有

自己添加的方法和属性

14.Java泛型
(1).泛型类
public class Generics{ private T key ; }
(2).泛型接口
public Interface Generics { public T next();}
(3).泛型方法
public T getKey(T t){}
(4).通配符和上下边界
Generics

上边界:Generics 只能传入T的子类

下边界:Generics 只能传入T的父类

15.抽象类和接口的区别
（1）.抽象类只能单继承，而接口却可以多实现

(2).抽象类中啥都有，但是抽象接口中一般不能有非抽象的方法。

(3).抽象类时对类的抽象，接口是对行为的抽象。(Door open close alarm

16.Java集合
(1)List
ArrayList 非同步的基于动态数组可以随机访问

LinkedList 非同步的基于双向链表不可以随机访问，必须从开头或者结尾遍历列表 Collect.synczoiedList()变成同步列表

Vector 是同步的，其余和ArrayList一样

Stack 继承自Vector ，提供pop push ,peek，empty，search方法

17.Handler和Looper，Message之间的关系
(1).ActivityThread类 App进程的初始化类,开启死循环
Looper.prepareMainLooper()
Looper.loop();

(2).new 一个Hanlder对象的时候，构建方法中对Looper和MessageQueue进行了初始化，
当我们调用handler.sendMessage()---->enqueueMessage（），将此Message注入到
Looper所在的MessageQueue队列中

(3).一旦Looper所在的MessageQueue队列中有message，loop（）死循环方法中，通过

queue.next拿到消息，如果消息不为null，那么msg.target.dispatchMessage()处理消息，

dispatchMessag内部会调用handlerMessage()方法。

18.自定义View和ViewGroup
(1).4个构造方法
new ，AttributeSet ，view 有style，api>=21且view有style属性的时候调用

(2).onMeassure()
specMode=MeasureSpec.Exactly 精确值
specMode=MeasureSpec.AT_MOST 取最大值
specMode=MeasureSpec.UNSPECIFIED 父容器对当前的View不限制

setMeasureDimension()设置View大小

onDraw View disPatchDraw ViewGruop

invalidate主线程 postInvalidate子线程

自定义属性attrs.recycle（）// 进行对象回收

onLayout（）中child.layout(), rquestLayout();

19.Android间的跨进程通信 https://www.cnblogs.com/andy-songwei/p/10256379.html
(1).Activity可以跨进程调用其他应用程序的Activity；
打电话 startActivity()来启动另外一个进程的Activity。

Intent callIntent = new Intent(Intent.ACTION_CALL, Uri.parse("tel:12345678"); 隐式Intent
startActivity(callIntent);
(2)ContentProvider可以跨进程访问其他应用程序中的数据（以Cursor对象形式返回），
当然，也可以对其他应用程序的数据进行增、删、改操作；
Android系统本身提供了很多Content Provider，例如，音频、视频、联系人信息等等。我们可以通过这些Content Provider获得相关信息

的列表。这些列表数据将以Cursor对象返回。因此，从Content Provider返回的数据是二维表的形式。

(3).Broadcast可以向android系统中所有应用程序发送广播，
而需要跨进程通讯的应用程序可以监听这些广播；
广播是一种被动跨进程通讯的方式。当某个程序向系统发送广播时，其他的应用程序只能被动地接收广播数据。这就象电台进行广播一样

，听众只能被动地收听，而不能主动与电台进行沟通。

(4)Service这种可以跨进程通讯的服务叫AIDL服务。
注意普通的Service并不能实现跨进程操作，实际上普通的Service和它所在的应用处于同一个进程中，而且它也不会专门开一条新的线程

，因此如果在普通的Service中实现在耗时的任务，需要新开线程。
要实现跨进程通信，需要借助AIDL(Android Interface Definition Language)。Android中的跨进程服务其实是采用C/S的架构，因而AIDL

的目的就是实现通信接口。

Socket 其实也可以实现跨进程调用，但是一般使用在网络通信中。

20.Android多线程实现
(1).继承Thread类

(2).实现Runable接口

(3).线程池

Executors.newFixedThreadPool 定长线程池，可以控制最大并发数，超出的线程会在队列中等待

Executors.newCachedThreadPool 可缓存的线程池，如果线程池长度超多处理的需要，可以灵活回收空闲线程，
如果没有可以回收的，也可新建线程。

Executors.newScheduledThreadPool 带有周期性质的定长线程线程，支持定时和周期任务的执行

Executors.newSingleThreadExecutor 单线程化的线程池，他确保了所有的任务都在一个线程中执行，不存在线程同步的问题。

new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue());

原理：https://www.cnblogs.com/dongguacai/p/6030187.html

21.MVC模式,MVP模式,MVVM模式

MVC模式
Modle JavaBean
View xml
Controler Activity业务逻辑，数据处理，UI处理
特点：所有的数据处理，UI处理都在Activity中，导致Activity上千行代码，非常冗余

MVP模式 compositeSubscrition(Rxjava1) compositeDisposed(Rxjava2)
BasePresenter{ addDisposed() removeDisposed(compositeDispose.disposed())}

BaseView { loading() success()}

HomePresenter接口 HomeView接口

abstract BaseActivity

P createPresenter (){ new HomePresenter(this)};

MVVM模式
BaseViewModel{ addDisposed removeDisposed}

abstract BaseActivity
M createViewModel()
onDestory { viewModel.removeDisposed()}

HomeViewModel {
HomeViewModel（Activity context,ViewDataBinding databing){}

context.showDialog()
addDisposed{}   处理各种请求
context.disDialog()

}

RecycleView多布局
onBindViewHolder onCreateViewHolder
ItemFruitBinding itemFruitBinding = DataBindingUtil.inflate(inflater, R.layout.item_fruit, parent, false);
return new FruitViewHolder(itemFruitBinding);

((FruitViewHolder) holder).getBinding().setItem(fruitBean);
((FruitViewHolder) holder).getBinding().executePendingBindings(); //解决databinding闪烁问题

22.框架原理
Glide
(1).三级缓存
内存缓存（skipMemoryCache(true)）
磁盘缓存 diskCacheStrategy(DiskCacheStrategy.None)

DiskCacheStrategy.None 不缓存

DiskCacheStrategy.All 缓存所有

DiskCacheStrategy.RESULT 缓存转换过的

DiskCacheStrategy.SOURCE 只缓存原图
网络读取
默认的内存磁盘缓存目录：data/data/包名/cache/image_manager_disk

默认的内存磁盘缓存目录：Android/data/包名/cache/

(2).源码分析
Glide绑定生命周期，Glide.with()根据传入的context对象和当前的线程创建不同的

RequestManager实例，如果是在UI线程中，context是Activity，则会创建一个能感知

Activity生命周期的RequestManager，如果context是Fragment，则会创建一个能感知

Fragment生命周期的RequestManager,如果是在非UI线程中或者传入ApplicationContext，则会一个applicationManager

对象，能感知application的生命周期，在创建RequestManager的同时，也会创建一个

SupportRequestManagerFragment，里面有onAttach,onStart,onStop,onDestory,onDetach等生命周期的方法，停止加载
图片，释放资源。

与Picasso的对比：
Glide可以加载Gif，Picasso不能.

Picasso.with()只能接受context作为参数，但是glide的可以是
context,activity，fragment glide能根据context的类型动态的
加载和释放资源，更加灵活。

23.Retrofit2.0
(1).创建和用法
mRetorift=new Retrofit.Builder().baseUrl(Base_URL).client(new OkHttpClient())
.addConvertFactory(GsonConverterFactory.create())
.addCallAdapterFactory(Rxjava2CallAdapterFactory.create()).build().

Get请求
@GET("article/list/{type}?")
Call getInfoList(@Path("type") String type, @Query("page") int page);

GET请求提交数据
@GET
("MyWeb/RegServlet") Call getRegInfo(@QueryMap Map map);

@GET
Observable getCheckVersion(@Url String url);

Post上传多个文件，同时上传表单数据:
@POST("MyWeb/UPloadServlet")
Call postUploadFilesMultipartBody(@Body MultipartBody multipartBody);}

@POST("/member/login")
Observable getLogin(@Body RequestBody requestBody);

@FormUrlEncoded
@POST("MyWeb/RegServlet")
Call postFormFieldMap(@FieldMap Map map);

(2).动态代理（代理类ApiService在程序运行时动态生成，这种方式就叫做动态代理）
public T create(final Class service) {
Utils.validateServiceInterface(service);
if (validateEagerly) {
eagerlyValidateMethods(service);
}
return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class[] { service },
new InvocationHandler() {
private final Platform platform = Platform.get();

      @Override public Object invoke(Object proxy, Method method, Object[] args)
          throws Throwable {
        // If the method is a method from Object then defer to normal invocation.
        if (method.getDeclaringClass() == Object.class) {
          return method.invoke(this, args);
        }
        if (platform.isDefaultMethod(method)) {
          return platform.invokeDefaultMethod(method, service, proxy, args);
        }
        ServiceMethod serviceMethod =
            (ServiceMethod) loadServiceMethod(method);
        OkHttpCall

面试笔记记录

你可能感兴趣的:(面试笔记记录)