内部类
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 ： 能在本类中被访问，能在本包中的其他类中被访问，能在其他包中的子类中被访问
能在其他包的无关类中被访问