笔记之java基础--10

1.什么叫包？
为了更好地组织类，Java提供了包机制。包是类的容器，用于分隔类名空间。如果没有指定包名，所有的示例都属于一个默认的无名包。Java中的包一般均包含相关的类，例如，所有关于交通工具的类都可以放到名为Transportation的包中。

2.包有什么用途？
如上所述，更好的组织类，防止在一个空间下出现类重名啊这些情况；表明类之间的层次关系。

3、四种权限修饰符的访问权限：

public  默认   private  protected

        1)说明在一个类中，这几种访问权限修饰符都可以访问

        2)同一个包中没有继承关系的两个类，除了private都可以访问。

        3）同一个包下，当有继承关系时，不管是Fu对象还是Zi对象，除了private都可以访问。

        4）不同包下没有继承关系的类只有public可以访问

        5）不同包下的有继承关系的访问，父类对象只能访问public,子类对象可以访问public和protect。

            结论：
                              本类         同一个包下(有无关系均可)    不同包下（继承）  不同包下（无关的类）
private              Y      
默认                  Y                      Y
protected         Y                      Y                                （zi）y(fu)N 
public               Y                      Y                                      y                               Y

记住：
成员变量：private

成员方法：public

                   类           成员变量         成员方法             构造方法
private                                     Y                  Y                  Y
默认                     Y                  Y          Y           Y
protected        Y             Y             Y
public                 Y       Y    Y Y
abstract              Y    Y
static                                     Y    Y
final                   Y                 Y    Y

注意，常见规则如下：
以后，所有的类都用public修饰，并且在一个java文件中，只写一个类。
以后，所有的成员变量都用private修饰。
以后，所有的成员方法都用public修饰
  如果是抽象类或者接口：
public abstra +...
以后，所有的构造方法用public修饰
      如果类是工具类或者是单例类：

构造用private修饰。

4、内部类概述：
1）将一个类定义在一个类的里面，对里面那个类就称为内部类（内置，类，嵌套类）。
访问特点：
内部类可以直接访问外部类中的成员，包括私有成员。
而外部类要访问内部类中的成员必须要建立内部类的对象。
     内部类的位置：
A:成员位置----成员内部类

B:局部位置----局部内部类

        如果想在测试类中，直接使用内部类，那么请按照如下格式：

                外部类名.内部类名 变量 = 外部类对象.内部类对象。

代码实例：

class Outer
{
private int num = 10;
class Inner
{
public void show()
{
System.out.println(num);
}
}
public void method()
{
Inner i = new Inner();
i.show();
}
}
class InnerTest
{
public static void main(String[] args) 
{
Outer o = new Outer();
o.method();
//能不能直接使用Inner类
//可以用，但是必须加限定
//格式：
//外部类名.内部类名 变量 = 外部类对象.内部类对象
Outer.Inner oi = new Outer().new Inner();
oi.show();
}

}

                但是这样不太合理，因为有的时候内部类是保密的不能随便被访问：

    2）内部类的修饰符：
A:private为了安全考虑，常见用法，这样修饰后，外界不能随便创建对象。

B:static为了方便，因为静态可以通过类名调用。

代码：

class Outer
{
private class Inner
{  
}
}
class InnerTest2 
{
public static void main(String[] args) 
{   
Outer.Inner oi = new Outer.Inner();//报错，因为private class Inner，不能在外部访问。   
}
}

    代码：

class Body
{
class Heart
{ 
public void operator()
{
System.out.println("心脏搭桥手术");
}
}
}
class Test
{
public static void main(String[] args) 
{
Body.Heart bh = new Body().new Heart();
bh.operator();
}
}
*/
//上面这几行程序，会导致任何人都可以访问内部类的operator函数，太不安全
//至少要加一个判断函数，同时对内部类加private修饰符
/*
class Body
{
private class Heart
{ 
public void operator()
{
System.out.println("心脏搭桥手术");
}
}
public void method()
{
if(如果你是医生)
{
Heart h = new Heart();
h.operator();
}
}
}
class Test
{
public static void main(String[] args) 
{
  Body b = new Body();
  b.method();
}
}

*/

    3）static修饰符：

class Outer
{
public static class Inner2
{
public void show()
{
System.out.println("show1");
}
public static void show2()
{
System.out.println("show2");
}
} 
}
class InnerTest2 
{
public static void main(String[] args) 
{
//如何使用Inner2中的方法呢
//如果内部类是静态修饰
//格式：
//外部类名.内部类名 变量 = new 外部类名.内部类名（）；
Outer.Inner2 oi = new Outer.Inner2();
oi.show();
oi.show2();
//因为Inner2是static修饰，可以直接通过类名调用。
Outer.Inner2.show2();   
}

}

4）局部内部类：
方法中定义的类。
结论：局部内部类访问局部变量，该变量必须被final修饰。
为什么？
局部变量在栈内存，使用完毕立刻消失，类是在堆内存中存储。并不是立刻消失。
类中的方法也没有立刻消失还在使用已经消失的栈内存中的变量。因此会报错。
final修饰后是常量，存储在方法区中的常量区，生命周期变长。
class Outer
{
private int num = 40; 
public void method()
{
//final int num = 30;
//定义类
class Inner
{
//int num = 20;
public void show()
{
//int num = 10;
System.out.println(num);
}
}
//创建对象
Inner i = new Inner();
i.show();
//局部类只能在局部使用。

}
public void function()
{
class Inner2
{
//int num = 10;
public void show()
{
//int num = 10;
//System.out.println(num);
}
}
}
}
class InnerTest3 
{
public static void main(String[] args) 
{  
Outer o = new Outer();
o.method();
o.function();
}

}

5）匿名内部类：
没有名字的局部内部类。
前提：
必须存在一个类，抽象类或者接口。
格式：
new 类名或者接口名（）
{
重写类或者接口中的方法，
也可以自己定义新的方法。
}
是一个继承了类或者实现了接口的匿名的子类对象。
什么时候使用匿名内部类：
一般来说，当接口或者抽象类中的方法在三个以下的时候考虑使用匿名类。
以后在看到一个方法接收的形式参数是一个抽象类或者接口的时候。

就可以考虑采用匿名内部类实现。

           匿名内部类 代码一：

interface Inter

{
public abstract void show();
}
class Outer
{
public void method()
{
/*
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();
}

}

    匿名内部类代码二：

interface Animal
{
public abstract void eat();
}
/*
class Dog implements Animal
{
public void eat()
{
System.out.println("eat Dog");
}
}
*/
class Test
{
public void show(Animal a)
{
a.eat();
}
}
class AnimalTest 
{
public static void main(String[] args) 
{
//Dog d = new Dog();
//d.eat();

Test t = new Test();
t.show(new Animal(){
public void eat()
{
System.out.println("eat Dog");
}
});
t.show(new Animal(){
public void eat()
{
System.out.println("eat Dog2");
}
});
}
}