java的三种内部类

成员内部类

//外部类
public class Outer{
//内部类Inner，类Inner在类0uter的内部
    public class Inner{
//内部类的方法
        public void show(){
            System.out.println("Inner！");
        }
    }
    public static void main(String[]args){
        //创建外部类对象
        outer outer=new Outer();
        //创建内部类对象
        Inneri=outer.new Inner();  //内部类怎么使用？
        //调用内部类对象的方法
        i.show();
    }
}

静态内部类

public class Outer{
    //静态内部类
    static class StaticInner{
    //内部类的方法
        public void show(){
            System.out.println("StaticInner！");
        }
    }
    public static void main(String[]args){
        StaticInner staticinner=new StaticInner();
        staticinner.show();
    }
}

匿名内部类

与继承有关

内部类访问成员变量

public class Outer{
    private int n=99；//外部类的私有属性
    private int m=99；//外部类的私有属性
    public class Inner{
        //内部类Inner 
        int m=88；//内部类的成员属性
        public void show(){
            //内部类的方法
            System.out.println("访问外部类中的n！"+n);//因为内部类没这个变量，可直接访问
            System.out.println("访问外部类中的m！"+Outer.this.m);//同时有m时，这样访问外部的m，this代表访问的类的对象
            System.out.println("访问内部类中的m！"+m);//访问内部类的m，直接访问
        }
    }
    public static void main（String[]args）{
        Outer outer=new Outer();//创建外部类对象
        Inneri=outer.new Inner();//创建内部类对象
        i.show();
    }
}

从上面的代码中我们可以看到，成员内部类的使用方法
1.Inner类定义在0uter类的内部，相当于0uter类的一个成员变量的位置，lnner类可以使用任意访问控制符，如public、protected、private等
2.Inner类中定义的show（）方法可以直接访问0uter类中的数据，而不受访问控制符的影响，如直接访问0uter类中的私有属性n
3.Inner类中定义的show（）方法内如果需要访问0uter类中的同名数据，需要加上外部类名.this.变量名
4.定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去new一个内部类对象，即：内部类对象名=外部类对象.new内部类（）；

内部类的编译

编译上面的程序后，会发现产生了两个.class文件0uter$Inner.class 内部类Outer.class外部类
另外还有一点，外部类是不能访问内部类中的成员和方法的

继承

java中的继承

继承是类与类的一种关系
Java中的继承是单继承的

继承的好处：
1.子类拥有父类的所有属性和方法
2.实现代码复用

语法：

class 子类 extends 父类{
    ...
}

eg:
注意一般类是不放到一起的，最好一个类一个文件，除非是内部类有关联的
当然这样类写到一起也不会报错

public class Animal{
    String name;
    int age;
}
public class Dog extends Animal{
}
public class Test{
    public static void main（String[]args）{
        Dog dog=new Dog();
        dog.name="狗";
    }
}

java中的方法重写

1.什么是方法的重写
如果子类对继承父类的方法不满意，是可以重写父类继的方法的，当调用方法时会优先调用子类的方法。

2.语法规则
A.返回值类型
B.方法名
C.参数类型及个数
都要与父类继承的方法相同，才叫方法的重写。

方法的重写相当于C++中虚函数覆盖
快捷键：Ctrl+O

public class Animal{
    String name;
    int age;
    public String getName(){
        return name;
    }
}
public class Dog extends Animal{
    public String getName(){
        return "Dog";
    }
}

java中的继承初始化顺序

1.父类对象
2.父类属性初始化
3.父类构造方法

4.子类对象
5.子类属性初始化
6.子类构造方法

java中final的使用

1.final关键字作为标识有”最终的”含义

2.final可以修饰类、方法、属性和变量

3.final修饰类，则该类不允许被继承
eg:public final class Animal class Dog extendsAnima-{}

4.final修饰方法，则该方法不允许被覆盖（重写）

5.final修饰属性
则该类的属性不会进行隐式的初始化（类的初始化属性必须有值）
eg:private final int n=1；
或在构造方法中赋值（但只能选其一）

6.final修饰变量，则该变量的值只能赋一次值，即变为常量

java中super的使用

super关键字：
在对象的内部使用，可以代表父类对象。
1.访问父类的属性super.age
2.访问父类的方法
super.eat（）
super应用：
1.子类构造的过程当中必须调用其父类的构造方法。

public class Animal{
    String name;
    int age;
    //当创建有参构造方法之后，午餐构造就自动消失
    //public Animal(String name, int age{
    //    this. name=name;
    //    this. age=age;
    //}
    public String getName(){
        return name;
    }
}

public class Dog extends Animal{
    //public Dog(){
    //    super("狗",1)   //这部分和上面那部分相呼应，有参必须调用
    //}
    public Dog(){
    }
    public String getName(){
        return "Dog";
    }
}

2.如果显式的调用构造方法，必须在子类的构造方法的中第一行

public class Main{
    public static void main(String[] args){
        Dog dog = new Dog();
        dog.name = "秋田犬";
        System.out.println(dog.name);
    }
}

public class Animal{
    String name;
    int age;
    当创建有参构造方法之后，午餐构造就自动消失
    public Animal(String name, int age{
        this. name=name;
        this. age=age;
    }
    public String getName(){
        return name;
    }
}

public class Dog extends Animal{
    public Dog(){
        super("狗",1)   //这部分和上面那部分相呼应，有参必须调用
    }
    public String getName(){
        return "Dog";
    }
}

3.如果子类构造方法中既没有显式的调用父类构造方法，而父类又没有无参的构造方法，则编译出错。

这个就和第一点差不多，如果子类构造方法不加上super(“狗”,1)这一行代码，并且Animal类有参构造，子类就会报错

java中的Object类

Object类是所有类的父类，如果一个类没有使用extends关键字明确标识继承另一个类，那么这个类默认继承Object类。
Object类中的方法，适合所有子类。
1.toString（）返回对象地址字符串
一般我们会重写此方法，返回对象的属性eg:Dog类，重写toString），返回“Dog”

2.equals（）比较对象引用的地址
一般我们会重写此方法，比较对象的属性值

安卓大师之路

android安全之java面向对象2