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("我已经成功退出......");
}
}*/