权限修饰符 内部类 匿名内部类

权限修饰符 内部类 匿名内部类

1. package关键字的概述及作用

A:包的概述:	就是文件夹
B:包的作用:   用来解决同一个路径下不能存在同名文件的问题(分类管理)
C:包的划分:
	按照功能
	按照模块

2. 包的定义及注意事项

A:定义包的格式
	package 包名;
	多级包用.分开即可
B:定义包的注意事项
	A:package语句必须是程序的第一条可执行的代码
	B:package语句在一个java文件中只能有一个
	C:如果没有package，默认表示无包名

3. 不同包下类之间的访问

A:案例演示
	不同包下类之间的访问
		定义两个类：Demo,Test。
			Demo
				求和方法(sum)
			Test
				测试方法(main)

4. import关键字的概述和使用

A:导包的概述
	不同包下的类之间的访问，我们发现，每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能
B:导包格式
	import 包名;
	注意：
		这种方式导入是到类的名称。
		虽然可以最后写*，但是不建议。
C:package,import,class有没有顺序关系(面试题)

5. 四种权限修饰符

四种权限修饰符: private(私有的) , 默认 , protected(受保护的) , public(公共的)

6. 类及其组成所使用的常见修饰符

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

6. 内部类概述和访问特点

A:内部类概述:	把类定义在其他类的内部，这个类就被称为内部类。
	举例：在类A中定义了一个类B，类B就是内部类。
B:内部类访问特点
	a:内部类可以直接访问外部类的成员，包括私有。
	b:外部类要访问内部类的成员，必须创建对象。
C:案例演示
	内部类极其访问特点

7. 内部类分类及成员内部类的直接使用

A:按照内部类位置分类
	成员位置:在成员位置定义的类，被称为成员内部类。	
	局部位置:在局部位置定义的类，被称为局部内部类。
B:成员内部类
	如何在测试类中直接访问内部类的成员。
	格式: 	外部类名.内部类名 对象名 = 外部类对象.内部类对象;

8. 成员内部类的常见修饰符及应用

A:成员内部类的修饰符：
	private 为了保证数据的安全性
	static 	为了方便访问数据
		注意事项:  a:静态内部类访问的外部类数据必须用静态修饰。
		           b: 成员方法可以是静态的也可以是非静态的
B:成员内部类被静态修饰后的访问方式是:
	格式:	外部类名.内部类名 对象名 = new 外部类名.内部类名();

9. 匿名内部类

1. 匿名内部类其实就是内部类的简写格式。
2. 定义匿名内部类的前提：内部类必须是继承一个抽象类或者实现接口。只要一个类是抽象的或是一个接口，那么其子类中的方 法都可以使用匿名内部类来实现。
3. 匿名内部类的格式： new 父类或者接口(){定义子类的内容}
4. .其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。
5. 匿名内部类中定义的方法最好不要超过3个。

例如 ：通过继承一个抽象类来定义匿名内部类。

package com.saiermeng;
abstract class AbsDemo
{
abstract void show();


}
class Outer4
{
int x = 3;
    public void function()
{
             AbsDemo d = new AbsDemo()
{
int num = 9;
void show()
{
System.out.println("num==="+num);
}
void abc()
{
System.out.println("haha");
}
};


d.show();
     }
}
class InnerClassDemo4 
{
public static void main(String[] args) 
{
new Outer4().function();
}
}

通过实现一个接口来定义匿名内部类。

package com.saiermeng;
interface Inter0{
void method();

}
class Test0{
static Inter0 function(){    


return new Inter0(){      //new 就是新建了一个实现接口抽象方法的对象



public void method() {
System.out.println("method run");

}

};
}
}


public class InnerClassTest0 {
public static void main(String[]args){
Test0.function().method();

// 通过一个方法得到实现接口的子类对象，通过对象调用方法，就得到了Test0.function().method();
show(new Inter0(){



public void method() {
System.out.println("method show run");

}

});

}
public static void show(Inter0 in){
in.method();
}
}