Java 内部类、eclipse、包

内部类

一、定义在内部的类就是内部类

二、根据定义的位置不一样分为：成员内部类和局部内部类

三、成员内部类分为普通成员内部类、私有成员内部类和静态成员内部类

四、局部内部类：有名字的内部类和匿名内部类

成员内部类

一、普通成员内部类

　　一、定义在成员位置上的类

　　　　定义格式 class 内部类名{ 内部成员}

　　二、成员内部类说明

　　　　1.内部类能够直接访问外部类的全部成员，包括私有成员。
　　　　2.外部类访问内部类的成员，必须建立内部类的对象。
　　　　3.在外部其它类，访问内部类成员也要建立内部类对象。

　　建立内部类对象    外部类名.内部类名 内部类对象名 = new 外部类名().new 内部类名();

二、私有成员内部类

　　一、在成员类前加上private

　　二、访问说明：

　　　　1.在外部其它类之外，不能直接访问外部类中的私有成员内部类。
　　　　2.能够在外部类中，定义一个访问私有成员内部类的公有方法（也就是在外部类方法中建立内部类的对象），让外界                调用公有方法达到间接调用私有成员内部类的目的。

三、静态成员内部类

　　一、用static关键字修饰的内部类

　　二、访问特色：

　　　　1.成员内部类是外部类的静态成员，因此能够通外部类名.内部类名方式直接访问，而不须要建立外部类的对象。
　　　　2.静态内部类的非静态成员，须要将所在的内部类对象建立出来以后，才能被调用。
　　　　3.总结：一个类是否须要建立对象，不取决于该类自己是不是静态，而取决于访问的成员是不是静态。
　　　　4.外部类名.内部类名 对象名 = new 外部类名.内部类名();

public class Demo01 {

    public static void main(String[] args) {
        Animal.Dog.show();
    }
}

class Animal{
    
    private static int age = 10;
    
    public void eat() {
        System.out.println("eating");
    }
    
    static class Dog{
        static String name = "ahuang";
        public static void show() {
            System.out.println("名字是:"+name+"年龄是:"+age);
        }
    }
}

静态内部类的访问特色

局部内部类

一、定义在方法中的内部类

二、访问说明：

　　方法中的局部变量，外界都没有办法访问到，因此方法中定义的内部类，外界也没有办法访问到。
　　解决办法：在方法内部，就建立局部内部类的对象，调用对象的方法。

class Demo04_局部内部类 {
    public static void main(String[] args) {
        //经过调用breath方法，间接的访问局部内部类中的show方法
        breath();
    }
    public static void breath() {
        int f = 30;
        class Fei {
            String color = "black";
            public void show() {
                System.out.println(f + "..." + color + "...");
            }
        }
        //建立局部内部类对象
        Fei fei = new Fei();
        //调用局部内部类方法
        fei.show();
    }
}

局部内部类的访问特色

匿名内部类

一、没有名字的内部类

二、使用前提：继承一个类或实现一个接口

三、本质：子类的对象

四、在写匿名内部类时，里面的方法尽可能少于3个

public class Demo02 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new Dog() {
            public void eat() {
                System.out.println("eating");
            }
            public void mun() {    
            }    
        }.eat();//其实就是子类的定义加上实现成对象加上调用eat()方法
    }
}
interface MyInter{
    void eat();
}
interface MyInter2{
    void mun();
}
class Animal1{
    public void run() {
        System.out.println("runing");
    }
}
abstract class Dog extends Animal1 implements MyInter,MyInter2{

}

匿名内部类访问特色

eclipse

一、快捷键   alt + /内容辅助

　　一、ctrl + n：新建工程、包、类和文件等内容

　　二、Ctrl + shift + f：格式化代码

　　三、Ctrl + shift + o：自动导包、删除没有用的包

　　四、Ctrl + /：单行注释，取消单行注释

　　五、Ctrl + shift + / ：多行注释

　　六、Ctrl + shift + \ ：取消多行注释

　　七、Alt + ↑：向上移动一行

　　八、Alt + ↓：向下移动一行

　　九、Ctrl + alt + ↑：向上复制一行

　　十、Ctrl + alt + ↓ ：向下复制一行

　　十一、Ctrl + d：删除一整行

　　十二、Alt + shift + r：总体修改某个标识符名称

　　1三、F2：能够修改文件名称，而且将全部关联的位置一块儿修改

二、alt+shift+s 快速生成getter和Setter()方法、构造方法

三、ctrl +2 +l 快速命名

包

一、包：用于分类存放类文件（.class）的文件夹

二、做用：

  一、分类存放类文件

  二、在不一样的包中，能够起相同的类名（能够根据包名区分）

三、命名：

  域名倒着写：com.ujiuye.demos（全球惟一）

四、包的声明：

  使用package的关键字，声明当前的类是属于指定的包的

五、效果：

  一、编译的这个类，就会进入到一个指定的文件夹中

  二、当前的类，名称也发生了变化，类名变成了【包名 + 类名】

六、运行：

  一、包文件夹之外，没法直接访问到这个类了

  二、进入到包文件夹中，仍然没法访问到这个类：不管写类名仍是全类名都没法找到这个类

  三、【解决】在包文件夹所在的目录，运行这个类的全类名

七、访问：

  在其余类中访问带包的类的时候，须要使用那个类的全类名：包名+类名

八、简化：

  每次使用其余包的类的时候，都须要写很长一串全类名，因此很是麻烦，须要简化

  使用import语句进行简化，在类的声明上，写一个import语句，将这个类的全类名导入进来，在该类中，就能够直接使用这个类的简写形式了。

  注意事项：

　　一、即便在一个包中，有好多类都要使用，也不建议使用import *

　　二、若是在一个文件中，须要使用两个包中的同名类，那么不建议用import语句导包

     不然没法区分使用的是哪一个包中的类

九、权限修饰符

　　一、就是一些关键字，修饰成员，用于决定这些成员能够在什么位置被访问

　　二、这些关键字都是“封装”的体现形式

　　三、权限修饰符：

  　　　　private： 只能在本类中被访问

 　　　　 默认的权限修饰符（啥都不写）： 能够在本类中被访问，也能够在本包中的其余类中 被访问

 　　　　 protected： 能够在本类中被访问，也能够在本包中的其余类中被访问，能够在其余包的子类中被【继承】

　　　　  public ： 能在本类中被访问，能在本包中的其余类中被访问，能在其余包中的子类中被访问

                  　　能在其余包的无关类中被访问