java_修饰符、内部类

package com.tz.demo01;
/**
 * 修饰符：                             本类   同包下子类        同包下类             不同包下子类    不同包下类
 *  public： 公共的                     1       1               1                   1                   1       
 * protected ： 受保护的                1        1               1                   1                   0
 * default ： 默认的                        1       1               1                   0                   0
 * private ： 私有的                        1      0                0                   0                   0
 * 
 *      修饰符的使用：
 *              类的修饰符：      public final abstract 默认(什么都不写)
 *              构造方法/函数：    public protected  private 
 *              成员变量：       public protected  private  static  final  
 *              局部变量：       final
 *              方法：         public protected  private  static  final  abstract
 * 
 * @author Administrator
 *
 */
public class Animal {

    public String name1;
    protected String name2;
    String name3;
    private String name4;


    public  void show(){
        System.out.println(name1);
        System.out.println(name2);
        System.out.println(name3);
        System.out.println(name4);
    }


}

package com.tz.demo01;
/**
 * 同包下子类
 * @author Administrator
 *
 */
public class Dog extends Animal{

    public void show1(){
        System.out.println(name1);
        System.out.println(name2);
        System.out.println(name3);
        //System.out.println(name4);   私有的不能使用   
    }
}

package com.tz.demo01;
/**
 * 同包下类:
 *  
 * @author Administrator
 *
 */
public class Aaaa {

    public static void main(String[] args) {
        //没有继承关系的类在使用时，通过创建对象使用其属性和方法，使用的方式    对象名.属性名/方法名
        Animal animal = new Animal();
        System.out.println(animal.name1);
        System.out.println(animal.name2);
        System.out.println(animal.name3);
        //System.out.println(animal.name4);    

    }
}

package com.tz.demo02;

import com.tz.demo01.Animal;

/**
 * 不同包下子类:
 * 
 * @author Administrator
 *
 */
public class Fish extends Animal{

    public void show2(){
        System.out.println(name1);
        System.out.println(name2);
        //System.out.println(name3);            默认/缺省：不能使用（报错）
        //System.out.println(name4);            私有:不能使用（报错）
    }


}

package com.tz.demo02;

import com.tz.demo01.Animal;

/**
 * 不同包下类:
 *  
 * @author Administrator
 *
 */
public class Aaaa {
        public static void main(String[] args) {

            //创建对象
            Animal animal = new  Animal();
            System.out.println(animal.name1);
            //System.out.println(animal.name2);
            //System.out.println(animal.name3);
            //System.out.println(animal.name4);


        }
}

package InnerClass;
/**
 * java中的内部类：
 *          在一个类中定义另一个类叫作内部类,是一个独立的类，在编译时内部类会被编译成独立的.class文件
 *          文件名前冠以外部类的类名和$符
 *      例：
 *              在A类中定义一个B类 ：      --》   A$B.class
 * 
 *          内部类是外部类的一个成员，因此内部类可以自由访问外部类的成员，包括私有成员
 *          
 *          内部类的分类：
 *                      1、成员内部类         --》成员变量
 *                      2、局部内部类         --》局部变量
 *                      3、静态内部类         --》静态变量
 *                      4、匿名内部类         
 * 
 * @author Administrator
 *
 */
public class Test {
    //主方法
    public static void main(String[] args) {
        //创建对象
        MemberInner mbi = new MemberInner();
        System.out.println(mbi.str2);
        mbi.new Inner();    //以new的方式创建内部类
        //成员内部类的创建
        MemberInner.Inner inner = new MemberInner().new Inner();   

        //局部内部类
        PartInner pi = new PartInner();
        pi.method();

        //静态内部类
        StaticInner.InnerClass staicinner = new StaticInner.InnerClass();
    }
}

package InnerClass;
/**
 * 成员内部类：
 *          1、成员内部类可以看做成员变量
 *                          位置：  外部类 类中，方法体外
 *          2、可以用控制访问权限的修饰符修饰
 *          3、成员内部类不能拥有静态声明
 *          4、成员内部类可以访问外部类中的所有数据
 *          5、成员内部类如何创建对象：
 *                      外部类  外部类名对象 = new 外部类()；
 *                      外部类名对象 . new 内部类名（）；
 *              外部类类名.内部类类名 内部类对象名 = new 外部类类名().new 内部类类名();
 * @author Administrator
 *
 */
public class MemberInner {//外部类

        //静态变量
        static String str1 = "zxg";
        //成员变量
        String str2 = "qw";
        //静态方法
        private static void phoebe(){}
        //成员方法
        public void  daming(){}

    class Inner{ //成员内部类
                //静态变量
                //static String str1 = "zxg";
                //静态方法
                //private static void phoebe(){}
                //成员变量
                String str2 = "qw";
                //成员方法
                public void  daming(){
                    System.out.println(str1);
                    phoebe();
                    System.out.println(str2);
                    daming();
                }
    }
}

package InnerClass;
/**
 * 局部内部类：
 *          1、局部内部类可以看做是局部变量
 *          2、局部内部类不可以用控制访问权限修饰符修饰
 *          3、局部内部类不能有静态声明(因为他是一个局部变量的等级)
 *          4、局部内部类访问局部变量时，局部变量之前默认加final
 * 
 * @author Administrator
 *
 */
public class PartInner {
    int a = 3;   //成员变量
    public void method(){

        class Inner {
            int i = 1;    //局部变量
            public void m1(){
                System.out.println(a);
                System.out.println(i);  
            }
        }
        Inner inn = new  Inner();    
        inn.m1();
    }
}

package InnerClass;
/**
 * 静态内部类
 *      1、静态内部类可以看做是静态变量
 *      2、可以被控制权限修饰符修饰
 *      3、可以有静态声明和非静态声明
 *      4、可以直接访问外部类中静态数据，但是不能直接访问成员数据
 * @author Administrator
 *
 */
public class StaticInner {

            //静态变量
            static String str1 = "zxg";
            //成员变量
            public String str2 = "qw";
            //静态方法
            private static void phoebe(){}
            //成员方法
            public void  daming(){}

    public static class  InnerClass{    //静态内部类
                //静态变量
                //static String str1 = "zxg";
                //成员变量
                //String str2 = "qw";
                //静态方法
                private static void phoebe(){}
                //成员方法
                public void  daming(){
                    System.out.println(str1);
                    //System.out.println(str2);
                    phoebe();
                    daming();

                }
    }
}

package InnerClass;
/**
 * 匿名内部类
 *          1、没有类名
 *          2、好处：少定义一个类
 *          3、缺点：无法重复利用
 * @author Administrator
 *
 */
public class AnonInner {

    public  static void test(Cust cust){
        cust.logout();
    }
    public static void main(String[] args) {

        //创建对象
        //Phoebe phoebe = new Phoebe();
        //test(phoebe);

        test(new Cust()
        {
            @Override
            public void logout() {
                System.out.println("成功退出。。。。");
            }
        }); 
    }
}
interface Cust{     //引用数据类型   String 
    //退出登录
    void logout();    //抽象方法(接口里的方法是抽象方法)
}
/*class Phoebe implements Cust{
    @Override
    public void logout() {
        System.out.println("我已经成功退出......");
    }
}*/