黑马程序员——包、权限修饰符、内部类

最新推荐文章于 2024-06-01 17:51:28 发布

Holylighting

最新推荐文章于 2024-06-01 17:51:28 发布

阅读量319

点赞数

本文链接：https://blog.csdn.net/talonky/article/details/47431887

版权

------- <a href=" http://www.itheima.com " target="blank">android培训</a>、<a href=" http://www.itheima.com " target="blank">java培训</a>、期待与您交流！ ----------

1、包

1、概念

包就是文件夹，用于区分相同的类名

3、带包的类的编译和运行

javac –d . 文件名.java

4、导包

import 报名1.包名2…类名;

如果我在一个类中需要用到不同包下的两个类，并且这两类名同名

方式1：通过关键字import导入一个包，另一个用类全名

方式2：两个都用类全名

5、package ,import ,class 的出现顺序

package-->imoprt-->class

注意：

package 最后面有;

class 类名后面是大括号

import,package是关键字，不是类名

2、访问权限修饰符

1、四种权限修饰符

本类同包(无关类或者子类) 不同包(子类) 不同包(无关类)

private Y

默认 Y Y

protected Y Y Y

public Y Y Y Y

2、访问修饰符汇总

修饰符\元素	类本身	成员变量	成员方法	构造方法
private	成员内部类使用	Y	Y	Y
默认	Y	Y	Y	Y
protected	内部类使用	Y	Y	Y
public	Y	Y	Y	Y
static	成员内部类使用	Y	Y
abstract	Y		Y
final	Y	Y	Y

推荐

以后所有的类都用public修饰，并且在一个Java文件中只定义一个类

所有的成员变量用private修饰

所有的方法用public修饰(工具类和单例除外)

接口中所有的方法和成员变量把修饰写全

所有的构造方法用public修饰

3、内部类

1、什么时候用

B类如果要直接使用A类中的所有成员的时候就把B类定义到A类里面

2、内部类和继承的区别

内部类可以直接访问外部类的所有成员（包括私有成员）

但是子类要想访问父类的私有成员的话只能通过get/set方法间接访问

2、访问特点(注意事项)

1、内部类可以直接访问外部类所有成员

2、外部类想要访问内部类成员，必须

创建

内部类对象

3、内部类分类

1、成员内部类

A、其他类如何使用成员内部类？

外部类名.内部类名变量名 = new 外部类构造方法（）.new 内部类构造方法（）;

如果成员内部类用 static 修饰那么调用的方式是

外部类名.内部类名变量名 = new 外部类名.内部类名();

private:为了安全性

static:为了方便调用

B、注意问题

如果一个内部类含有静态方法，那么该内部类必须被静态修饰

如果一个类被定义为静态时，该类中可以没有静态方法

案例：

<span style="font-size:14px;">class  Outer
{
	public int num = 20;

	//成员内部类
	class Inner1
	{
		public int innerNum = 30;
		public void show()
		{	//直接使用
			System.out.println(num);
		}
	}

	public void method()
	{
		int x = 100;
	}
	
	//只要这个方法被调用，我就输出了内部类中的成员变量
	public void diaoYN()
	{
		Inner1 i1 = new Inner1();
		System.out.println(i1.innerNum);	//30
	}
		
	
}
class OuterTest
{
	public static void main(String[] args)
	{
		Outer o = new Outer();
		o.diaoYN();

		//外部类名.内部类名 变量 = new 外部类名().new 内部类名();
		//该语句创建了一个内部类对象
		Outer.Inner1 oi = new Outer().new Inner1();
		System.out.println(oi.innerNum);
		oi.show();
	}
}</span>

2、局部内部类

定义在方法中的类

局部内部类访问局部变量，该局部变量必须被final修饰,因为被final 修饰就变成常量，在方法区中，他的生命周期延长了。

为什么要final修饰面试

局部变量会在方法调用完毕后，立马消失。

而局部内部类中如果有地方使用着局部变量，当方法消失后，这个方法区中的内容还没有消失，也就是说这个变量还必须存在，所以为了延长局部变量的生命周期，就加final修饰。

在外部类中定义一个方法，这个方法里面定义一个静态变量，测试可不可以，为什么

不可以，静态变量随类的加载而加载，而方法要被调用才会执行。

案例：

<span style="font-size:14px;">class Outer
{
	//private int num  = 10;

	public void method()
	{
		final int num = 10;
		//定义类
		class Inner
		{
			public void show()
			{
				System.out.println(num);
			}
		}

		//创建对象
		Inner i = new Inner();
		i.show();
	}

	public void function()
	{
		//错误
		//Inner i = new Inner();
		//i.show();
	}
}

class InnerTest3
{
	public static void main(String[] args) 
	{
		Outer o = new Outer();
		o.method();
	}
}
</span>

4、匿名内部类

概念：没有名字的局部内部类

前提：必须存在一个类，抽象类或者接口

格式：

new 类名或接口名(){

//重写类或者接口中的方法

//也可自定义方法

};

本质：匿名内部类其实就是继承了一个类或者实现了一个接口的匿名的子类对象(掌握)

5、使用

匿名内部类一般使用方式

1、方法在三个以下，可以考虑使用

2、方法的形式参数是接口或者抽象类

如：有一个接口叫 Inter

public void show( Inter i ){}

注意：所有父类或者父接口出现的地方，完全可以用子类对象替代。

案例：

<span style="font-size:14px;">interface Inter
{
	public abstract void show();
	public abstract void show2();
}

class Outer
{
	public void method()
	{
		
		new Inter()
		{
			public void show()
			{
				System.out.println("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 InnerTest4 
{
	public static void main(String[] args) 
	{
		Outer o = new Outer();
		o.method();
	}
}
</span>

6、内部类命名规则

成员内部类命名规则: 外部类$内部类.class

局部内部类命名规则: 外部类$1第一级内部类$2第二级内部类$3第三级内部类.class，$后跟数字，数字与内部类对应的层级有关系

匿名内部类命名规则: 外部类$1.class,1代表外部类下的第几个内部类

总结：

$跟类名表示是成员内部类,

$后面跟数字是匿名内部类，且数字代表个数,

$后面跟数字$类名是局部内部类，数字表示层级

4、匿名内部类与匿名对象的区别

不同点

匿名内部类是一个继承了类或者实现了接口的子类对象

而匿名对象就是这个类的本类对象