java基础学习日志13

内部类

/**
 * 外部类的构造方法先于内部类构造方法执行
 * @author 
 * @date 2018年1月26日上午9:39:24
 */
public class MyOuterClass {
	String outValue;
	static String name;
	MyInnerClass myinner;
//在类内部定义的类叫内部类，定义在外部类内部，外部类方法的外部叫成员内部类，也加全局内部类
//	在成员内部类中不能定义静态方法
//	成员内部类可以直接调用外部类的成员变量和成员方法
	class MyInnerClass {
		String name;
		public MyInnerClass() {
			System.out.println(" this is myinnerclass 构造方法");
		}
		public MyInnerClass(String name) {
			System.out.println(" this is myinnerclass 有参构造方法 "+name);
		}
		String inValue ="this is 内部类的变量";
		public void testInner() {
			System.out.println("this is testInner() ");
			System.out.println("this outValue is"+outValue);
			name="张三";
			run();
		}
//		public void run(){
//			System.out.println("this is myinnerclass run()");
//		}
	}
	private void run(){
//		外部类访问内部类成员必须通过内部类对象进行方法
		System.out.println(myinner.name);
	}
//	在main方法中实例内部类对象，要通过外部类对象来进行实例化内部类对象
	public static void main(String[] args) {
		MyOuterClass myout = new MyOuterClass("zs");
		myout.run();
//		MyInnerClass myinner = myout.new MyInnerClass();
	}
	public MyOuterClass(String outValue) {
		System.out.println("this is myout 构造方法");
		myinner = new MyInnerClass(outValue);
	}
}

/**
 * 这是局部内部类的实例 局部内部类是定义在外部类的方法体中
 * 
 * @author 
 * @date 2018年1月26日上午10:16:11
 */
public class AreaMyouterClass {
	private String instanceStr = "外部类的实例变量";
	private static String staticStr = "外部类的静态变量";
	String name;
	public void testInner(String name) {
//		局部内部类的作用范围只在定义他的方法中有效
		String innerMathName=name;
		class Inner {
			public String name;
			private String instanceStr = "内部类的实例变量";
//			在局部内部类中不能定义静态属性
//			static String staticStr = "t";
			public Inner(){
				
			}
			public Inner(String innerMathName) {
				this.name = innerMathName;
			}
			public void innerPrint() {
				// 访问的是内部类的实例变量
				// 因为重名时，内部类的成员优先级更高
				System.out.println(this.instanceStr);
				// 如果想明确的使用外部类的this
				// 那么就必须在this之前加上外部类的类名
				System.out.println(AreaMyouterClass.this.instanceStr);
				System.out.println(staticStr);
			}
		}
		System.out.println(innerMathName);
		Inner inner = new Inner(innerMathName);
		inner.innerPrint();
		System.out.println("this is 局部内部类的值"+inner.name);
	}
	public AreaMyouterClass() {
		
	}
	public AreaMyouterClass(String name){
		AreaMyouterClass out = new AreaMyouterClass();
		out.testInner(name);
	}
	public static void main(String[] args) {
		AreaMyouterClass myout = new AreaMyouterClass("tom");
		myout.testInner(myout.name);
		
	}
}

/**
 * 静态内部类就是在成员内部类前加上static修饰符
 * 静态成员内部是可以访问外部类静态属性和方法
 * @author 
 * @date 2018年1月26日上午10:40:42
 */
public class StaticOutClass {
	String outValue;
	static String name;
	static class MyStaticInnerClass {
		String inValue;
//		静态内部类中可以定义静态变量以及静态方法
		static int i = 100;
		public void testInner() {
			System.out.println("this is testInner() "+name);
			System.out.println("this is testInner() ");
			run();
		}
		
	}
	public static void run(){
		System.out.println("this is myouter Run()");
	}
	public static int run1(){
		return 1;
	}
	public void testOuter() {
		System.out.println("this is testOuter!");
		MyStaticInnerClass myinner1 = new MyStaticInnerClass();
		MyStaticInnerClass myinner2 = new MyStaticInnerClass();
		System.out.println(myinner1.i);
		myinner2.i=130;
		System.out.println(myinner1.i);
	}
	public static void main(String[] args) {
		StaticOutClass so =new StaticOutClass();
		so.testOuter();
	}
}

import com.hisoft.java.innerclass.StaticOutClass.MyStaticInnerClass;
/**
 * 在其他类创建内部类对象时，创建的语法不同
 在静态内部类中只能访问外部类的静态成员，可以定义静态方法
  在成员内部类中能访问外部类中所有静态成员、非静态成员，但不可以定义静态方法 
 * @author 
 * @date 2018年1月26日上午11:00:59
 */
public class Test {
	
	public static void main(String[] args) {
//		在其他类中实例成员内部类
//		MyOuterClass myout = new MyOuterClass("");
//		MyInnerClass myinner = myout.new MyInnerClass();
//		myinner.testInner();
		
//		在其他类中实例化静态内部类
//		方式一：通过导包
		StaticOutClass.MyStaticInnerClass min = new MyStaticInnerClass();
		min.testInner();
//		方式二：通过外部类.内部类
		StaticOutClass.MyStaticInnerClass min1= new StaticOutClass.MyStaticInnerClass();
		min.testInner();
	}
}

public interface MyInterface extends MyInterface2 {
	void m1();

	void sleep();
}

public class MyoutClassAndNoName {
	// 如果在方法中直接new 某一个接口，则相当于创建一个实现该接口的匿名内部类
	public void run() {
		MyInterface minner;
		minner = new MyInterface() {
			@Override
			public void m1() {
				System.out.println("这是一个匿名内部类对象");
			}

			public void run1() {
				System.out.println("这是匿名内部类的run方法");
			}

			@Override
			public void sleep() {
				System.out.println("这是匿名内部类的sleep方法");
			}

			@Override
			public void run() {
				// TODO Auto-generated method stub

			}
		};
		minner.m1();
		minner.sleep();
		minner.run();

	}

	public static void main(String[] args) {
		MyoutClassAndNoName mo = new MyoutClassAndNoName();
		mo.run();
	}
}

public abstract class MyAbstractDemo {
	public abstract void eat();

	public abstract void sleep();

	public void smoking() {
		System.out.println("这是抽烟方法");
	}

	public void run() {
		System.out.println("这是抽象类的自己的run()");
	}
}

public class MyOuterClassAndNameClass {
	public static void myInner() {
		// 创建通过继承抽象类类型的匿名内部类对象
		MyAbstractDemo myabs;
		myabs = new MyAbstractDemo() {
			@Override
			public void sleep() {
				System.out.println("这是继承抽象类的匿名内部类对象的sleep()");
			}

			@Override
			public void eat() {
				System.out.println("这是继承抽象类的匿名内部类对象的eat()");
			}

			// 如果匿名内部类要用自己的方法，那么该方法必须重写抽象类的方法
			@Override
			public void run() {
				System.out.println("这是匿名内部类的自己的run()");
			}
		};
		myabs.eat();
		myabs.sleep();
		myabs.smoking();
		myabs.run();
		// 这种只能使用一次
		new MyAbstractDemo() {

			@Override
			public void sleep() {
			}

			@Override
			public void eat() {

			}

			public void getName() {
				System.out.println("这是匿名内部类的自己的getName");
			}
		}.getName();

	}

	public static void main(String[] args) {
		myInner();
	}
}