JAVA面向对象：相关基础知识（带包编译--权限修饰符--内部类）

1.带包编译

解决使用notepad++ 等文本编辑器编写的java类中如果需要 package 的解决方案:

手动式：手动建包，.java文件放在包外，.class文件放在包内
自动式：javac –d空格.空格文件名.java

java 包名.类名

建包：package 导包：import

注：不建包的时候：出现同包下存在同名类的情况，下述方式可以避免就近原则。

java.util.Scanner sc = new java.util.Scanner(System.in)

顺序：package ------ import --------- class

2.权限修饰符

public：允许在整个项目中访问，可以修饰所有的类/属性/方法；

(default)：允许在本包内访问，可以修饰所有的类/属性/方法；

protected：允许在本包内访问，同时允许访问不同包下的子类，可以修饰内部类/属性/方法；（很少用）

private：允许在本类中访问，可以修饰内部类/属性/方法；

外部类权限修饰符只有：public 、default(默认)

外部类修饰符：public , (default),final,abstract

3.内部类

内部类：定义在类里面的类，可以使用四种权限修饰符
* 成员内部类：
* 局部内部类：定义在方法中的类
* 静态内部类：
* 匿名内部类：
注：输出语句、if、循环等可执行语句必须放在方法里面。

=======成员内部类===========
如来一指
本兮
嘲风
10
=======局部内部类===========
hahaha
=======静态内部类===========
520
乾坤一掷
万剑归宗
乾坤一掷
520
===========================================================================
public class InnerClassDemo01 {
	public static void main(String[] args) {
		System.out.println("=======成员内部类===========");
		OuterClass.InnerClass1 inner = new OuterClass().new InnerClass1();
		inner.test();
		System.out.println("=======局部内部类===========");
		//1.使用匿名对象调用局部内部类存在的方法
		new OuterClass().method();
		System.out.println("=======静态内部类===========");
		System.out.println(OuterClass.InnerClass3.age);
		System.out.println(new OuterClass.InnerClass3().name);
		new OuterClass.InnerClass3().test();
	}
}

class OuterClass{
	private String name = "嘲风";  //成员变量
	static int age = 10;          //静态变量
	public void method() {
		String name = "hahaha";
		/**
		 * 局部内部类：类似于局部变量，用的很少
		 * 1.只能在方法中被认识
		 * 2.局部内部类不能使用public,private,protected 修饰：局部变量的权限只能在方法内部使用
		 * 3.在jdk1.7之前，局部内部类中访问的变量必须用final修饰，1.7之后可以省略不写。因为不希望在局部内部类消失后变量发生改变
		 * 调用局部内部类的步骤：1.先调用局部内部类存在的方法；2.在该方法中调用内部类
		 */
		class InnerClass2{
			public void test() {
				System.out.println(name);
			}
		}
		//2.在该方法中调用内部类
		new InnerClass2().test();
	}
	/**
	 * 成员内部类：创建对象的时候产生，类似于成员变量
	 * 1.成员内部类可以无限制的访问外部类中的成员，包括静态成员和私有成员
	 * 2.成员内部类中不能定义静态的成员，因为二者的生命周期不一样
	 * 3.如何调用成员内部类中的成员（变量/方法）
	 * 		创建内部类的对象： 外部类名.内部类名  对象名  = new 外部类名().new 内部类名();
	 * 4.如何在内部类中调用外部类中同名的成员
	 * 		外部类名.this.成员
	 */
	class InnerClass1{   //寄生关系，不是继承关系
		String name = "本兮";   //同名的成员变量
		public void test() {
			String name = "如来一指";    //同名的局部变量
			System.out.println(name);   //就近原则，打印局部变量
			System.out.println(this.name);  //打印内部类的成员变量
			System.out.println(OuterClass.this.name);  //打印外部类的成员变量
			System.out.println(age);
		}
	}
	/**
	 * 1.静态内部类既可以定义静态成员，也可以定义非静态的成员
	 * 2.有静态成员的内部类一定是静态内部类
	 * 3.Main类中如何调用静态内部类中的成员
	 * 		静态成员：外部类名.内部类名.静态变量
	 * 		非静态成员：new 外部类名.内部类名().非静态成员  ---new其实在 内部类名() 前面
	 */
	static class InnerClass3{
		String name = "乾坤一掷";     //静态内部类同名的成员变量
		static int age = 520;       //静态内部类同名的静态变量
		public void test() {
			String name = "万剑归宗";   //同名的局部变量
			System.out.println(name);
			System.out.println(this.name);
			//System.out.println(OuterClass.this.name);
			System.out.println(age);
		}
	}
}

* 匿名对象：new Teacher(); -------对象的一种简化写法
* 匿名内部类：(*****),内部类中最重要的一个。---------------- Lambda表达式是java语言向函数式编程的转变
本质：对象（实现了接口/继承了类）-------------------- 子类的对象
* 格式： new 接口名/类名(){重写/实现的方法}

* 匿名内部类最常用的使用方式是作为方法参数传递

public class NoNameDemo01 {
	public static void main(String[] args) {
		//正常写法:需要先写一个子类，然后实现接口，之后利用创建的对象访问接口中的test()方法
		InterA a1 = new ClassC();
		a1.test();
		//匿名内部类1：用变量接收，在调用方法
		InterA a = new InterA() {	
			@Override
			public void test() {
				System.out.println("生如夏花，死如秋叶");
			}
		};
		a.test();
		//匿名内部类2：直接调用方法
		new ClassA() {
			@Override
			public void show() {
				System.out.println("天地不仁，以万物为刍狗");				
			}			
		}.show();
		//对普通类使用匿名内部类，可以不进行方法的重写
		new ClassB() {   
			public void print() {
				System.out.println("杨花落尽子规啼");
			}
		}.print();
	}
}
//抽象类：抽象方法的abstract关键字不能省略
abstract class ClassA{
	abstract public void show();
}
//接口：public abstract可以省略
interface InterA{
	void test();
}
//普通类：方法有方法体
class ClassB{
	public void print() {
		System.out.println("愿你出走半生，归来仍是少年！");
	}
}
//正常情况下，不使用匿名内部类时
class ClassC implements InterA{
	@Override
	public void test() {
		System.out.println("正常情况下实现接口或继承抽象类还需要创建一个对象");	
	}
}