Java 内部类、eclipse、包

内部类

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

2、根据定义的位置不同分为：成员内部类和局部内部类

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

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

成员内部类

1、普通成员内部类

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

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

　　2、成员内部类说明

　　　　1.内部类可以直接访问外部类的所有成员，包括私有成员。
　　　　2.外部类访问内部类的成员，必须创建内部类的对象。
　　　　3.在外部其它类，访问内部类成员也要创建内部类对象。

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

2、私有成员内部类

　　1、在成员类前加上private

　　2、访问说明：

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

3、静态成员内部类

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

　　2、访问特点：

　　　　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);
        }
    }
}

局部内部类

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

2、访问说明：

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

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();
    }
}

匿名内部类

1、没有名字的内部类

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

3、本质：子类的对象

4、在写匿名内部类时，里面的方法尽量少于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

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

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

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

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

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

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

　　6、Ctrl + shift + ：取消多行注释

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

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

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

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

　　11、Ctrl + d：删除一整行

　　12、Alt + shift + r：整体修改某个标识符名称

　　13、F2：可以修改文件名称，并且将所有关联的位置一起修改

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

3、ctrl +2 +l 快速命名

包

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

2、作用：

  1、分类存放类文件

  2、在不同的包中，可以起相同的类名（可以根据包名区分）

3、命名：

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

4、包的声明：

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

5、效果：

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

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

6、运行：

  1、包文件夹以外，无法直接访问到这个类了

  2、进入到包文件夹中，仍然无法访问到这个类：无论写类名还是全类名都无法找到这个类

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

7、访问：

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

8、简化：

  每次使用其他包的类的时候，都需要写很长一串全类名，所以非常麻烦，需要简化

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

  注意事项：

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

　　2、如果在一个文件中，需要使用两个包中的同名类，那么不建议用import语句导包

     否则无法区分使用的是哪个包中的类

9、权限修饰符

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

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

　　3、权限修饰符：

	本类中	子类中	同包类中	其他类中
public	可以	可以	可以	可以
protected	可以	可以	可以	不可以
默认	可以	同包子类可以	可以	不可以
private	可以	不可以	不可以	不可以

　　　　 private： 只能在本类中被访问

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

 　　　　protected： 可以在本类中被访问，也可以在本包中的其他类中被访问，可以在其他包的子类中被【继承】

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

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