search

creeperyang / blog

前端博客，关注基础知识和性能优化。
MIT License
2.63k stars 211 forks source link

从零开始学习 Android （笔记） #47

Open creeperyang opened 6 years ago

creeperyang commented 6 years ago

工作需要，开始写原生安卓项目；本文记录一个前端学习安卓相关知识的历程 😄

一、前置Java知识

https://www.w3cschool.cn/java/ 可用于快速补充一些Java的基础知识，作为一个基本的工具手册。

Java 是一门强类型的面向对象的解释型语言，通过JVM可以在多平台运行。

1. 基础类型

8种内置类型，六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型：

引用类型

对象、数组都是引用数据类型，所有引用类型的默认值都是null。

对前端而言，需要额外注意两点：

2. 基本语法

总的来说，Java基本语法和一般程序语言的语法一致。相比JS，我们可能要注意 修饰符，接口等概念。

循环

和JS基本一致；不过可以注意下增强的for循环：

String [] names ={"James", "Larry", "Tom", "Lacy"};
for( String name : names ) {
         System.out.print( name );
         System.out.print(",");
}

for(声明语句 : 表达式) 中表达式为数组。

分支

与JS一致。

3. 类和对象

对象是类的一个实例，有状态和行为。类可以看成是创建Java对象的模板。一个类可以包含以下类型变量：

每个类都有构造方法。如果没有显式为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。

源文件声明规则

Java包

包主要用来对类和接口进行分类。我们用package pkgName 来声明包，用import java.io.* 来引入包。

4. 修饰符（访问控制及其它）

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java支持4种不同的访问权限。

访问控制和继承

非访问修饰符

为了实现一些其他的功能，Java也提供了许多非访问修饰符。

5. Java 的继承与接口

Java是完全面向对象的语言，继承是最重要的topic。Java只有单继承（相比多继承，减少复杂度和潜在的一些问题（比如函数重写）），但通过接口来保留多继承的一些优点。

典型的继承语法：

class Pet {
    public String name;
    private int age = 0;
    public Pet() {}
    public String getName() {
        System.out.println("yes, in Pet!");
        return name;
    }
    public int getAge() {
        return age;
    }
}

interface Animal {
    public void eat(String food);
}

class Dog extends Pet implements Animal {
    int age = 10;

    @Override
    public int getAge() {
        System.out.println("hey!" + age);
        return age;
    }

    public void eat(String food) {
        System.out.println("dog eat " + food);
    }
}

public class Test {
    public static void main(String[] args) {
        Pet a = new Pet();
        Pet b = new Pet();
        Dog d = new Dog();
        System.out.println(a.getName());
        System.out.println(d.getName());
        System.out.println("--------------");
        d.eat("gouliang");
    }
}

子类可以从父类继承所有的 protected/public 属性和方法。

我们知道，JS 中，基于原型链的继承机制，所有实例的方法调用的方法最终都指向原型（链）的某个方法，即方法在内存中只有一份，那在Java中一样吗？

答案是：是。

Java中，类在加载时，类的信息（类信息，常量，静态变量，类方法）被存储到方法区。

类信息除了有类的版本、字段、方法、接口等描述信息外，还有一项信息是常量池（Constant Pool Table），用于存放编译期生成的各种字面量、符号引用，文字字符串、final变量值、类名和方法名常量，这部分内容将在类加载后存放到方法区的运行时常量池中。它们以数组形式访问，是调用方法、与类联系及类的对象化的桥梁。

其中 方法信息，包括方法名、返回值类型、参数类型、修饰符、异常、方法的字节码。

在Java中 new 一个对象时，为类的成员（包括（继承的）父类的成员）分配了内存空间，然后执行构造函数，初始化这些属性的值。

但对象并不会为方法分配内存，当调用对象的方法时，实质上是去方法区查找到对应的方法执行。

静态方法和私有方法在解析阶段确定唯一的调用版本，而其它实例方法，会去动态查找（沿继承链）。

参考：

6. Java 泛型

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

泛型类

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map。

泛型类的定义：

class 类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型>{
  private 泛型标识 /*（成员变量类型）*/ var; 
  .....
  }
}

例子：

class Demo <T> {
    private T key;
    public Demo(T key) {
        this.key = key;
    }
    public T getKey() {
        return key;
    }
}
// 泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
// 传入的实参类型需与泛型的类型参数类型相同，即为Integer.
Demo<Integer> demoInt = new Demo<Integer>(10);

泛型的类型参数只能代表引用型类型，不能是原始类型（像int,double,char等）

泛型接口

//定义一个泛型接口
public interface Generator<T> {
    public T next();
}

public class FruitGenerator implements Generator<String> {

    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};

    @Override
    public String next() {
        Random rand = new Random();
        return fruits[rand.nextInt(3)];
    }
}

泛型方法

泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型 。

public class GenericMethodTest
{
   // 泛型方法 printArray                         
   public static < E > void printArray( E[] inputArray )
   {
      // 输出数组元素            
         for ( E element : inputArray ){        
            System.out.printf( "%s ", element );
         }
         System.out.println();
    }

    public static void main( String args[] )
    {
        // 创建不同类型数组： Integer, Double 和 Character
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };

        System.out.println( "Array integerArray contains:" );
        printArray( intArray  ); // 传递一个整型数组

        System.out.println( "\nArray doubleArray contains:" );
        printArray( doubleArray ); // 传递一个双精度型数组

        System.out.println( "\nArray characterArray contains:" );
        printArray( charArray ); // 传递一个字符型型数组
    } 
}

有界的类型参数:

可能有时候，你会想限制那些被允许传递到一个类型参数的类型种类范围。例如，一个操作数字的方法可能只希望接受Number或者Number子类的实例。这就是有界类型参数的目的。

要声明一个有界的类型参数，首先列出类型参数的名称，后跟extends关键字，最后紧跟它的上界。

   // 比较三个值并返回最大值
   // T 必须继承自 Comparable 接口
   public static <T extends Comparable<T>> T maximum(T x, T y, T z)
   {                     
      T max = x; // 假设x是初始最大值
      if ( y.compareTo( max ) > 0 ){
         max = y; //y 更大
      }
      if ( z.compareTo( max ) > 0 ){
         max = z; // 现在 z 更大           
      }
      return max; // 返回最大对象
   }

7. Java 多线程编程

8. Java 内存模型

源于同事的一次分享，查阅资料了解了Java虚拟机和内存管理相关知识。利于深入了解Java，对比JS可能有更大收获。

Run-Time Data Areas

2018-09-05 6 58 25

  1. 堆区：存放所有类实例（对象）和数组，虚拟机启动时创建。由GC自动管理。

  2. 方法区（Method area and runtime constant pool）：存放类的结构信息，虚拟机启动时创建。类似于传统语言中存放编译后代码的地方，它存放类的 （1）run-time constant pool（类似传统语言的符号表+其它），（2）成员和方法信息，（3）静态变量，（4）方法的代码等等。

    It stores per-class structures such as the run-time constant pool, field and method data, and the code for methods and constructors.

    虽然逻辑上来说，方法区也是堆的一部分，不过方法区一般不被GC管理（取决于JVM的具体实现）。

  3. JVM Stack：每个Java线程创建时都会创建一个私有的JVM Stack，存储局部变量和部分结果，参与函数调用和返回。Stack本身只负责存储（push/pop）frames，frame 对应方法，负责存数据和部分结果，执行动态链接，返回方法的值或者dispatch异常。

  4. Native Method Stacks：线程私有，但不是所有JVM都实现了。类似JVM Stack，用于执行 Native 方法服务。

    frame通常包含：

    • 局部变量表（Current Variable Table）
    • 操作数栈（Operand Stack）：字节码指令从操作数栈弹出数据，执行计算，再把结果入操作数栈。
    • 动态链接（Dynamic Linking）：指向运行时常量池中frame所属方法的引用。
    • 返回地址（Return Address）：正常返回，PC register的值作为返回地址保存；异常返回，通过异常处理表获得返回地址。

  5. PC register：线程私有。每个JVM线程都有自己的pc register，在任意时刻，每个线程都是在执行一个方法（记作 current method）。如果这个方法不是native的，那么pc register存着当前执行的JVM指令的地址；否则pc register的值是undefined。

Go7hic commented 6 years ago

厉害了老哥

creeperyang commented 6 years ago

二、Android 编程

1. IDE 和创建第一个项目

下载 AndroidStudio，创建一个项目并编译，了解基本的流程。

2. Layout 与 Res 文件夹

3. Gradle

Gradle 是一个基于 JVM 的构建工具，基于 groovy，有强大的依赖管理，支持多工程构建。

Gradle 构建基础

projects 和 tasks是 Gradle 中最重要的两个概念。

1、创建任务

1.1、创建一个最简单的task（build.gradle文件）：

task hello {
    doLast {
        println 'Hello world!'
    }
}

我们可以执行gradle -q hello查看输出：

$ gradle -q hello
Hello world!

1.2、快速定义task：

task hello << {
    println 'Hello world!'
}
// << 等同于 doLast

1.3、使用groovy

task upper << {
    String someString = 'mY_nAmE'
    println "Original: " + someString
    println "Upper case: " + someString.toUpperCase()
}
$ gradle -q upper
Original: mY_nAmE
Upper case: MY_NAME

2、任务依赖

2.1、 在两个任务之间指明依赖关系

task hello << {
    println 'Hello world!'
}
task intro(dependsOn: hello) << {
    println "I'm Gradle"
}
$ gradle -q intro
Hello world!
I'm Gradle

2.2、延迟依赖

taskX 是可以在 taskY 之前定义的。

task taskX(dependsOn: 'taskY') << {
    println 'taskX'
}
task taskY << {
    println 'taskY'
}

3、动态任务

4.times { counter ->
    task "task$counter" << {
        println "I'm task number $counter"
    }
}
// gradle -q task1

4、任务操纵

4.1、通过 API 进行任务之间的通信 - 增加依赖

4.times { counter ->
    task "task$counter" << {
        println "I'm task number $counter"
    }
}
task0.dependsOn task2, task3

4.2、通过 API 进行任务之间的通信 - 增加任务行为

task hello << {
    println 'Hello Earth'
}
hello.doFirst {
    println 'Hello Venus'
}
hello.doLast {
    println 'Hello Mars'
}
hello << {
    println 'Hello Jupiter'
}

doFirst 和 doLast 可以进行多次调用。他们分别被添加在任务的开头和结尾。当任务开始执行时这些动作会按照既定顺序进行。

5、短标记法

每个任务都是一个脚本的属性，你可以访问它。

以属性的方式访问任务：

task hello << {
    println 'Hello world!'
}
hello.doLast {
    println "Greetings from the $hello.name task."
}
// $hello.name 就是 “hello”

6、增加自定义属性

task myTask {
    ext.myProperty = "myValue"
}

task printTaskProperties << {
    println myTask.myProperty
}

7、调用 Ant 任务

Ant 任务是 Gradle 中的一等公民。Gradle 自带了一个 AntBuilder，可以通过它来调用一个 Ant 任务以及与 Ant 中的属性进行通信。

task loadfile << {
    def files = file('../antLoadfileResources').listFiles().sort()
    files.each { File file ->
        if (file.isFile()) {
            ant.loadfile(srcFile: file, property: file.name)
            println " *** $file.name ***"
            println "${ant.properties[file.name]}"
        }
    }
}

8、方法抽取

task checksum << {
    fileList('../antLoadfileResources').each {File file ->
        ant.checksum(file: file, property: "cs_$file.name")
        println "$file.name Checksum: ${ant.properties["cs_$file.name"]}"
    }
}
task loadfile << {
    fileList('../antLoadfileResources').each {File file ->
        ant.loadfile(srcFile: file, property: file.name)
        println "I'm fond of $file.name"
    }
}
File[] fileList(String dir) {
    file(dir).listFiles({file -> file.isFile() } as FileFilter).sort()
}

9、定义默认任务

defaultTasks 'clean', 'run'
task clean << {
    println 'Default Cleaning!'
}
task run << {
    println 'Default Running!'
}
task other << {
    println "I'm not a default task!"
}
$ gradle -q
Default Cleaning!
Default Running!

以上是一些gradle的基础小知识，下面以android项目为例，了解gradle实际是怎么工作的。

Building Android Apps