内部类
可访问外围类
- 外围类就是包含内部类的那个类的啦
public class Sequence {
private Object[] items= new Object[5];
private class SequenceSelector implements Selector
{
private int i ;
@Override
public boolean end() {
return 1==items.length; //直接访问了内部类属性;
}
}
public Selector selector ()
{
return new SequenceSelector();
}
public static void main (String a[])
{
Sequence sequence = new Sequence();
Selector selector = sequence.selector();
System.out.println(selector.end());
}
}
this 与new
- this是返回类自身的一个对象;
- 外部类的.new方法,用于初始化一个内部类对象
public class DoThis {
inner inner = new inner();
private class inner //访问无限制;
{
public inner in()
{
return inner.this;
}
}
public static void main(String a[])
{
DoThis doThis = new DoThis();
DoThis.inner inner = doThis.new inner();
System.out.println(inner.equals(inner.in())); //输出为true
inner in = new inner(); //报错,(即便内部类为public),解决方案显示,要不将内部类static,变成嵌套类;要不main函数去掉static ,这样就变成外围类的小函数喽;
}
}
ps:在拥有外部类之前,是不能创建内部类的;内部类对象会偷偷连接到外部类对象;嵌套类除外,就是内部类前面加static;嵌套类基本是说外部类可以访问内部类,而内部类不可直接访问内部类;
内部类与向上转型;
1.大概讲了接口分离吧,没感觉的说。。。。
在方法和作用域中的内部类
1.当一个类只在某处使用,而又不想公开,就可以写在方法或作用域中
public void test()
{
class a{ //class前面不可有访问控制符;
}
if (true)
{
class b {
}
}
}
匿名类 (重点喽)
public class Parcel7 {
public Selector selector () //Selector是接口
{
return new Selector() { //直接返回一个对象,没有引用,也就是对象的名字
@Override
public boolean end() { //接口需要重写方法;
return false;
}
};
}
class selector implements Selector //原始版本
{
@Override
public boolean end() {
return false;
}
}
public Selector selector02()
{
return new selector();
}
}
1.从上面可以看出,在没有匿名类时。我们需要使用接口就得新建一个类,为了方便就可以创建内部类;但是类本身生成对象没有用啊,于是我们可能就得用函数,或者外围类来创建它;而假设我们只是想得到一个对象,这样太麻烦了;匿名类就简化了这样的步骤;
2.相当于什么呢,现在我们需要一个泥瓦罐,平常得先继承啊什么的,匿名类,直接上一个泥瓦罐交差了;
上面的是接口,如果是继承呢?
public class Wrapping {
private int i ;
public Wrapping(int x)
{
i = x;
}
public void a()
{
}
}
public class Parcel7 {
public Wrapping wrapping ()
{
return new Wrapping(1) //这里也可以直接初始化
{
@Override //只能重写
public void a() {
}
};
}
}
1. 当匿名类继承自类时,实际上是把它作为接口使用,无法重载;
2. 匿名内部类只能继承或只能实现接口,不可重载;
再访工厂方法
嵌套类
感觉没啥用啊
- 嵌套类的创建不需要外部类;也就是说你写在内部,写在外部没有区别
- 不能从嵌套类对象访问非静态的外围类的对象。 只能访问静态对象,要你何用?
- 一个嵌套类不管嵌套多深,都可以访问外部类;
- 但是我们发现,当嵌套类放在接口中的时候,他就可以顺利成章的被所有实现接口的类所使用(接口自动就是static ,所以内部类不好使)
public interface ClassInterface {
void howdy();
class test implements ClassInterface
{
@Override
public void howdy() {
System.out.println("out");
}
void a () //a方法就不行啦
{
System.out.println("a");
}
}
}
public class ClassIner implements ClassInterface {
@Override
public void howdy() {
}
public static void main(String a[])
{
ClassIner classIner = new ClassIner();
classIner.howdy();
new test().howdy(); //不声明接口无法调用
}
}
内部类到底有啥用处?
1. 首先一个内部类创建时就和一和一个外围类的对象绑定;可以访问外围类中的属性;
2. 内部类可以有多个;他们可以实现接口或者继承;
于是我们可以推出的是:
1. 当内部类对象被创建时,这个对象是可以操作外围类数据的;这就好像外围类自己的方法操作自己的方法一样;然而,内部类可以继承,可以接口;所以方法一下子就变多了;等于外围类实现了多重继承;
2. 然而却不是多重继承;我们在继承的时候,留下了方法,留下了属性;然而有些时候我们只希望用一下你们家的方法,不想要属性;(想要属性那是抽象类)这种事情很多,就有了接口,谁想用用呗;只要自己想办法实现;然而这样不能用继承啊,而且接口多的话好麻烦啊,整个类变得臃肿不堪
最后呢,举个例子:
- 期初有一家公司
- 这家公司随着时间总得换新boss吧;然后就继承出了新的公司;
- 随着时间又该换boss啦,老头看了看不争气的儿子;就把公司的几个部门的老大解雇了,说到:我把这些人解雇,部门还留着,但是具体实现就得靠你了;这时就是抽象类了;
- 随着时间过去了很久,市场有了天翻地覆的变化,网络啊,手机啊;这家公司不知所措,就别人做什么他也做什么;经常是使用公司的全力向某个方向发展;然后活下去了;这就叫做接口;
- 但是随着接口越来越多,公司的发展方向越来越多;很难再倾尽公司之力,于是就分为子公司专做这个;这就是内部类
- 随着时间的消逝,你可能已经忘了最初的那家公司了,因为它全身插满了管子,通往四面八方;
闭包
闭包(Closure)是一种能被调用的对象,它保存了创建它的作用域的信息。JAVA并不能显式地支持闭包,但是在JAVA中,闭包可以通过“接口+内部类”来实现。
例如:一个接口程序员和一个基类作家都有一个相同的方法work,相同的方法名,但是其含义完全不同,这时候就需要闭包。
class Writer {//作家基类
void work(){};
}
interface programmer{//程序员接口
void work();
}
闭包实现代码如下:
public class WriterProgrammer extends Writer {
@Override
public void work(){
//写作
}
public void code(){
//写代码
}
class ProgrammerInner implements programmer{
@Override
public void work(){
code();
}
}
}
在子类中定义了遵循程序员接口规则的内部类,然后使用内部类实现程序员的work()方法回调code()方法,在子类中直接实现父类作家的work()方法。