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);
}
}
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);
}
}
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);
}
}
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);
}
}
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();
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{
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{
private static void phoebe(){}
public void daming(){
System.out.println(str1);
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) {
test(new Cust()
{
@Override
public void logout() {
System.out.println("成功退出。。。。");
}
});
}
}
interface Cust{
void logout();
}