安卓面试学习day02

static

静态修饰词，可以用于修饰方法，变量，也有静态代码块的方法，主要作用是在程序运行的过程中提前生成和起作用
答案：

思考：我之前一直有说的不太明白的这个问题，我回答说的运行的过程中提前生成和起作用，其实不如答案中说的类初次加载时就会被初始化。

final

也是一个关键词，可以修饰变量方法，意思为最后，变量不能再修改值，方法不能被重写

String、StringBuffer、StringBuilder

String是一个final修饰的对象，无法改变，而Buffer和Builder是为了改变的，而Buffer线程安全，他们俩个的实质是一个字符串缓冲区。
答案：

异常处理体系

回答：有exception和error（异常和错误），exception也可以分为两种，一种是编译器可发现的一般都是语法错误，一种是运行是才出问题的exception，而error则是编译或者运行时出现需要修改的错误。
思考：上面那个自己的回答可以不看了，总结来说都是Throwable的子类，然后error是由虚拟机抛出，不可以被捕捉，Exception可以被分为检查性异常和非检查性异常

内部类

回答：这个自己了解的不太清楚，只知道是一个类中可以在建立一个内部类，可以进行更方便的操作
答案：

在java中内部类主要分为成员内部类（非静态内部类、静态内部类）、匿名内部类、局部内部类

使用static来修饰一个内部类，则这个内部类就属于外部类本身，而不属于外部类的某个对象。称为静态内部类（也可称为类内部类），这样的内部类是类级别的，static关键字的作用是把类的成员变成类相关，而不是实例相关

这种不太熟的，上一个代码

//非静态内部类
public static void main(String[] args) {
	   //创建内部类对象
	   Outer.Inter inter = new Outer().new Inter();//外部类以外的地方使用非静态内部类  
       //new Inter()外部类中定义内部类
       inter.show();//调用show()
   }

class Outer{
	private int age = 10;//外部类 Outer.this.age
	class Inter{
		int age = 20;//内部类 this.age
		public void show(){
			int age = 30;//局部变量 age
			System.out.println("外部类的成员变量age = "+Outer.this.age); //输出外部类
			System.out.println("内部类的成员变量age = "+this.age); //输出内部类
			System.out.println("局部变量age = "+age); //输出局部变量

		}
	}

//静态内部类
public class Outer {
    // 定义一个实例变量和一个静态变量
    private int a;
    private static int b;

    // 定义一个静态方法和一个非静态方法
    public static void say() {
    }

    public void test() {
        // 在外部类中调用内部类的属性和方法
        Outer.Inner.c = 1; // 可以通过静态内部类的全类名来调用静态内部类的静态属性（外部类名.静态内部类名.属性）
        Outer.Inner.go(); // 可以通过静态内部类的全类名来调用静态内部类的静态方法（外部类名.静态内部类名.方法）
        // Outer.Inner.walk(); //不能通过类静态内部类的全类名来调用内部类的非静态属性和方法
        Inner inner = new Inner(); //可以通过创建内部类实例来调用静态内部类的非静态属性和方法
        inner.d = 1;
        inner.walk(); 
    }

    // 静态内部类
    public static class Inner {
        // 在静态内部类中定义一个静态变量和一个实例变量
        static int c;
        int d;
        // 定义一个匿名代码块和一个静态代码块
        {
        }
        static {
        }

        // 定义一个静态方法和一个普通方法
        public static void go() {
            
        }

        public void walk() {
            // 在静态内部类中调用外部类的属性和方法
            int f = b; // 可以直接调用外部类的静态属性
            say(); // 可以直接调用外部类的静态方法
            // int e = a; 直接调用外部类的非静态属性出错编译出错
            // test(); 直接调用外部类的非静态方法时编译出错
            Outer outer = new Outer();
            int e = outer.a; // 可以通过创建外部类实例来调用外部类的非静态属性
            outer.test(); // 可以通过创建外部类实例来调用外部类的非静态方法
        }
    }
}

匿名内部类

答案：
思考：
转载地址：https://www.cnblogs.com/nerxious/archive/2013/01/25/2876489.html
匿名内部类也就是没有名字的内部类

正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写

但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口

//不使用匿名内部类
abstract class Person {
    public abstract void eat();
}
 
class Child extends Person {
    public void eat() {
        System.out.println("eat something");
    }
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Child();
        p.eat();
    }
}

//使用匿名内部类，可以看出，这样写简写（省略）了一个类
abstract class Person {
    public abstract void eat();
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}
//接口也可以实现匿名内部类
interface Person {
    public void eat();
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

//匿名内部类在多线程上的运用
public class Demo {
    public static void main(String[] args) {
        Thread t = new Thread() {
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.print(i + " ");
                }
            }
        };
        t.start();
    }
}

public class Demo {
    public static void main(String[] args) {
        Runnable r = new Runnable() {
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.print(i + " ");
                }
            }
        };
        Thread t = new Thread(r);
        t.start();
    }
}

多态

回答：多态是Java的四大特征抽象、封装、继承、多态之一，它的意思是一个方法在面对不同参数的时候可以会有不同的代码实现，
答案：
思考：感觉它这个答案和我想的差距很多。一句一句的分析吧

父类引用指向子类对象指的是：

例如父类Animal，子类Cat,Dog。其中Animal可以是类也可以是接口，Cat和Dog是继承或实现Animal的子类。

Animal animal = new Cat();
即声明的是父类，实际指向的是子类的一个对象。
那我们从内存角度来理解试试.
假设现在有一个父类Father,它里面的变量需要占用1M内存.
有一个它的子类Son,它里面的变量需要占用0.5M内存.
现在通过代码来看看内存的分配情况:

Father f = new Father();//系统将分配1M内存.

Son s = new Son();//系统将分配1.5M内存!

如果能够理解对象在内存的分布，那我们接下来就介绍java的多态性

方法的重写、重载和动态链接构成了java的多态性。Java之所以引入多态的概念，原因之一是它在类的继承问题上和C++不同，后者允许多继承，这确实给其带来的非常强大的功能，但是复杂的继承关系也给C++开发者带来了更大的麻烦，为了规避风险，Java只允许单继承，派生类与基类间有IS-A的关系（即“猫”is a “动物”）。这样做虽然保证了继承关系的简单明了，但是势必在功能上有很大的限制，所以，Java引入了多态性的概念以弥补这点的不足。

理解多态性，首先要理解的就是“向上转型”：子类是对父类的改进和扩充。定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。 但是父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，父类引用是无法调用的；
再加上几个例子，应该就可以解释的清上面的答案了。

//例子1
public class Father{ 
    //父类有一个打孩子方法 
    public void hitChild(){ 
    } 
} 
//子类1 
public class Son1 extends Father{ 
    //重写父类打孩子方法 
    public void hitChild(){ 
      System.out.println("为什么打我？我做错什么了！"); 
    } 
} 
//子类2 
public class Son2 extends Father{ 
    //重写父类打孩子方法 
    public void hitChild(){ 
      System.out.println("我知道错了，别打了！"); 
    } 
} 
//子类3 
public class Son3 extends Father{ 
    //重写父类打孩子方法 
    public void hitChild(){ 
      System.out.println("我跑，你打不着！"); 
    } 
} 
//测试类 
public class Test{ 
    public static void main(String args[]){ 
      Father father; 
      father = new Son1(); 
      father.hitChild(); 
      father = new Son2(); 
      father.hitChild(); 
      father = new Son3(); 
      father.hitChild(); 
    } 
}