java 类

#类的高级概念  
##1.访问修饰符  
Java为类中的成员提供了四种访问级别，按照访问权限由大到小排列如下：  
1. 公开访问级别：使用public关键字修饰，用public关键字修饰的成员对外公开可以被任何其他对象访问。  
2. 受保护访问级别：使用protected的关键字修饰，受保护的成员可以被统一包中的类所访问，还可以被类的子类所访问，不管子类在哪一个包中。
3. 默认访问级别：没有访问修饰符。默认访问级别的成员可以被同一包中其它类所访问，不能被其它包中的子类所访问。
4. 私有访问级别：使用private关键字修饰。私有成员只有类本身可以访问，不对外公开。  
  
PS:private,protected 不能用于修饰类。子类重写父类的方法时，访问修饰符不能小于父类的访问修饰符级别。
>     public String name;
>     protected  int age;
>     int sex;
>     private String color;
##2.封装  
封装：隐藏内部实现，暴露外部方法。是类中的成员变量都是private，并提供public方法访问这些成员变量的技术。允许获取成员变量的get方法称为访问器方法，允许修改成员变量的set方法被称为修改器方法。面向对象的三大特征：封装，继承，多态。  

    public class Test1 {
    private String name;
    private int sex;
    private int high;

    public String getName() {
        return name;
        }
    public void setName(String name) {
        this.name = name;
        }

    public int getSex() {
        return sex;
        }

    public void setSex(int sex) {
        if (sex != 0 | sex != 1) {
            this.sex = 1;
        }
        this.sex = sex;
    }

    public int getHigh() {
        return high;
    }

    public void setHigh(int high) {
        if (high > 3 | high < 0) {
            this.high = 1;
        }
     else {
            this.high = high;
            }
        }

    }  
##3.static  


1. 用static声明的成员变量或方法可以被认为是全局的，任何其它类可以直接访问静态成员变量或调用静态方法而不需要该类的一个实例。static修饰的变量访问的时候不需要new这个类在访问和当前类没有直接关联，值不随着类的初始化而初始化。  
静态方法访问外部属性，调用别的方法，该方法和变量也必须是static的。   
2.静态方法  
静态方法可以直接通过类名调用，任何的实例也都可以调用，
因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。
因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。
例如为了方便方法的调用，Java API中的Math类中所有的方法都是静态的，而一般类内部的static方法也是方便其它类对该方法的调用。
静态方法是类内部的一类特殊方法，只有在需要时才将对应的方法声明成静态的，一个类内部的方法一般都是非静态的  
3.静态初始化块
类被类加载器加载一次，静态初始化块的作用是允许类执行任何所需的只需要发生一次的设置任务，即类加载的时候执行一次。  

        public void Test1() {
            {
            System.out.println("xiaohong information");
            }
        
        System.out.println("构造函数"+getHigh());
            }

        static {
        System.out.println("开始了");
        }  
执行顺序为静态方法块，初始化代码块，构造函数。
    
##4.内部类  
为什么要使用内部类？  
如果需要用一个类，但是这个类不常用（没必要单独创建偶尔才使用）。  
1.静态内部类
作为类的静态成员存在于某个类的内部可以访问外部类的属性或者方法，前提条件是外部类的属性和方法也必须是static。  

    public class StaticInnerDemo{
    static int a=10;
    int b=20;
    static void f(){
    System.out.println("我在静态方法饭（）中")；
    }
    static class Inner{
     int c=30;
    public void g(){
    f();
    System.out.println(a+" "+c);
        }
    }
      
2.成员内部类  

    class Outer{
        class Inner{
        }
    }  
只有创建了Outer类的实例对象后，才能使用Inner类的对象。  
3.局部内部类  
局部内部类是在类的方法内部定义的类，局部内部类只能在方法内部中使用，一旦方法执行完毕局部内部类就会从内存中清除。  

    public class LocalDemo{
        int a=10;
        void f(){
        class Inner{
            int b=20;
            void g(){
                System.out.println(a);
                System.out.println(b);
                }
            }
    Inner in=new Inner();
    in.g();
    }
    public static void main(String [] args){
        LocalDemo local=new LocalDemo();
        local.f();
        }
    }