java中的包

01_面向对象(package关键字的概述及作用)(了解)

• A:为什么要有包
  • 将字节码(.class)进行分类存放
  • 包其实就是文件夹

02_面向对象(包的定义及注意事项)(掌握)

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

03_面向对象(带包的类编译和运行)(掌握)

• A:如何编译运行带包的类
  • a:javac编译的时候带上-d即可
    • javac -d . HelloWorld.java
  • b:通过java命令执行。
    • java 包名.HellWord

04_面向对象(import关键字的概述和使用)(掌握)

• A:案例演示
  • 为什么要有import
    • 其实就是让有包的类对调用者可见,不用写全类名了
    • 不导入，则书写格式：
      com.baidu.person p = new com.baidu.person();
    • 导入书写格式：
    • import com.baidu.person;
      person p = new person();
• B:导包格式
  • import 包名;
  • 注意：
  • 这种方式导入是到类的名称。
  • 虽然可以最后写*，但是不建议。
• C:package,import,class有没有顺序关系(面试题)
• 先package，后import，最后class
  06_面向对象(四种权限修饰符的测试)(掌握)
  四种权限修饰符

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

05_修饰符

• 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

08_内部类概述

• A:内部类概述
  指在类中的类
• B:内部类访问特点
  • a:内部类可以直接访问外部类的成员，包括私有。
  • b:外部类要访问内部类的成员，必须创建对象。
  • 外部类名.内部类名 对象名 = 外部类对象.内部类对象;
    Outer.Inner i = new Outer().new Inner();

成员内部类私有
若public类中有private类
可以在该public类中用公共方法创建一个对私有类的调用
静态成员内部类
以class Outer为例
class Outer {
static class Inner{}
}
Outer.Inner oi= new Outer.Inner();
外部类名.内部类名 对象名= 外部类名.内部类对象；
核心：静态类不用创建对象，直接使用；
成员内部类面试题：
要求：使用已知的变量，在控制台输出30，20，10。

	class Outer {
		public int num = 10;
		class Inner {
			public int num = 20;
			public void show() {
				int num = 30;
				System.out.println(?);			//?为number
				System.out.println(??);		//??为this.number
				System.out.println(???);		//???为Outer.this.num,内部类获取外部成员是因为能获取外部类引用：外部类名.this
			}
		}
	}
	class InnerClassTest {
		public static void main(String[] args) {
			Outer.Inner oi = new Outer().new Inner();
			oi.show();
		}	
	}

局部内部类访问局部变量
局部内部类访问局部变量必须用final修饰
* 局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?
因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用
匿名内部类格式/理解
A:匿名内部类
就是内部类的简化写法。
B:前提：存在一个类或者接口
这里的类可以是具体类也可以是抽象类。
C:格式：
new 类名或者接口名(){ //实现接口
重写方法;
} //整个看作一个子类对象

D:本质是什么呢?
是一个继承了该类或者实现了该接口的子类匿名对象。
匿名内部类重写多个方法调用

   interface Inter{
     public void show1();
     public void show2();
     }
   class Outer{
   		public void method(){
 			new Inter(){
 				public void show1(){
					System.out.println("show1");  	
				public void show2(){
					System.out.println("show2");  	
				}.show1()											//此时指new来实现一个接口Inter并重写show1和show2，同时使用show1中的方法		
				new Inter(){
 				public void show1(){
					System.out.println("show1");  	
				public void show2(){
					System.out.println("show2");  	
				}.show1()										//此时指new来实现一个接口Inter并重写show1和show2，同时使用show2中的方法

因为匿名内部类每次new都需要重写接口或类，因此建议匿名内部类只实现一个方法。
匿名内部类在开发中的应用

• A:代码如下

•   //这里写抽象类，接口都行
    abstract class Person {
    	public abstract void show();
    }
  
    class PersonDemo {
    	public void method(Person p) {				//Person p= new	 Student()
    		p.show();
    	}
    }
  
    class PersonTest {
    	public static void main(String[] args) {//如何调用PersonDemo中的method方法呢?
    		PersonDemo pd = new PersonDemo ();
    		
    	}
    }						
    解：
    class Student extands Person{
    	public void show(){
    		System.out.ptintln("show");
    		}
    	}				//有名内部类
    
    pd.method(new Person(){
    	public void show(){
    		System.out.println("show");
    		}
    		});			//匿名内部类当作参数传递，本质把匿名内部类看做一个对象
  

匿名内部类面试题

面试题
* 
		按照要求，补齐代码
		interface Inter { 
			void show(); 
			}
		class Outer { 
			//补齐代码 
			}
		class OuterDemo {
			public static void main(String[] args) {
				  Outer.method().show();				//method 调用完可以调用show，所以method调用完返回一个对象（链式编程，调用方法后继续调用，证明调用方法后返回对象）
				  													// Outer.method().show();	与Inter i = Outer.method(); i.show(); 效果相同
			  }
		}
		要求在控制台输出”HelloWorld”
		class Outer{
			public static Inter method(){			// 显示返回值为Inter
				return new Inter(){					//重写Inter接口,因为Inter为接口，所以返回一个Inter的子类对象
					public void show(){
						System.out.println("helloworld");
						}
					};
				}
			}