java不同包之间可以调用吗 java两个包之间的类

包

包的特点

• 可以有多层
• 不同包下的文件名可以重复
• package来修饰包并且在第一行代码

相同包下的访问

• 直接访问，不需要做其他的操作

不同包下的访问

• 使用类的全名（类的全名：包名.类名）
• 使用关键字import将类导入

注意：*代表是通配符，代表导入了这个包下所有的类，并没有导入子包下的类

package com.it01;

import java.util.ArrayList;
import java.util.ArrayList;;

public class PackageDemo2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		PackageDemo pd = new PackageDemo();
		
		//类的全名：包名.类名
		java.util.ArrayList list =new java.util.ArrayList();
		
		ArrayList list2 =new ArrayList();
	}

}

权限修饰符

• public 当前类 相同包下不同类 不同包下的类
• default 当前类 相同包下不同类
• private 当前类
• protected 当前类 相同包下不同类

default:当前包下使用
protected：让子类对象使用

package com.it02;

public class PermissionDemo {
	
	public void publicMethod() {
		System.out.println("publicMethod");
	}
	
	void defaultMethod() {
		System.out.println("defaultMethod");
	}
	
	private void privateMethod() {
		System.out.println("privateMethod");
	}
	
	protected void protectedMethod() {
		System.out.println("protectedMethod");
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		PermissionDemo pd = new PermissionDemo();
		
		pd.publicMethod();
		pd.defaultMethod();
		pd.privateMethod();
		pd.protectedMethod();

	}

}

package com.it02;

public class PermissionDemo2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		PermissionDemo pd = new PermissionDemo();
		pd.publicMethod();
		pd.defaultMethod();
		//pd.privateMethod();
		pd.protectedMethod();
	}

}

package com.it03;

import com.it02.PermissionDemo;

public class PermissionDemo3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		PermissionDemo pd = new PermissionDemo();
		pd.publicMethod();
		//pd.defaultMethod();
		//pd.privateMethod();
		//pd.protectedMethod();

	}

}

package com.it03;
import com.it02.PermissionDemo;
public class PermissionDemo4 extends PermissionDemo{

	public void function() {
		super.protectedMethod();
		super.publicMethod();
	}
	public static void main(String[] args) {
		
	}

}

修饰符	类	成员变量	成员方法	构造方法
public	y	y	y	y
default	y	y	y	y
protected	n	y	y	y
private	n	y	y	y
abstract	y	n	y	n
static	n	y	y	n
final	y	y	y	n

常见的规则：

• 1-以后我们使用public来修饰类，一个java文件只能有一个类，如果一个文件中有多个类，
  类名和文件名名一样的类必须使用public修饰，其他类不能使用public修饰
• 2-以后所有的成员变量都使用private修饰
• 3-以后所有的方法使用public修饰
• 4-以后所有的构造方法使用public修饰

内部类

1.成员内部类
2.局部内部类
3.匿名内部类

成员内部类

package com.it04;

import com.it04.Outer.Inner;

/*
 * 	成员内部类：
 * 		在类的成员位置
 * 		在内部类当中，可以直接访问外部类的成员，包括私有成员
 * 		
 */
public class InnerDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Outer o = new Outer();
		o.method();
		
		//在外部无法直接创建Inner对象，要先创建Outer对象
		Inner i1 = new Outer().new Inner();	
		i1.function();
	}

}

//定义外部类
class Outer{
	private int num =10;
	
	public void method() {
		
		Inner i = new Inner();	
		i.function();
	}
	class Inner{
		public void function() {
			System.out.println("这是内部类");
			System.out.println(num);
		}
	}
}

package com.it04;



/*
 * 	成员内部类的修饰符
 * 
 * 		我们可以使用权限修饰符修饰成员内部类，但是如果使用私有来修饰，则无法在其他类中访问
 * 		我们可以使用static修饰成员内部类，不用再创建外部类的对象了
 * 
 * 	可以使用abstract和final修饰成员内部类
 * 		
 */
public class InnerDemo2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		Outer2.Inner2 i = new Outer2.Inner2();
		i.function();
	}

}

//定义外部类
class Outer2{
	private int num =10;
	
	public void method() {
		
		Inner2 i = new Inner2();	
		i.function();
	}
	static class Inner2{
		public void function() {
			System.out.println("这是内部类");
			//System.out.println(num);
		}
	}
}

局部内部类

package com.it04;



/*
 * 	局部内部类
 * 		在方法内出了方法就不能使用，
 * 		
 */
public class InnerDemo3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Outer o = new Outer();
		o.method();
	}

}

//定义外部类
class Outer{
	
	public void method() {
		class Inner{
			public void function() {
				System.out.println("这是内部类");
			}
		}
		Inner i = new Inner();
		i.function();
		
	}
	
	public void Test() {
		//Inner i = new Inner();
		//i.function();
	}
	
}

匿名内部类

package com.it04;
/*
 * 	匿名内部类：
 * 		可以看作是一个没有名字的局部内部类
 * 		定义在方法当中
 *                     必须在定义匿名内部类的时候创建他的对象
 *  
 *  格式：
 *  new 类/接口( ){
 *  	如果创建了继承这个类的子类对象，我们可以重写父类的方法
 *  	如果创建了实现这个接口的子类对象，我们必须实现该接口的所有方法
 *  }；
 *  
 *  	原理：创建了继承这个类的子类对象或者是创建了实现这个接口的子类对象
 * 	
 */
public class InnerDemo4 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Outer8 o = new Outer8();
		o.method();

	}

}

interface Inner{
	public void function();
}

class Outer8{
	public void method() {
		//方式一
		new Inner() {

			@Override
			public void function() {
				// TODO Auto-generated method stub
				System.out.println("function");
			}
			
		}.function();
		
		//方式二
		
		Inner i= new Inner() {

			@Override
			public void function() {
				// TODO Auto-generated method stub
				System.out.println("function");
			}
			
		};
		i.function();
	}
}

匿名内部类的使用场景

package com.it04;

public interface Animal {
	public abstract void eat();
}

package com.it04;

public class Cat  implements Animal{

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("猫吃鱼");
	}

}

package com.it04;

public class Dog  implements Animal{

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("狗吃屎");
		
	}

}

package com.it04;
/*
 *  匿名内部类的使用场景
 *  	作为参数进行传递
 *  	
 */
public class InnerDemo5 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//method(new Dog());
		//method(new Cat());
		
		method(
				new Animal() {

			@Override
			public void eat() {
				// TODO Auto-generated method stub
				System.out.println("猫吃鱼");
			}

				}
				);
		}
	
	public static void method(Animal a) {
		a.eat();
	}

}