CrossWalk之XWalkView使用

发表于 2019-05-16 | 分类于 Android ， WebView

XwalkView属性配置

@SuppressLint("SetJavaScriptEnabled")
    public void init() {
        if (BuildConfig.DEBUG) {
            XWalkPreferences.setValue(XWalkPreferences.REMOTE_DEBUGGING, true);
        }

        //声明WebSettings子类
        XWalkSettings webSettings = getSettings();
        //如果访问的页面中要与Javascript交互，则webview必须设置支持Javascript
        webSettings.setJavaScriptEnabled(true);
        // 若加载的 html 里有JS 在执行动画等操作，会造成资源浪费（CPU、电量）
        // 在 onStop 和 onResume 里分别把 setJavaScriptEnabled() 给设置成 false 和 true 即可

        //支持插件
        //webSettings.setPluginsEnabled(true);

        //设置自适应屏幕，两者合用
        //将图片调整到适合webview的大小
        webSettings.setUseWideViewPort(true);
        //缩放至屏幕的大小
        webSettings.setLoadWithOverviewMode(true);

        //缩放操作
        //支持缩放，默认为true。是下面那个的前提。
        webSettings.setSupportZoom(true);
        //设置内置的缩放控件。若为false，则该WebView不可缩放
        webSettings.setBuiltInZoomControls(true);
        //webSettings.setDisplayZoomControls(false); //隐藏原生的缩放控件

        //其他细节操作
        //关闭webview中缓存
        webSettings.setCacheMode(WebSettings.LOAD_NO_CACHE);
        //设置可以访问文件
        webSettings.setAllowFileAccess(true);
        //支持通过JS打开新窗口
        webSettings.setJavaScriptCanOpenWindowsAutomatically(true);
        //支持自动加载图片
        webSettings.setLoadsImagesAutomatically(true);
        //webSettings.setDefaultTextEncodingName("utf-8");//设置编码格式

        //设置背景为白色
        setBackgroundColor(Color.WHITE);
        //设置排序
        setZOrderOnTop(true);
        Log.i("XwalkViewWebContainer", "Version:" + getXWalkVersion());
    }

Android系统WebView使用

发表于 2019-05-16 | 分类于 Android ， WebView

#Android系统WebView使用

WebView属性配置

public void init() {
        if (BuildConfig.DEBUG) {
            setWebContentsDebuggingEnabled(true);
        }
        //声明WebSettings子类
        WebSettings webSettings = getSettings();
        //如果访问的页面中要与Javascript交互，则webview必须设置支持Javascript
        webSettings.setJavaScriptEnabled(true);
        // 若加载的 html 里有JS 在执行动画等操作，会造成资源浪费（CPU、电量）
        // 在 onStop 和 onResume 里分别把 setJavaScriptEnabled() 给设置成 false 和 true 即可

        //支持插件
        //webSettings.setPluginsEnabled(true);

        //设置自适应屏幕，两者合用
        webSettings.setUseWideViewPort(true); //将图片调整到适合webview的大小
        webSettings.setLoadWithOverviewMode(true); // 缩放至屏幕的大小

        //缩放操作
        webSettings.setSupportZoom(true); //支持缩放，默认为true。是下面那个的前提。
        webSettings.setBuiltInZoomControls(true); //设置内置的缩放控件。若为false，则该WebView不可缩放
        webSettings.setDisplayZoomControls(false); //隐藏原生的缩放控件

        //其他细节操作
        webSettings.setCacheMode(WebSettings.LOAD_CACHE_ELSE_NETWORK); //关闭webview中缓存
        webSettings.setAllowFileAccess(true); //设置可以访问文件
        webSettings.setJavaScriptCanOpenWindowsAutomatically(true); //支持通过JS打开新窗口
        webSettings.setLoadsImagesAutomatically(true); //支持自动加载图片
        webSettings.setDefaultTextEncodingName("utf-8");//设置编码格式
}

Java基础知识（转&添加）

发表于 2019-05-15 | 分类于 Java

Java基础知识（转&添加）

[TOC]

java中“==”和equals的区别以及hashCode的区别

`==`概述

==即可以比较基本类型数据也可以比较对象数据，进行基本数据类型比较时比较的是值，进行对象比较时比较的是对象的内存地址。

`equals`概述

它的作用也是判断两个对象是否相等。equals只能比较对象，即使Objects.equals()”可以”比较两个基本值类型变量，但它实际上比较的时自动装箱过后的值类型对应的对象。IDE也会建议用==比较基本数据类型。但equals一般有两种使用情况：

情况一：类没有覆盖equals()方法。则通过 equals() 比较该类的两个对象时，等价于通过“==”比较这两个对象。
情况二：类有覆盖equals()方法。一般，我们都覆盖 equals() 方法来判断两个对象的内容相等；若它们的内容相等，则返回 true (即，认为这两个对象相等)。

举个例子：

public class test1 {
    public static void main(String[] args) {
        String a = new String("ab"); // a 为一个引用
        String b = new String("ab"); // b为另一个引用,对象的内容一样
        String aa = "ab"; // 放在常量池中
        String bb = "ab"; // 从常量池中查找
        if (aa == bb) // true
            System.out.println("aa==bb");
        if (a == b) // false，非同一对象
            System.out.println("a==b");
        if (a.equals(b)) // true
            System.out.println("aEQb");
        if (42 == 42.0) { // true
            System.out.println("true");
        }
    }
}

注：

String是对象类型，继承了Object，但是它是重写了equals()方法的，因为object中的equals是比较的对象内存地址，String比较的是对象的值
当创建 String 类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个 String 对象。

hashCode 与 equals

面试官可能会问你：“你重写过 hashcode 和 equals 么，为什么重写equals时必须重写hashCode方法？”

hashCode（）介绍
hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在JDK的Object.java中，这就意味着Java中的任何类都包含有hashCode() 函数。

散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象）

为什么要有 hashCode

我们先以“HashSet 如何检查重复”为例子来说明为什么要有 hashCode：

当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashcode 值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象，这时会调用 equals（）方法来检查 hashcode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。（摘自《Head first java》第二版）。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。

通过上述我们可以看出：hashCode() 的作用就是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode()在散列表中才有用，在其它情况下没用。在散列表中hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。

hashCode（）与equals（）的相关规定

如果两个对象相等，则hashcode一定也是相同的
两个对象相等,对两个对象分别调用equals方法都返回true
两个对象有相同的hashcode值，它们也不一定是相等的
因此，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖
hashCode() 的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode()，则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）

基本数据类型各占多少字节、多少位

注：bit 位

类型	名字	字节（8bit）	位
byte	字节	1	1*8
char	字符	2	2*8=16
short	短整型	2	2*8=16
int	整形	4	4*8=32
long	长整型	8	8*8=64
float	单精度浮点数	4	4*8=32
double	双精度浮点型	8	8*8=64
boolean	布尔值	-	-

注：boolean 只有两个值：true、false，可以使用 1 bit 来存储，但是具体大小没有明确规定。JVM 会在编译时期将 boolean 类型的数据转换为 int，使用 1 来表示 true，0 表示 false。JVM 支持 boolean 数组，但是是通过读写 byte 数组来实现的。

包装类型 int与Integer的区别

基本类型都有对应的包装类型，基本类型与其对应的包装类型之间的赋值使用自动装箱与拆箱完成。

1 2	Integer x = 2; // 装箱 int y = x; // 拆箱

面向对象思想

封装

利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体。数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。用户无需知道对象内部的细节，但可以通过对象对外提供的接口来访问该对象。

优点：

减少耦合：可以独立地开发、测试、优化、使用、理解和修改
减轻维护的负担：可以更容易被程序员理解，并且在调试的时候可以不影响其他模块
有效地调节性能：可以通过剖析确定哪些模块影响了系统的性能
提高软件的可重用性
降低了构建大型系统的风险：即使整个系统不可用，但是这些独立的模块却有可能是可用的

以下 Person 类封装 name、gender、age 等属性，外界只能通过 get() 方法获取一个 Person 对象的 name 属性和 gender 属性，而无法获取 age 属性，但是 age 属性可以供 work() 方法使用。

注意到 gender 属性使用 int 数据类型进行存储，封装使得用户注意不到这种实现细节。并且在需要修改 gender 属性使用的数据类型时，也可以在不影响客户端代码的情况下进行。

public class Person {

    private String name;
    private int gender;
    private int age;

    public String getName() {
        return name;
    }

    public String getGender() {
        return gender == 0 ? "man" : "woman";
    }

    public void work() {
        if (18 <= age && age <= 50) {
            System.out.println(name + " is working very hard!");
        } else {
            System.out.println(name + " can't work any more!");
        }
    }
}

继承

继承实现了 IS-A 关系，例如 Cat 和 Animal 就是一种 IS-A 关系，因此 Cat 可以继承自 Animal，从而获得 Animal 非 private 的属性和方法。

继承应该遵循里氏替换原则，子类对象必须能够替换掉所有父类对象。

Cat 可以当做 Animal 来使用，也就是说可以使用 Animal 引用 Cat 对象。父类引用指向子类对象称为 向上转型 。

1	Animal animal = new Cat();

多态

多态分为编译时多态和运行时多态：

编译时多态主要指方法的重载
运行时多态指程序中定义的对象引用所指向的具体类型在运行期间才确定

运行时多态有三个条件：

继承
覆盖（重写）
向上转型

下面的代码中，乐器类（Instrument）有两个子类：Wind 和 Percussion，它们都覆盖了父类的 play() 方法，并且在 main() 方法中使用父类 Instrument 来引用 Wind 和 Percussion 对象。在 Instrument 引用调用 play() 方法时，会执行实际引用对象所在类的 play() 方法，而不是 Instrument 类的方法。

public class Instrument {

    public void play() {
        System.out.println("Instument is playing...");
    }
}

public class Wind extends Instrument {

    public void play() {
        System.out.println("Wind is playing...");
    }
}

public class Percussion extends Instrument {

    public void play() {
        System.out.println("Percussion is playing...");
    }
}

public class Music {

    public static void main(String[] args) {
        List<Instrument> instruments = new ArrayList<>();
        instruments.add(new Wind());
        instruments.add(new Percussion());
        for(Instrument instrument : instruments) {
            instrument.play();
        }
    }
}

String、StringBuffer、StringBuilder区别

1. 可变性

String 不可变
StringBuffer 和 StringBuilder 可变

2. 线程安全

String 不可变，因此是线程安全的
StringBuilder 不是线程安全的
StringBuffer 是线程安全的，内部使用 synchronized 进行同步

StackOverflow : String, StringBuffer, and StringBuilder

什么是内部类？内部类的作用

Java内部类详解

　　在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。广泛意义上的内部类一般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类。下面就先来了解一下这四种内部类的用法

内部类分类

成员内部类

成员内部类是最普通的内部类，它的定义为位于另一个类的内部，形如下面的形式：

class Circle {

    double radius = 0;

    public Circle(double radius) {
        this.radius = radius;
    }

    //内部类
    class Draw {     
        public void drawSahpe() {
            System.out.println( "drawshape" );
        }
    }
}

这样看起来，类Draw像是类Circle的一个成员，Circle称为外部类。成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。

class Circle {
    private double radius = 0;
    public static int count =1;
    public Circle(double radius) {
        this.radius = radius;
    }
     
    class Draw {     //内部类
        public void drawSahpe() {
            System.out.println(radius);  //外部类的private成员
            System.out.println(count);   //外部类的静态成员
        }
    }
}

成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象。创建成员内部类对象的一般方式如下：

public class Test {
    public static void main(String[] args)  {
        //第一种方式：
        Outter outter = new Outter();
        Outter.Inner inner = outter.new Inner();  //必须通过Outter对象来创建
         
        //第二种方式：
        Outter.Inner inner1 = outter.getInnerInstance();
    }
}
 
class Outter {
    private Inner inner = null;
    public Outter() {
         
    }
     
    public Inner getInnerInstance() {
        if(inner == null)
            inner = new Inner();
        return inner;
    }
      
    class Inner {
        public Inner() {
             
        }
    }
}

　　内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。比如上面的例子，如果成员内部类Inner用private修饰，则只能在外部类的内部访问，如果用public修饰，则任何地方都能访问；如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限，则只能在同一个包下访问。这一点和外部类有一点不一样，外部类只能被public和包访问两种权限修饰。我个人是这么理解的，由于成员内部类看起来像是外部类的一个成员，所以可以像类的成员一样拥有多种权限修饰。　　

局部内部类

局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。

class People{
    public People() {
         
    }
}
 
class Man{
    public Man(){
         
    }
     
    public People getWoman(){
        class Woman extends People{   //局部内部类
            int age =0;
        }
        return new Woman();
    }
}

　　注意，局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。

匿名内部类

匿名内部类应该是平时我们编写代码时用得最多的，在编写事件监听的代码时使用匿名内部类不但方便，而且使代码更加容易维护。下面这段代码是一段Android事件监听代码：

scan_bt.setOnClickListener(new OnClickListener() {
             
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                 
            }
});
         
        history_bt.setOnClickListener(new OnClickListener() {
             
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                 
            }
        });

　　这段代码为两个按钮设置监听器，这里面就使用了匿名内部类。这段代码中的：

new OnClickListener() {
             
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                 
            }
        }

　　
就是匿名内部类的使用。代码中需要给按钮设置监听器对象，使用匿名内部类能够在实现父类或者接口中的方法情况下同时产生一个相应的对象，但是前提是这个父类或者接口必须先存在才能这样使用。当然像下面这种写法也是可以的，跟上面使用匿名内部类达到效果相同。

private void setListener()
{
    scan_bt.setOnClickListener(new Listener1());       
    history_bt.setOnClickListener(new Listener2());
}
 
class Listener1 implements View.OnClickListener{
    @Override
    public void onClick(View v) {
    // TODO Auto-generated method stub
             
    }
}
 
class Listener2 implements View.OnClickListener{
    @Override
    public void onClick(View v) {
    // TODO Auto-generated method stub
             
    }
}

　　这种写法虽然能达到一样的效果，但是既冗长又难以维护，所以一般使用匿名内部类的方法来编写事件监听代码。同样的，匿名内部类也是不能有访问修饰符和static修饰符的。

　　匿名内部类是唯一一种没有构造器的类。正因为其没有构造器，所以匿名内部类的使用范围非常有限，大部分匿名内部类用于接口回调。匿名内部类在编译的时候由系统自动起名为Outter$1.class。一般来说，匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。　　

静态内部类

静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法，这点很好理解，因为在没有外部类的对象的情况下，可以创建静态内部类的对象，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体的对象。

public class Test {
    public static void main(String[] args)  {
        Outter.Inner inner = new Outter.Inner();
    }
}
 
class Outter {
    public Outter() {
         
    }
     
    static class Inner {
        public Inner() {
             
        }
    }
}

内部类的作用

内部类可以很好的实现隐藏

一般的非内部类，是不允许有 private 与protected权限的，但内部类可以

内部类拥有外围类的所有元素的访问权限

为什么可以引用：
内部类虽然和外部类写在同一个文件中，但是编译完成后，还是生成各自的class文件，内部类通过this访问外部类的成员。

编译器自动为内部类添加一个成员变量，这个成员变量的类型和外部类的类型相同，这个成员变量就是指向外部类对象(this)的引用；
编译器自动为内部类的构造方法添加一个参数，参数的类型是外部类的类型，在构造方法内部使用这个参数为内部类中添加的成员变量赋值；
在调用内部类的构造函数初始化内部类对象时，会默认传入外部类的引用。

可是实现多重继承

我们知道 java 是不允许使用 extends 去继承多个类的。内部类的引入可以很好的解决这个事情。
以下引用《Thinking In Java》中的一段话：

每个内部类都可以队里的继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类没有影响
如果没有内部类提供的、可以继承多个具体的或抽象的类的能力，一些设计与编程问题就难以解决。
接口解决了部分问题，一个类可以实现多个接口，内部类允许继承多个非接口类型（类或抽象类）。

我的理解 Java只能继承一个类这个学过基本语法的人都知道，而在有内部类之前它的多重继承方式是用接口来实现的。但使用接口有时候有很多不方便的地方。比如我们实现一个接口就必须实现它里面的所有方法。而有了内部类就不一样了。它可以使我们的类继承多个具体类或抽象类。

可以避免修改接口而实现同一个类中两种同名方法的调用

抽象类和接口区别

接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。

抽象类的意义

定义：
如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。

父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

抽象类总结规定：

抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。
抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。
构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。
抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

抽象类与接口的应用场景

interface的应用场合

类与类之前需要特定的接口进行协调，而不在乎其如何实现。
作为能够实现特定功能的标识存在，也可以是什么接口方法都没有的纯粹标识。
需要将一组类视为单一的类，而调用者只通过接口来与这组类发生联系。
需要实现特定的多项功能，而这些功能之间可能完全没有任何联系。

abstract class的应用场合

一句话，在既需要统一的接口，又需要实例变量或缺省的方法的情况下，就可以使用它。最常见的有：

定义了一组接口，但又不想强迫每个实现类都必须实现所有的接口。可以用abstract class定义一组方法体，甚至可以是空方法体，然后由子类选择自己所感兴趣的方法来覆盖。
某些场合下，只靠纯粹的接口不能满足类与类之间的协调，还必需类中表示状态的变量来区别不同的关系。abstract的中介作用可以很好地满足这一点。
规范了一组相互协调的方法，其中一些方法是共同的，与状态无关的，可以共享的，无需子类分别实现；而另一些方法却需要各个子类根据自己特定的状态来实现特定的功能

抽象类是否可以没有方法和属性？

抽象类专用于派生出子类，子类必须实现抽象类所声明的抽象方法，否则，子类仍是抽象类。
包含抽象方法的类一定是抽象类，但抽象类中的方法不一定是抽象方法。
抽象类中可以没有抽象方法，但有抽象方法的一定是抽象类。所以，java中抽象类里面可以没有抽象方法。比如HttpServlet类。抽象类和普通类的区别就在于，抽象类不能被实例化，就是不能被new出来，即使抽象类里面没有抽象方法。
抽象类的作用在于子类对其的继承和实现，也就是多态；而没有抽象方法的抽象类的存在价值在于：实例化了没有意义，因为类已经定义好了，不能改变其中的方法体，但是实例化出来的对象却满足不了要求，只有继承并重写了他的子类才能满足要求。所以才把它定义为没有抽象方法的抽象类

接口的意义

简单地说：接口的作用就是把使用接口的人和实现接口的人分开，实现接口的人不必要关心谁去使用，而使用接口的人也不用关心实现的细节。
4点关于JAVA中接口存在的意义：

重要性：在Java语言中， abstract class 和interface 是支持抽象类定义的两种机制。正是由于这两种机制的存在，才赋予了Java强大的面向对象能力。
简单、规范性：如果一个项目比较庞大，那么就需要一个能理清所有业务的架构师来定义一些主要的接口，这些接口不仅告诉开发人员你需要实现那些业务，而且也将命名规范限制住了（防止一些开发人员随便命名导致别的程序员无法看明白）。
维护、拓展性：比如有一个类，实现了某个功能，突然有一天，发现这个类满足不了需求了，然后又要重新设计这个类，更糟糕是你可能要放弃这个类，那么其他地方可能有引用他，这样修改起来很麻烦。

如果一开始定义一个接口，把功能放在接口里，然后定义类时实现这个接口，然后只要用这个接口去引用实现它的类就行了，以后要换的话只不过是引用另一个类而已，这样就达到维护、拓展的方便性。比如有个method1的方法，如果用接口，【接口名】【对象名】=new 【实现接口的类】，这样想用哪个类的对象就可以new哪个对象了，new a（）；就是用a的方法，new b（）就是用b的方法，就和USB接口一样，插什么读什么，就是这个原理。

你要做一个画板程序，其中里面有一个面板类，主要负责绘画功能，然后你就这样定义了这个类。

安全、严密性：接口是实现软件松耦合的重要手段，它描叙了系统对外的所有服务，而不涉及任何具体的实现细节。这样就比较安全、严密一些（一般软件服务商考虑的比较多，jdk中很多方法就是实现了某个接口）。

泛型中extends和super的区别

【Java】泛型中 extends 和 super 的区别

父类的静态方法能否被子类重写

答案：不能
原因：因为静态方法从程序开始运行后就已经分配了内存，也就是说已经写死了。所有引用到该方法的对象（父类的对象也好子类的对象也好）所指向的都是同一块内存中的数据，也就是该静态方法。子类中如果定义了相同名称的静态方法，并不会重写，而应该是在内存中又分配了一块给子类的静态方法，没有重写这一说。

进程和线程的区别

进程和线程的区别
 进程和线程的区别（故事版）

final，finally，finalize的区别

final 用于声明属性,方法和类, 分别表示属性不可变, 方法不可覆盖, 类不可继承.
finally 是异常处理语句结构的一部分，表示总是执行.
finalize 是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等. JVM不保证此方法总被调用.

序列化

定义

序列化（serialization）定义：在计算机科学的数据处理中，是指将数据结构或对象状态转换成可取用格式（例如存成文件，存于缓冲，或经由网络中发送），以留待后续在相同或另一台计算机环境中，能恢复原先状态的过程。依照序列化格式重新获取字节的结果时，可以利用它来产生与原始对象相同语义的副本。对于许多对象，像是使用大量引用的复杂对象，这种序列化重建的过程并不容易。面向对象中的对象序列化，并不概括之前原始对象所关系的函数。这种过程也称为对象编组（marshalling）。从一系列字节提取数据结构的反向操作，是反序列化（也称为解编组、deserialization、unmarshalling）。

序列化在计算机科学中通常有以下定义:

对同步控制而言，表示强制在同一时间内进行单一访问。
在数据储存与发送的部分是指将一个对象存储至一个存储介质，例如文件或是存储器缓冲等，或者透过网络发送数据时进行编码的过程，可以是字节或是XML等格式。而字节的或XML编码格式可以还原完全相等的对象。这程序被应用在不同应用程序之间发送对象，以及服务器将对象存储到文件或数据库。相反的过程又称为反序列化。

简单地说，“序列化”就是将运行时的对象状态转换成二进制，然后保存到流、内存或者通过网络传输给其他端。

序列化参考：
Android 进阶6：两种序列化方式 Serializable 和 Parcelable

方式

Android中序列化方式有两种：

Serializable
Parcelable

两者都是支持序列化和反序列化的操作。

区别

API Serializable是Java API，Parcelable是Android的API
效率
Serializable 会使用反射，序列化和反序列化过程需要大量 I/O 操作， Parcelable 自已实现封送和解封（marshalled &unmarshalled）操作不需要用反射，数据也存放在 Native 内存中，效率要快很多。

总结：可以看到，Serializable 的使用比较简单，创建一个版本号即可；而 Parcelable 则相对复杂一些，会有四个方法需要实现。

一般在保存数据到 SD 卡或者网络传输时建议使用 Serializable 即可，虽然效率差一些，好在使用方便。

而在运行时数据传递时建议使用 Parcelable，比如 Intent，Bundle 等，Android 底层做了优化处理，效率很高。

静态属性和静态方法是否可以被继承？是否可以被重写？以及原因？

参考一：https://www.cnblogs.com/kabi/p/5181941.html
参考二：https://blog.csdn.net/jinyongqing/article/details/7669605

静态内部类的设计意图

参考一：https://zhuanlan.zhihu.com/p/29623665

成员内部类、静态内部类、局部内部类和匿名内部类的理解，以及项目中的应用

参考一：https://www.cnblogs.com/chenssy/p/3388487.html

谈谈对kotlin的理解

参考一：http://shinelw.com/2017/03/17/kotlin-apply-in-coding/

闭包和局部内部类的区别

参考一：https://blog.csdn.net/u010412719/article/details/49453235

string 转换成 integer的方式及原理

参考一：https://blog.csdn.net/itboy_libing/article/details/80393530

Android事件分发机制

发表于 2019-03-26 | 分类于 Android ，自定义view

Android事件分发机制

1、概述

本次分享有一个非常重要的概念：View，虽然说View不属于四大组件，但是它的作用堪比四大组件，甚至比Receiver和Provider的重要性都要大。在Android开发中，Activity承担这可视化的功能，同时Android系统提供了很多基础控件，常见的有Button、TextView、CheckBox等。很多时候仅仅使用系统提供的控件是不能满足需求的，因此我们就需要能够根据需求进行新控件的定义，而控件的自定义就需要对Android的View体系有深入的理解，只有这样才能写出完美的自定义控件。同时Android手机属于移动设备，移动设备的一个特点就是用户可以直接通过屏幕来进行一系列操作，一个典型的场景就是屏幕的滑动，用户可以通过滑动来切换到不同的界面。很多情况下我们的应用都需要支持滑动操作，当处于不同层级的View都可以响应用户的滑动操作时，就会带来一个问题，那就是滑动冲突。如何解决滑动冲突呢？这对于初学者来说的确是个头疼的问题，其实解决滑动冲突本不难，它需要读者对View的事件分发机制有一定的了解，在这个基础上，我们就可以利于这个特性从而得出滑动冲突的解决方法。
——摘自Android开发艺术探索

2、事件分发概述

事件指的是什么呢？就是指用户触摸屏幕产生的Touch事件；在Android中它被封装成MotionEvent。

3、常用`MotionEvent`分类

ACTION_DOWN：按下View（其他所有事件的开始）。
ACTION_UP：抬起View（与DOWN对应）。
ACTION_MOVE：滑动View。
ACTION_CANCEL：结束事件（非人为原因）。

其余事件：ACTION_MASK、ACTION_OUTSIDE、ACTION_POINTER_DOWN、
ACTION_POINTER_UP、ACTION_HOVER_MOVE、ACTION_SCROLL、
ACTION_HOVER_ENTER、ACTION_HOVER_EXIT、ACTION_BUTTON_PRESS、
ACTION_BUTTON_RELEASE、ACTION_POINTER_INDEX_MASK、
ACTION_POINTER_INDEX_SHIFT；有兴趣的可以下来自己了解。

3、事件产生顺序

4、Android事件扭转流程

模拟：

经理分派任务，下属处理这个任务的过程。

View层次示例
View内部事件处理流程图：

5、事件分发流程及其分析

流程图及注释

流程分析

流程1:在Activity#dispatchTouchEvent返回false/true
当前流程是在Activity#dispatchTouchEvent拦截并消费事件，不再往下传递

03-26 18:54:58.178 com.android.api23 I/com.android.api23.MainActivity: dispatchTouchEvent#event:0
流程2:在ViewGroup#dispatchTouchEvent返回true：
当前流程是ViewGroup#dispatchTouchEvent拦截并消费事件，事件不再往下传递

03-26 19:08:23.268 com.android.api23 I/com.android.api23.MainActivity: dispatchTouchEvent#event:0
03-26 19:08:23.268 com.android.api23 I/com.android.api23.MyViewGroup: dispatchTouchEvent#event:0
流程3:在ViewGroup#dispatchTouchEvent返回false：
当前流程是停止往当前ViewGroup及其子View事件，并将当前事件交由父类onTouchEvent处理。

03-26 19:09:15.238 com.android.api23 I/com.android.api23.MainActivity: dispatchTouchEvent#event:0
03-26 19:09:15.238 com.android.api23 I/com.android.api23.MyViewGroup: dispatchTouchEvent#event:0
03-26 19:09:15.238 com.android.api23 I/com.android.api23.MainActivity: onTouchEvent#event:0
流程4:在ViewGroup#onInterceptTouchEvent返回true：

03-26 19:07:02.918 com.android.api23 I/com.android.api23.MainActivity: dispatchTouchEvent#event:0
03-26 19:07:02.918 com.android.api23 I/com.android.api23.MyViewGroup: dispatchTouchEvent#event:0
03-26 19:07:02.918 com.android.api23 I/com.android.api23.MyViewGroup: onInterceptTouchEvent#event:0
03-26 19:07:02.918 com.android.api23 I/com.android.api23.MyViewGroup: onTouchEvent#event:0
03-26 19:07:02.918 com.android.api23 I/com.android.api23.MainActivity: onTouchEvent#event:0
在ViewGroup#onInterceptTouchEvent返回false
当前流程为系统默认流程即：ViewGroup不拦截事件，事件将往下一级传递

03-26 19:06:11.008 com.android.api23 I/com.android.api23.MainActivity: dispatchTouchEvent#event:0
03-26 19:06:11.018 com.android.api23 I/com.android.api23.MyViewGroup: dispatchTouchEvent#event:0
03-26 19:06:11.018 com.android.api23 I/com.android.api23.MyViewGroup: onInterceptTouchEvent#event:0
03-26 19:06:11.018 com.android.api23 I/com.android.api23.MyView: dispatchTouchEvent#event:0
03-26 19:06:11.018 com.android.api23 I/com.android.api23.MyView: onTouchEvent#event:0
03-26 19:06:11.018 com.android.api23 I/com.android.api23.MyViewGroup: onTouchEvent#event:0
03-26 19:06:11.018 com.android.api23 I/com.android.api23.MainActivity: onTouchEvent#event:0
流程5:在View#dispatchTouchEvent返回true：
当前流程是ViewGroup#dispatchTouchEvent拦截并消费事件，事件不再往下传递

03-26 19:10:41.048 com.android.api23 I/com.android.api23.MainActivity: dispatchTouchEvent#event:0
03-26 19:10:41.048 com.android.api23 I/com.android.api23.MyViewGroup: dispatchTouchEvent#event:0
03-26 19:10:41.048 com.android.api23 I/com.android.api23.MyViewGroup: onInterceptTouchEvent#event:0
03-26 19:10:41.048 com.android.api23 I/com.android.api23.MyView: dispatchTouchEvent#event:0
流程6:在View#dispatchTouchEvent返回false：

03-26 19:11:36.458 com.android.api23 I/com.android.api23.MainActivity: dispatchTouchEvent#event:0
03-26 19:11:36.458 com.android.api23 I/com.android.api23.MyViewGroup: dispatchTouchEvent#event:0
03-26 19:11:36.458 com.android.api23 I/com.android.api23.MyViewGroup: onInterceptTouchEvent#event:0
03-26 19:11:36.458 com.android.api23 I/com.android.api23.MyView: dispatchTouchEvent#event:0
03-26 19:11:36.458 com.android.api23 I/com.android.api23.MyViewGroup: onTouchEvent#event:0
03-26 19:11:36.458 com.android.api23 I/com.android.api23.MainActivity: onTouchEvent#event:0
流程7:在View#onTouchEvent返回true：

03-26 19:12:51.688 com.android.api23 I/com.android.api23.MainActivity: dispatchTouchEvent#event:0
03-26 19:12:51.688 com.android.api23 I/com.android.api23.MyViewGroup: dispatchTouchEvent#event:0
03-26 19:12:51.688 com.android.api23 I/com.android.api23.MyViewGroup: onInterceptTouchEvent#event:0
03-26 19:12:51.688 com.android.api23 I/com.android.api23.MyView: dispatchTouchEvent#event:0
03-26 19:12:51.688 com.android.api23 I/com.android.api23.MyView: onTouchEvent#event:0
在View#onTouchEvent返回false：
当前流程为系统默认流程

03-26 19:13:58.188 com.android.api23 I/com.android.api23.MainActivity: dispatchTouchEvent#event:0
03-26 19:13:58.188 com.android.api23 I/com.android.api23.MyViewGroup: dispatchTouchEvent#event:0
03-26 19:13:58.188 com.android.api23 I/com.android.api23.MyViewGroup: onInterceptTouchEvent#event:0
03-26 19:13:58.188 com.android.api23 I/com.android.api23.MyView: dispatchTouchEvent#event:0
03-26 19:13:58.188 com.android.api23 I/com.android.api23.MyView: onTouchEvent#event:0
03-26 19:13:58.188 com.android.api23 I/com.android.api23.MyViewGroup: onTouchEvent#event:0
03-26 19:13:58.188 com.android.api23 I/com.android.api23.MainActivity: onTouchEvent#event:0
流程8:在ViewGroup#onTouchEvent返回true：

03-26 19:15:14.608 com.android.api23 I/com.android.api23.MainActivity: dispatchTouchEvent#event:0
03-26 19:15:14.608 com.android.api23 I/com.android.api23.MyViewGroup: dispatchTouchEvent#event:0
03-26 19:15:14.608 com.android.api23 I/com.android.api23.MyViewGroup: onInterceptTouchEvent#event:0
03-26 19:15:14.608 com.android.api23 I/com.android.api23.MyView: dispatchTouchEvent#event:0
03-26 19:15:14.608 com.android.api23 I/com.android.api23.MyView: onTouchEvent#event:0
03-26 19:15:14.608 com.android.api23 I/com.android.api23.MyViewGroup: onTouchEvent#event:0
在ViewGroup#onTouchEvent返回false：
当前流程为系统默认流程

03-26 19:16:48.928 com.android.api23 I/com.android.api23.MainActivity: dispatchTouchEvent#event:0
03-26 19:16:48.928 com.android.api23 I/com.android.api23.MyViewGroup: dispatchTouchEvent#event:0
03-26 19:16:48.928 com.android.api23 I/com.android.api23.MyViewGroup: onInterceptTouchEvent#event:0
03-26 19:16:48.928 com.android.api23 I/com.android.api23.MyView: dispatchTouchEvent#event:0
03-26 19:16:48.928 com.android.api23 I/com.android.api23.MyView: onTouchEvent#event:0
03-26 19:16:48.928 com.android.api23 I/com.android.api23.MyViewGroup: onTouchEvent#event:0
03-26 19:16:48.928 com.android.api23 I/com.android.api23.MainActivity: onTouchEvent#event:0
流程9:在Activity#onTouchEvent返回true：

03-26 19:18:49.648 com.android.api23 I/com.android.api23.MainActivity: dispatchTouchEvent#event:0
03-26 19:18:49.648 com.android.api23 I/com.android.api23.MyViewGroup: dispatchTouchEvent#event:0
03-26 19:18:49.648 com.android.api23 I/com.android.api23.MyViewGroup: onInterceptTouchEvent#event:0
03-26 19:18:49.648 com.android.api23 I/com.android.api23.MyView: dispatchTouchEvent#event:0
03-26 19:18:49.648 com.android.api23 I/com.android.api23.MyView: onTouchEvent#event:0
03-26 19:18:49.648 com.android.api23 I/com.android.api23.MyViewGroup: onTouchEvent#event:0
03-26 19:18:49.648 com.android.api23 I/com.android.api23.MainActivity: onTouchEvent#event:0
在Activity#onTouchEvent返回false：
当前流程为系统默认流程

03-26 19:20:07.738 com.android.api23 I/com.android.api23.MainActivity: dispatchTouchEvent#event:0
03-26 19:20:07.738 com.android.api23 I/com.android.api23.MyViewGroup: dispatchTouchEvent#event:0
03-26 19:20:07.738 com.android.api23 I/com.android.api23.MyViewGroup: onInterceptTouchEvent#event:0
03-26 19:20:07.738 com.android.api23 I/com.android.api23.MyView: dispatchTouchEvent#event:0
03-26 19:20:07.738 com.android.api23 I/com.android.api23.MyView: onTouchEvent#event:0
03-26 19:20:07.738 com.android.api23 I/com.android.api23.MyViewGroup: onTouchEvent#event:0
03-26 19:20:07.738 com.android.api23 I/com.android.api23.MainActivity: onTouchEvent#event:0

AndroidApi23：Android事件分发机制测试Demo

微信小程序之文件系统初探

发表于 2019-03-22 | 分类于微信小程序

微信小程序之文件系统初探

1、文件下载

 //下载文件
go_download: function() {
  var content = this;
  var baseUrl = "http://rwh.blob.core.chinacloudapi.cn";
  var fileName = "1-e2b214af930149ee80c8142d067148a7.exam";
  var url = baseUrl + "/data/ExamBuilder2.0/20190320" + "/" + fileName;

  console.log("dowload url:" + url);

  //用户缓存目录
  var userLocalPath = wx.env.USER_DATA_PATH;
  var localPath = "wxfile://";
  var path = userLocalPath + "/" + fileName
  var localPath = localPath + "/" + fileName
  var authorization = "Basic ZThlYWJmNWMwN2I0NGI0YmEzOGJmZWMyMTJkM2U1ZDU=";
  var apptoken = "Authorization"

  const downloadTask = wx.downloadFile({

    // 待下载的云资源
    url: url,

    //下载成功后的回调函数
    success(res) {
      console.log("dowload res.errMsg:" + res.errMsg);
      console.log("dowload res.statusCode:" + res.statusCode);
      console.log("dowload res.tempFilePath:" + res.tempFilePath);

      if (res.statusCode === 200) {
        wx.showToast({
          title: '下载成功！'
        })
      }
    },

    //失败回调函数
    fai: function(res) {
      console.log("downloadFile fai:" + res.errMsg)
    },

    //完成回调函数
    complete: function() {
      console.log("downloadFile complete")
      content.getReaddir(targPath)
    }
  })

  downloadTask.onProgressUpdate((res) => {
    console.log('下载进度', res.progress)
    console.log('已经下载的数据长度', res.totalBytesWritten)
    console.log('预期需要下载的数据总长度', res.totalBytesExpectedToWrite)
  })

  // downloadTask.abort() // 取消下载任务

}

2、持久化文件到本地

 //下载成功的文件目前存在temp文件夹下，它属于临时文件
 //如果想要将其持久化，需要使用wx.saveFile()将其保存至store文件夹下，
 //在使用这个函数时，temp文件夹下的临时文件会被删除。
wx.saveFile({
   tempFilePath: res.tempFilePath,
      success: function(res) {
      console.log(res);
      var savedFilePath = res.savedFilePath;
      console.log('文件已下载到' + savedFilePath);
    }
 })

3、解压压缩文件

//解压文件
unzipFile: function(path, targPath) {
  var content = this;
  console.log("unzip path:" + path)
  console.log("unzip targPath:" + targPath)
  wx.getFileSystemManager().unzip({
    //文件路径
    zipFilePath: path,

    //目标文件夹
    targetPath: targPath,

    //成功回调函数
    success: function(res) {
      console.log(res.errMsg)
    },

    //失败回调函数
    fai: function(res) {
      console.log("unzip fai:" + res.errMsg)
    },

    //完成回调函数
    complete: function() {
      console.log("unzip complete")
      content.getReaddir(targPath)
    }
  });
}

3、读取文件到内存

//读取文件
  readFile: function(path) {
    console.log("readFile start path:" + path)
    var userLocalPath = wx.env.USER_DATA_PATH;
    wx.getFileSystemManager().readFile({
      //文件路径
      filePath: path,

      //成功回调函数
      success: function(res) {
        console.log("unzip success res:" + res.errMsg)
        console.log(res)
      },

      //失败回调函数
      fai: function(res) {
        console.log("unzip fai:" + res.errMsg)
      },

      //完成回调函数
      complete: function() {
        console.log("unzip complete")
      }
    });
  }

4、查看目标文件夹的文件列表

// 查看下载的文件列表
 getReaddir: function(path) {
   console.log("getReaddir start")
   wx.getFileSystemManager().readdir({
     dirPath: path,

     //成功回调函数
     success: function(res) {
       console.log("getReaddir success res:" + res.errMsg)
       console.log(res)
     },

     //失败回调函数
     fai: function(res) {
       console.log("getReaddir fai:" + res.errMsg)
     },

     //完成回调函数
     complete: function() {
       console.log("getReaddir complete")
     }
   })
 }

5、查看已经缓存的文件列表

// 查看下载的文件列表
 getUserSavedFileList: function() {
   console.log("getUserSavedFileList start")
   wx.getFileSystemManager().getSavedFileList({
     //成功回调函数
     success: function(res) {
       console.log("getUserSavedFileList success res:" + res)
       console.log(res)
     },

     //失败回调函数
     fai: function(res) {
       console.log("getUserSavedFileList fai:" + res.errMsg)
     },

     //完成回调函数
     complete: function() {
       console.log("getUserSavedFileList complete")
     }
   })
 }

XwalkView属性配置

WebView属性配置

Java基础知识（转&添加）

java中“==”和equals的区别以及hashCode的区别

==概述

equals概述

举个例子：

注：

hashCode 与 equals

基本数据类型各占多少字节、多少位

包装类型 int与Integer的区别

面向对象思想

封装

继承

多态

String、StringBuffer、StringBuilder区别

什么是内部类？内部类的作用

内部类分类

成员内部类

局部内部类

匿名内部类

静态内部类

内部类的作用

抽象类和接口区别

抽象类的意义

抽象类与接口的应用场景

interface的应用场合

abstract class的应用场合

抽象类是否可以没有方法和属性？

接口的意义

泛型中extends和super的区别

父类的静态方法能否被子类重写

进程和线程的区别

final，finally，finalize的区别

序列化

定义

方式

区别

静态属性和静态方法是否可以被继承？是否可以被重写？以及原因？

静态内部类的设计意图

成员内部类、静态内部类、局部内部类和匿名内部类的理解，以及项目中的应用

谈谈对kotlin的理解

闭包和局部内部类的区别

string 转换成 integer的方式及原理

Android事件分发机制

1、概述

2、事件分发概述

3、常用MotionEvent分类

3、事件产生顺序

4、Android事件扭转流程

模拟：

5、事件分发流程及其分析

流程图及注释

流程分析

微信小程序之文件系统初探

1、文件下载

2、持久化文件到本地

3、解压压缩文件

3、读取文件到内存

4、查看目标文件夹的文件列表

5、查看已经缓存的文件列表

`==`概述

`equals`概述

3、常用`MotionEvent`分类