【Java基础】-【包与内部类】

一、形式参数与返回值

1.形式参数

基本类型
引用类型
①类
形式参数需要的是该类的对象。
②抽象类
需要的是该抽象类的子类对象，通过多态实现。
③接口
需要的是该接口的实现类对象，通过多态实现。

2.返回值

基本类型
引用类型
①类
返回的是该类的对象。
②抽象类
返回的是该抽象类的子类对象。
③接口
返回的是该接口的实现类的对象。
链式编程
每次调用完毕方法后，返回的是一个对象。

StudentDemo sd = new StudentDemo();
sd.getStudent().study();

二、包

1.包的概述

包其实就是文件夹。

2.包的作用

①把相同的类名放到不同的包中。
②对类进行分类管理。

3.分包方案

方案1：按照功能分

cn.itcast.add
		AddStudent
		AddTeacher
cn.itcast.delete
		DeleteStudent
		DeleteTeacher
cn.itcast.update
		UpdateStudent
		UpdateTeacher
cn.itcast.find
		FindStudent
		FindTeacher

方案2：按照模块分

cn.itcast.teacher
		AddTeacher
		DeleteTeacher
		UpdateTeacher
		FindTeacher
cn.itcast.student
		AddStudent
		DeleteStudent
		UpdateStudent
		FindStudent

4.包的定义

	package 包名;
	//多级包用.分开即可

5.包的注意事项

注意事项:
①package语句必须是程序的第一条可执行的代码。
②package语句在一个java文件中只能有一个。
③如果没有package，默认表示无包名。

6.带包的编译和运行

	A:手动式
		a:编写一个带包的java文件。
		b:通过javac命令编译该java文件。
		c:手动创建包名。
		d:把b步骤的class文件放到c步骤的最底层包
		e:回到和包根目录在同一目录的地方，然后运行。
			[注意：带包运行]		
					
	B:自动式
		a:编写一个带包的java文件。
		b:javac编译的时候带上-d即可
			javac -d . HelloWorld.java
		c:通过java命令执行。和手动式一样。

7.导包

导包概述
不同包下的类之间的访问，每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能。
导包格式

import 包名;

注意：
这种方式导入是到类的名称，虽然可以最后写*，但是不建议。
思考题：

思考1：
		package,import,class有没有顺序关系?

答：有，package > import > class

	Package:只能有一个。
	import:可以有多个。
	class:可以有多个，以后建议是一个。

—————————————————————————

权限修饰符

					本类	   同一个包下(子类和无关类)	不同包下(子类)	不同包下(无关类)
	private 		Y		
	默认				Y			Y
	protected		Y			Y						Y
	public			Y			Y						Y				Y

类及其组成可以用的修饰符

修饰符：
-权限修饰符：private，默认的，protected，public
-状态修饰符：static，final
-抽象修饰符：abstract

类：
	权限修饰符：默认修饰符，public
	状态修饰符：final
	抽象修饰符：abstract
	
	用的最多的就是：public
	
成员变量：
	权限修饰符：private，默认的，protected，public
	状态修饰符：static，final
	
	用的最多的就是：private
	
构造方法：
	权限修饰符：private，默认的，protected，public
	
	用的最多的就是：public
	
成员方法：
	权限修饰符：private，默认的，protected，public
	状态修饰符：static，final
	抽象修饰符：abstract
	
	用的最多的就是：public
	
除此以外的组合规则：
	成员变量：public static final
	成员方法：	public static 
	          	public abstract
			  	public final

三、内部类

1.内部类概述

把类定义在其他类的内部，这个类就被称为内部类。
举例：在类A中定义了一个类B，类B就是内部类。

2.内部类的访问特点：

①内部类可以直接访问外部类的成员，包括私有。
②外部类要访问内部类的成员，必须创建对象。

3.内部类位置

按照内部类在类中定义的位置不同，可以分为如下两种格式：
-成员位置(成员内部类)
-局部位置(局部内部类)

class Outer 
{
	private int num = 10;	
	//成员位置
	/*
	class Inner
	 {
		
	}
	*/
	

	public void method() 
	{
		//局部位置
		class Inner
		 {
		
		}
	}
}

4. 成员内部类

直接访问内部类成员：

//外部类名.内部类名 对象名 = 外部类对象.内部类对象;
Outer.Inner oi = new Outer().new Inner();

成员内部类的修饰符
①private 为了保证数据的安全性
-一般内部类是不让外界直接访问的。
②static 为了让数据访问更方便
-内部类用静态修饰是因为内部类可以看成是外部类的成员。
-被静态修饰的成员内部类只能访问外部类的静态成员。
-成员内部类被静态修饰后的访问方式是:

//格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
Outer.Inner oi = new Outer.Inner();

思考题：

思考1：
	要求请填空分别输出30，20，10。
class Outer {
	public int num = 10;
	class Inner {
		public int num = 20;
		public void show() {
			int num = 30;
			System.out.println(???);
			System.out.println(???);
			System.out.println(???);
		}
	}
}
class InnerClassTest {
	public static void main(String[] args) {
		Outer.Inner oi = new Outer().new Inner();
		oi.show();
	}	
}

答：num、this.num、Outer.this.num
1:内部类和外部类没有继承关系。
2:通过外部类名限定this对象。
—————————————————————————

5.局部内部类

-可以直接访问外部类的成员。
-可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能。
思考题：

思考1：
局部内部类访问局部变量的注意事项及原因：

class Outer {
	private int num  = 10;
	
	public void method() {
		//int num2 = 20;
		final int num2 = 20;
		class Inner {
			public void show() {
				System.out.println(num);
				//从内部类中访问本地变量num2; 需要被声明为最终类型
				System.out.println(num2);//20
			}
		}		
		
		Inner i = new Inner();
		i.show();
	}
}

答： 局部内部类访问局部变量必须用final修饰。
原因：
局部变量是随着方法的调用而调用，随着调用完毕而消失。而堆内存的内容并不会立即消失。所以加final修饰。加入final修饰后，这个变量就成了常量。既然是常量。变量消失了。在内存中存储的是数据20，所以，还是有数据在使用。
—————————————————————————

6.匿名内部类

就是内部类的简化写法。
前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类。
格式：

new 类名或者接口名() {重写方法;}

本质：是一个继承了类或者实现了接口的子类匿名对象。
示例：

interface Inter {
	public abstract void show();
	public abstract void show2();
}

class Outer {
	public void method() {
		//一个方法的时候
		/*
		new Inter() {
			public void show() {
				System.out.println("show");
			}
		}.show();
		*/
		
		//二个方法的时候
		/*
		new Inter() {
			public void show() {
				System.out.println("show");
			}
			
			public void show2() {
				System.out.println("show2");
			}
		}.show();
		
		new Inter() {
			public void show() {
				System.out.println("show");
			}
			
			public void show2() {
				System.out.println("show2");
			}
		}.show2();
		*/
		
		//多个方法改进的方案
		Inter i = new Inter() { //多态
			public void show() {
				System.out.println("show");
			}
			
			public void show2() {
				System.out.println("show2");
			}
		};
		
		i.show();
		i.show2();
	}
}

class InnerClassDemo {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
	}
}

匿名内部类在开发中的使用

interface Person {
	public abstract void study();
}

class PersonDemo {
	//接口名作为形式参数
	//其实这里需要的不是接口，而是该接口的实现类的对象
	public void method(Person p) {
		p.study();
	}
}

//实现类
class Student implements Person {
	public void study() {
		System.out.println("好好学习,天天向上");
	}
}

class InnerClassTest2 {
	public static void main(String[] args) {
		//测试
		PersonDemo pd = new PersonDemo();
		Person p = new Student();
		pd.method(p);
		System.out.println("--------------------");
		
		//匿名内部类在开发中的使用
		//匿名内部类的本质是继承类或者实现了接口的子类匿名对象
		pd.method(new Person(){
			public void study() {
				System.out.println("好好学习,天天向上");
			}
		});
	}
}

思考题

思考1：
	匿名内部类面试题：
		按照要求，补齐代码
			interface Inter { void show(); }
			class Outer { //补齐代码 }
			class OuterDemo {
				public static void main(String[] args) {
					  Outer.method().show();
				  }
			}
			要求在控制台输出”HelloWorld”

答：

interface Inter { 
	void show(); 
	//需要注意重写方法权限不能低于public abstract
}

class Outer { 
	//补齐代码
	public static Inter method() {
		//子类对象 -- 子类匿名对象
		return new Inter() {
			public void show() {
				System.out.println("HelloWorld");
			}
		};
	}
}

class OuterDemo {
	public static void main(String[] args) {
		Outer.method().show();
		/*
			1:Outer.method()可以看出method()应该是Outer中的一个静态方法。
			2:Outer.method().show()可以看出method()方法的返回值是一个对象。
			3.由于接口Inter中有一个show()方法,method()方法的返回值类型是一个接口。
		*/
	}
}