static关键字
-
使用范围：
- 在Java类中，可用static修饰属性、方法、代码块、内部类
-
被修饰后的成员具备以下特点：
- 随着类的加载而加载
- 优先于对象存在
- 修饰的成员，被所有对象所共享
- 访问权限允许时，可不创建对象，直接被类调用
静态变量
使用static修饰的成员变量就是静态变量（或类变量、类属性）
[修饰符] class 类{
[其他修饰符] static 数据类型 变量名;
}
静态变量的特点
-
静态变量的默认值规则和实例变量一样。
-
静态变量值是所有对象共享。
-
静态变量的值存储在方法区。
-
静态变量在本类中，可以在任意方法、代码块、构造器中直接使用。
-
如果权限修饰符允许，在其他类中可以通过“
类名.静态变量”直接访问，也可以通过“对象.静态变量”的方式访问（但是更推荐使用类名.静态变量的方式）。 -
静态变量的get/set方法也静态的，当局部变量与静态变量
重名时，使用“类名.静态变量”进行区分。
| 分类 | 数据类型 | 默认值 |
|---|---|---|
| 基本类型 | 整数（byte，short，int，long） | 0 |
| 浮点数（float，double） | 0.0 | |
| 字符（char） | 0或'\u0000' | |
| 布尔（boolean） | false | |
| 数据类型 | 默认值 | |
| 引用类型 | 数组，类，接口 | null |
静态方法
语法格式
用static修饰的成员方法就是静态方法。
[修饰符] class 类{
[其他修饰符] static 返回值类型 方法名(形参列表){
方法体
}
}
静态方法的特点
- 静态方法在本类的任意方法、代码块、构造器中都可以直接被调用。
- 只要权限修饰符允许，静态方法在其他类中可以通过“类名.静态方法“的方式调用。也可以通过”对象.静态方法“的方式调用（但是更推荐使用类名.静态方法的方式）。
- 在static方法内部只能访问类的static修饰的属性或方法，不能访问类的非static的结构。
- 静态方法可以被子类继承，但不能被子类重写。
- 静态方法的调用都只看编译时类型。
- 因为不需要实例就可以访问static方法，因此static方法内部不能有this，也不能有super。如果有重名问题，使用“类名.”进行区别。
package com.atguigu.keyword;
public class Father {
public static void method(){
System.out.println("Father.method");
}
public static void fun(){
System.out.println("Father.fun");
}
}
package com.atguigu.keyword;
public class Son extends Father{
// @Override //尝试重写静态方法，加上@Override编译报错，去掉Override不报错，但是也不是重写
public static void fun(){
System.out.println("Son.fun");
}
}
package com.atguigu.keyword;
public class TestStaticMethod {
public static void main(String[] args) {
Father.method();
Son.method();//继承静态方法
Father f = new Son();
f.method();//执行Father类中的method
}
}
代码块
静态代码块
如果想要为静态变量初始化，可以直接在静态变量的声明后面直接赋值，也可以使用静态代码块。
在代码块的前面加static，就是静态代码块。
【修饰符】 class 类{
static{
静态代码块
}
}
静态代码块的特点
1.可以有输出语句。
2. 可以对类的属性、类的声明进行初始化操作。
3. 不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法。
4. 若有多个静态的代码块，那么按照从上到下的顺序依次执行。
5. 静态代码块的执行要先于非静态代码块。
6. 静态代码块随着类的加载而加载，且只执行一次。
package com.atguigu.keyword;
public class Chinese {
// private static String country = "中国";
private static String country;
private String name;
{
System.out.println("非静态代码块，country = " + country);
}
static {
country = "中国";
System.out.println("静态代码块");
}
public Chinese(String name) {
this.name = name;
}
}
package com.atguigu.keyword;
public class TestStaticBlock {
public static void main(String[] args) {
Chinese c1 = new Chinese("张三");
Chinese c2 = new Chinese("李四");
}
}
非静态代码块
语法格式
【修饰符】 class 类{
{
非静态代码块
}
【修饰符】 构造器名(){
// 实例初始化代码
}
【修饰符】 构造器名(参数列表){
// 实例初始化代码
}
}
非静态代码块的作用
和构造器一样，也是用于实例变量的初始化等操作。
非静态代码块的意义
如果多个重载的构造器有公共代码，并且这些代码都是先于构造器其他代码执行的，那么可以将这部分代码抽取到非静态代码块中，减少冗余代码。
非静态代码块的执行特点
-
可以有输出语句。
-
可以对类的属性、类的声明进行初始化操作。
-
除了调用非静态的结构外，还可以调用静态的变量或方法。
-
若有多个非静态的代码块，那么按照从上到下的顺序依次执行。
-
每次创建对象的时候，都会执行一次。且先于构造器执行。
举例
（1）声明User类，
-
包含属性：username（String类型），password（String类型），registrationTime（long类型），私有化
-
包含get/set方法，其中registrationTime没有set方法
-
包含无参构造，
- 输出“新用户注册”，
- registrationTime赋值为当前系统时间，
- username就默认为当前系统时间值，
- password默认为“123456”
-
包含有参构造(String username, String password)，
- 输出“新用户注册”，
- registrationTime赋值为当前系统时间，
- username和password由参数赋值
-
包含public String getInfo()方法，返回：“用户名：xx，密码：xx，注册时间：xx”
（2）编写测试类，测试类main方法的代码如下：
public static void main(String[] args) {
User u1 = new User();
System.out.println(u1.getInfo());
User u2 = new User("song","8888");
System.out.println(u2.getInfo());
}
如果不用非静态代码块，User类是这样的：
package com.atguigu.block.no;
public class User {
private String username;
private String password;
private long registrationTime;
public User() {
System.out.println("新用户注册");
registrationTime = System.currentTimeMillis();
username = registrationTime+"";
password = "123456";
}
public User(String username,String password) {
System.out.println("新用户注册");
registrationTime = System.currentTimeMillis();
this.username = username;
this.password = password;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public long getRegistrationTime() {
return registrationTime;
}
public String getInfo(){
return "用户名：" + username + "，密码：" + password + "，注册时间：" + registrationTime;
}
}
如果提取构造器公共代码到非静态代码块，User类是这样的：
package com.atguigu.block.use;
public class User {
private String username;
private String password;
private long registrationTime;
{
System.out.println("新用户注册");
registrationTime = System.currentTimeMillis();
}
public User() {
username = registrationTime+"";
password = "123456";
}
public User(String username, String password) {
this.username = username;
this.password = password;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public long getRegistrationTime() {
return registrationTime;
}
public String getInfo(){
return "用户名：" + username + "，密码：" + password + "，注册时间：" + registrationTime;
}
}
final关键字
final修饰类
表示这个类不能被继承，没有子类。提高安全性，提高程序的可读性。
例如：String类、System类、StringBuffer类
final class Eunuch{//太监类
}
class Son extends Eunuch{//错误
}
final修饰方法
表示这个方法不能被子类重写。
例如：Object类中的getClass()
class Father{
public final void method(){
System.out.println("father");
}
}
class Son extends Father{
public void method(){//错误
System.out.println("son");
}
}
final修饰变量
final修饰某个变量（成员变量或局部变量），一旦赋值，它的值就不能被修改，即常量，常量名建议使用大写字母。
例如：final double MY_PI = 3.14;
如果某个成员变量用final修饰后，没有set方法，并且必须初始化（可以显式赋值、或在初始化块赋值、实例变量还可以在构造器中赋值）
- 修饰成员变量
public final class Test {
public static int totalNumber = 5;
public final int ID;
public Test() {
ID = ++totalNumber; // 可在构造器中给final修饰的“变量”赋值
}
public static void main(String[] args) {
Test t = new Test();
System.out.println(t.ID);
}
}
- 修饰局部变量：
public class TestFinal {
public static void main(String[] args){
final int MIN_SCORE ;
MIN_SCORE = 0;
final int MAX_SCORE = 100;
MAX_SCORE = 200; //非法
}
}
- 错误演示：
class A {
private final String INFO = "atguigu"; //声明常量
public void print() {
//The final field A.INFO cannot be assigned
//INFO = "尚硅谷";
}
}
抽象类与抽象方法(或abstract关键字)
举例1：
随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。
举例2：
当我们声明一个几何图形类：圆、矩形、三角形类等，发现这些类都有共同特征：求面积、求周长、获取图形详细信息。那么这些共同特征应该抽取到一个公共父类中。但是这些方法在父类中又无法给出具体的实现，而是应该交给子类各自具体实现。那么父类在声明这些方法时，就只有方法签名，没有方法体，我们把没有方法体的方法称为抽象方法。Java语法规定，包含抽象方法的类必须是抽象类。
语法格式
- 抽象类：被abstract修饰的类。
- 抽象方法：被abstract修饰没有方法体的方法。
抽象类的语法格式
[权限修饰符] abstract class 类名{
}
[权限修饰符] abstract class 类名 extends 父类{
}
抽象方法的语法格式
[其他修饰符] abstract 返回值类型 方法名([形参列表]);
注意：抽象方法没有方法体
代码举例：
public abstract class Animal {
public abstract void eat()；
}
public class Cat extends Animal {
public void eat (){
System.out.println("小猫吃鱼和猫粮")；
}
}
public class CatTest {
public static void main(String[] args) {
// 创建子类对象
Cat c = new Cat();
// 调用eat方法
c.eat();
}
}
此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。
使用说明
-
抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。
-
抽象类中，也有构造方法，是供子类创建对象时，初始化父类成员变量使用的。
理解：子类的构造方法中，有默认的super()或手动的super(实参列表)，需要访问父类构造方法。
-
抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。
-
抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。
理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。
-
不能用abstract修饰变量、代码块、构造器；
-
不能用abstract修饰私有方法、静态方法、final的方法、final的类。
接口interface
接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。
引用数据类型：数组，类，枚举，接口，注解。
接口的声明格式
[修饰符] interface 接口名{
//接口的成员列表：
// 公共的静态常量
// 公共的抽象方法
// 公共的默认方法（JDK1.8以上）
// 公共的静态方法（JDK1.8以上）
// 私有方法（JDK1.9以上）
}
示例代码：
package com.atguigu.interfacetype;
public interface USB3{
//静态常量
long MAX_SPEED = 500*1024*1024;//500MB/s
//抽象方法
void in();
void out();
//默认方法
default void start(){
System.out.println("开始");
}
default void stop(){
System.out.println("结束");
}
//静态方法
static void show(){
System.out.println("USB 3.0可以同步全速地进行读写操作");
}
}
在JDK8.0 之前，接口中只允许出现：
（1）公共的静态的常量：其中public static final可以省略
（2）公共的抽象的方法：其中public abstract可以省略
理解：接口是从多个相似类中抽象出来的规范，不需要提供具体实现
在JDK8.0 时，接口中允许声明默认方法和静态方法：
（3）公共的默认的方法：其中public 可以省略，建议保留，但是default不能省略
（4）公共的静态的方法：其中public 可以省略，建议保留，但是static不能省略
在JDK9.0 时，接口又增加了：
（5）私有方法
除此之外，接口中没有构造器，没有初始化块，因为接口中没有成员变量需要动态初始化。
面试题
1、为什么接口中只能声明公共的静态的常量？
因为接口是标准规范，那么在规范中需要声明一些底线边界值，当实现者在实现这些规范时，不能去随意修改和触碰这些底线，否则就有“危险”。
例如：USB1.0规范中规定最大传输速率是1.5Mbps，最大输出电流是5V/500mA
USB3.0规范中规定最大传输速率是5Gbps(500MB/s)，最大输出电流是5V/900mA
例如：尚硅谷学生行为规范中规定学员，早上8:25之前进班，晚上21:30之后离开等等。
2、为什么JDK8.0 之后允许接口定义静态方法和默认方法呢？因为它违反了接口作为一个抽象标准定义的概念。
静态方法：因为之前的标准类库设计中，有很多Collection/Colletions或者Path/Paths这样成对的接口和类，后面的类中都是静态方法，而这些静态方法都是为前面的接口服务的，那么这样设计一对API，不如把静态方法直接定义到接口中使用和维护更方便。
默认方法：（1）我们要在已有的老版接口中提供新方法时，如果添加抽象方法，就会涉及到原来使用这些接口的类就会有问题，那么为了保持与旧版本代码的兼容性，只能允许在接口中定义默认方法实现。比如：Java8中对Collection、List、Comparator等接口提供了丰富的默认方法。（2）当我们接口的某个抽象方法，在很多实现类中的实现代码是一样的，此时将这个抽象方法设计为默认方法更为合适，那么实现类就可以选择重写，也可以选择不重写。
3、为什么JDK1.9要允许接口定义私有方法呢？因为我们说接口是规范，规范是需要公开让大家遵守的。
私有方法：因为有了默认方法和静态方法这样具有具体实现的方法，那么就可能出现多个方法由共同的代码可以抽取，而这些共同的代码抽取出来的方法又只希望在接口内部使用，所以就增加了私有方法。
接口的使用规则
使用接口的静态成员
接口不能直接创建对象，但是可以通过接口名直接调用接口的静态方法和静态常量。
package com.atguigu.interfacetype;
public class TestUSB3 {
public static void main(String[] args) {
//通过“接口名.”调用接口的静态方法 (JDK8.0才能开始使用)
USB3.show();
//通过“接口名.”直接使用接口的静态常量
System.out.println(USB3.MAX_SPEED);
}
}
类实现接口（implements）
接口不能创建对象，但是可以被类实现（implements ，类似于被继承）。
类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements关键字。
【修饰符】 class 实现类 implements 接口{
// 重写接口中抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
// 重写接口中默认方法【可选】
}
【修饰符】 class 实现类 extends 父类 implements 接口{
// 重写接口中抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
// 重写接口中默认方法【可选】
}
-
如果接口的实现类是非抽象类，那么必须
重写接口中所有抽象方法。 -
默认方法可以选择保留，也可以重写。
重写时，default单词就不要再写了，它只用于在接口中表示默认方法，到类中就没有默认方法的概念了
-
接口中的静态方法不能被继承也不能被重写
举例：
package com.atguigu.interfacetype;
public class MobileHDD implements USB3 {
//重写/实现接口的抽象方法，【必选】
public void out() {
System.out.println("读取数据并发送");
}
public void in(){
System.out.println("接收数据并写入");
}
//重写接口的默认方法，【可选】
//重写默认方法时，default单词去掉
public void end(){
System.out.println("清理硬盘中的隐藏回收站中的东西，再结束");
}
}
举例：
interface USB{ //
public void start() ;
public void stop() ;
}
class Computer{
public static void show(USB usb){
usb.start() ;
System.out.println("=========== USB 设备工作 ========") ;
usb.stop() ;
}
};
class Flash implements USB{
public void start(){ // 重写方法
System.out.println("U盘开始工作。") ;
}
public void stop(){ // 重写方法
System.out.println("U盘停止工作。") ;
}
};
class Print implements USB{
public void start(){ // 重写方法
System.out.println("打印机开始工作。") ;
}
public void stop(){ // 重写方法
System.out.println("打印机停止工作。") ;
}
};
public class InterfaceDemo{
public static void main(String args[]){
Computer.show(new Flash()) ;
Computer.show(new Print()) ;
c.show(new USB(){
public void start(){
System.out.println("移动硬盘开始运行");
}
public void stop(){
System.out.println("移动硬盘停止运行");
}
});
}
};
使用接口的非静态方法
- 对于接口的静态方法，直接使用“
接口名.”进行调用即可- 也只能使用“接口名."进行调用，不能通过实现类的对象进行调用
- 对于接口的抽象方法、默认方法，只能通过实现类对象才可以调用
- 接口不能直接创建对象，只能创建实现类的对象
package com.atguigu.interfacetype;
public class TestMobileHDD {
public static void main(String[] args) {
//创建实现类对象
MobileHDD b = new MobileHDD();
//通过实现类对象调用重写的抽象方法，以及接口的默认方法，如果实现类重写了就执行重写的默认方法，如果没有重写，就执行接口中的默认方法
b.start();
b.in();
b.stop();
//通过接口名调用接口的静态方法
// MobileHDD.show();
// b.show();
Usb3.show();
}
}
接口的多实现（implements）
之前学过，在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类能继承一个父类，同时实现多个接口。
实现格式：
【修饰符】 class 实现类 implements 接口1，接口2，接口3。。。{
// 重写接口中所有抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
// 重写接口中默认方法【可选】
}
【修饰符】 class 实现类 extends 父类 implements 接口1，接口2，接口3。。。{
// 重写接口中所有抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
// 重写接口中默认方法【可选】
}
接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。
定义多个接口：
package com.atguigu.interfacetype;
public interface A {
void showA();
}
package com.atguigu.interfacetype;
public interface B {
void showB();
}
定义实现类：
package com.atguigu.interfacetype;
public class C implements A,B {
@Override
public void showA() {
System.out.println("showA");
}
@Override
public void showB() {
System.out.println("showB");
}
}
测试类
package com.atguigu.interfacetype;
public class TestC {
public static void main(String[] args) {
C c = new C();
c.showA();
c.showB();
}
}
接口的多继承 （extends)
一个接口能继承另一个或者多个接口，接口的继承也使用 extends 关键字，子接口继承父接口的方法。
定义父接口：
package com.atguigu.interfacetype;
public interface Chargeable {
void charge();
void in();
void out();
}
定义子接口：
package com.atguigu.interfacetype;
public interface UsbC extends Chargeable,USB3 {
void reverse();
}
定义子接口的实现类：
package com.atguigu.interfacetype;
public class TypeCConverter implements UsbC {
@Override
public void reverse() {
System.out.println("正反面都支持");
}
@Override
public void charge() {
System.out.println("可充电");
}
@Override
public void in() {
System.out.println("接收数据");
}
@Override
public void out() {
System.out.println("输出数据");
}
}
所有父接口的抽象方法都有重写。
方法签名相同的抽象方法只需要实现一次。
接口与实现类对象构成多态引用
实现类实现接口，类似于子类继承父类，因此，接口类型的变量与实现类的对象之间，也可以构成多态引用。通过接口类型的变量调用方法，最终执行的是你new的实现类对象实现的方法体。
接口的不同实现类：
package com.atguigu.interfacetype;
public class Mouse implements USB3 {
@Override
public void out() {
System.out.println("发送脉冲信号");
}
@Override
public void in() {
System.out.println("不接收信号");
}
}
package com.atguigu.interfacetype;
public class KeyBoard implements USB3{
@Override
public void in() {
System.out.println("不接收信号");
}
@Override
public void out() {
System.out.println("发送按键信号");
}
}
测试类
package com.atguigu.interfacetype;
public class TestComputer {
public static void main(String[] args) {
Computer computer = new Computer();
USB3 usb = new Mouse();
computer.setUsb(usb);
usb.start();
usb.out();
usb.in();
usb.stop();
System.out.println("--------------------------");
usb = new KeyBoard();
computer.setUsb(usb);
usb.start();
usb.out();
usb.in();
usb.stop();
System.out.println("--------------------------");
usb = new MobileHDD();
computer.setUsb(usb);
usb.start();
usb.out();
usb.in();
usb.stop();
}
}
内部类（InnerClass)
什么是内部类
将一个类A定义在另一个类B里面，里面的那个类A就称为内部类（InnerClass），类B则称为外部类（OuterClass）。
为什么要声明内部类呢
总的来说，遵循高内聚、低耦合的面向对象开发总原则。便于代码维护和扩展。
具体来说，当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，不在其他地方单独使用，那么整个内部的完整结构最好使用内部类。而且内部类因为在外部类的里面，因此可以直接访问外部类的私有成员。
内部类的分类
根据内部类声明的位置（如同变量的分类），我们可以分为：
（1）成员内部类：
- 静态成员内部类
- 非静态成员内部类
（2）局部内部类
- 有名字的局部内部类
- 匿名的内部类
成员内部类
概述
如果成员内部类中不使用外部类的非静态成员，那么通常将内部类声明为静态内部类，否则声明为非静态内部类。
语法格式：
[修饰符] class 外部类{
[其他修饰符] [static] class 内部类{
}
}
成员内部类的使用特征，概括来讲有如下两种角色：
- 成员内部类作为
类的成员的角色：- 和外部类不同，Inner class还可以声明为private或protected；
- 可以调用外部类的结构
- Inner class 可以声明为static的，但此时就不能再使用外层类的非static的成员变量；
- 成员内部类作为
类的角色：- 可以在内部定义属性、方法、构造器等结构
- 可以声明为abstract类 ，因此可以被其它的内部类继承
- 可以声明为final的
- 编译以后生成OuterClass$InnerClass.class字节码文件（也适用于局部内部类）
注意点：
-
非static的成员内部类中的成员不能声明为static的，只有在外部类或static的成员内部类中才可声明static成员。
-
外部类访问成员内部类的成员，需要“内部类.成员”或“内部类对象.成员”的方式
-
成员内部类可以直接使用外部类的所有成员，包括私有的数据
-
当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态的
具体来讲，内容如下。
静态成员内部类
静态成员内部类用static修饰，它的特点：
- 和其他类一样，它只是定义在外部类中的另一个完整的类结构
- 可以继承自己的想要继承的父类，实现自己想要实现的父接口们，和外部类的父类和父接口无关
- 可以在静态内部类中声明属性、方法、构造器等结构，包括静态成员
- 可以使用abstract修饰，因此它也可以被其他类继承
- 可以使用final修饰，表示不能被继承
- 编译后有自己的独立的字节码文件，只不过在内部类名前面冠以外部类名和$符号。
- 和外部类不同的是，它可以允许四种权限修饰符：public，protected，缺省，private
- 外部类只允许public或缺省的
- 只可以在静态内部类中使用外部类的
静态成员- 在静态内部类中不能使用外部类的非静态成员
- 如果在内部类中有变量与外部类的静态成员变量同名，可以使用“外部类名."进行区别
- 在外部类的外面不需要通过外部类的对象就可以创建静态内部类的对象（通常应该避免这样使用）
其实严格的讲（在James Gosling等人编著的《The Java Language Specification》）静态内部类不是内部类，而是类似于C++的嵌套类的概念，外部类仅仅是静态内部类的一种命名空间的限定名形式而已。所以接口中的内部类通常都不叫内部类，因为接口中的内部成员都是隐式是静态的（即public static)。例如：Map.Entry。
非静态成员内部类
没有static修饰的成员内部类叫做非静态内部类。非静态内部类的特点：
-
和其他类一样，它只是定义在外部类中的另一个完整的类结构
- 可以继承自己的想要继承的父类，实现自己想要实现的父接口们，和外部类的父类和父接口无关
- 可以在非静态内部类中声明属性、方法、构造器等结构，但是不允许声明静态成员，但是可以继承父类的静态成员，而且可以声明静态常量。
- 可以使用abstract修饰，因此它也可以被其他类继承
- 可以使用final修饰，表示不能被继承
- 编译后有自己的独立的字节码文件，只不过在内部类名前面冠以外部类名和$符号。
-
和外部类不同的是，它可以允许四种权限修饰符：public，protected，缺省，private
- 外部类只允许public或缺省的
-
还可以在非静态内部类中使用外部类的所有成员，哪怕是私有的
-
在外部类的静态成员中不可以使用非静态内部类
- 就如同静态方法中不能访问本类的非静态成员变量和非静态方法一样
-
在外部类的外面必须通过外部类的对象才能创建非静态内部类的对象（通常应该避免这样使用）
- 如果要在外部类的外面使用非静态内部类的对象，通常在外部类中提供一个方法来返回这个非静态内部类的对象比较合适
- 因此在非静态内部类的方法中有两个this对象，一个是外部类的this对象，一个是内部类的this对象
实例化静态内部类
外部类名 变量1 = new 外部类();
外部类名.非静态内部类名 变量 = 变量1.new 非静态内部类名();
变量.非静态成员();
- 实例化非静态内部类
外部类名.静态内部类名 变量 = 外部类名.静态内部类名();
变量.非静态成员();
package com.atguigu.inner.member;
public class TestMemberInnerClass {
public static void main(String[] args) {
Outer.outMethod();
System.out.println("-----------------------");
Outer out = new Outer();
out.outFun();
System.out.println("####################################");
Outer.Inner.inMethod();
System.out.println("------------------------");
//实例化静态内部类
Outer.Inner inner = new Outer.Inner();
inner.inFun();
System.out.println("####################################");
//实例化非静态内部类
Outer outer = new Outer();
// Outer.Nei nei = outer.new Nei();
Outer.Nei nei = out.getNei();
nei.inFun();
}
}
class Outer{
private static String a = "外部类的静态a";
private static String b = "外部类的静态b";
private String c = "外部类对象的非静态c";
private String d = "外部类对象的非静态d";
static class Inner{
private static String a ="静态内部类的静态a";
private String c = "静态内部类对象的非静态c";
public static void inMethod(){
System.out.println("Inner.inMethod");
System.out.println("Outer.a = " + Outer.a);
System.out.println("Inner.a = " + a);
System.out.println("b = " + b);
// System.out.println("c = " + c);//不能访问外部类和自己的非静态成员
// System.out.println("d = " + d);//不能访问外部类的非静态成员
}
public void inFun(){
System.out.println("Inner.inFun");
System.out.println("Outer.a = " + Outer.a);
System.out.println("Inner.a = " + a);
System.out.println("b = " + b);
System.out.println("c = " + c);
// System.out.println("d = " + d);//不能访问外部类的非静态成员
}
}
class Nei{
private String a = "非静态内部类对象的非静态a";
private String c = "非静态内部类对象的非静态c";
public void inFun(){
System.out.println("Nei.inFun");
System.out.println("Outer.a = " + Outer.a);
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("Outer.c = " + Outer.this.c);
System.out.println("c = " + c);
System.out.println("d = " + d);
}
}
public static void outMethod(){
System.out.println("Outer.outMethod");
System.out.println("a = " + a);
System.out.println("Inner.a = " + Inner.a);
System.out.println("b = " + b);
// System.out.println("c = " + c);
// System.out.println("d = " + d);
Inner in = new Inner();
System.out.println("in.c = " + in.c);
}
public void outFun(){
System.out.println("Outer.outFun");
System.out.println("a = " + a);
System.out.println("Inner.a = " + Inner.a);
System.out.println("b = " + b);
System.out.println("c = " + c);
System.out.println("d = " + d);
Inner in = new Inner();
System.out.println("in.c = " + in.c);
}
public Nei getNei(){
return new Nei();
}
}
局部内部类
语法格式：
【修饰符】 class 外部类{
【修饰符】 返回值类型 方法名(【形参列表】){
【final/abstract】 class 内部类{
}
}
}
局部内部类的特点：
- 和外部类一样，它只是定义在外部类的某个方法中的另一个完整的类结构
- 可以继承自己的想要继承的父类，实现自己想要实现的父接口们，和外部类的父类和父接口无关
- 可以在局部内部类中声明属性、方法、构造器等结构，但不包括静态成员，除非是从父类继承的或静态常量
- 可以使用abstract修饰，因此它也可以被同一个方法的在它后面的其他内部类继承
- 可以使用final修饰，表示不能被继承
- 编译后有自己的独立的字节码文件，只不过在内部类名前面冠以外部类名、$符号、编号。
- 这里有编号是因为同一个外部类中，不同的方法中存在相同名称的局部内部类
- 和成员内部类不同的是，它前面不能有权限修饰符等
- 局部内部类如同局部变量一样，有作用域
- 局部内部类中是否能访问外部类的非静态的成员，取决于所在的方法
- 局部内部类中还可以使用所在方法的局部常量，即用final声明的局部变量
- JDK1.8之后，如果某个局部变量在局部内部类中被使用了，自动加final
- 为什么在局部内部类中使用外部类方法的局部变量要加final呢？考虑生命周期问题。
举例：
package com.atguigu.inner.local;
public class TestLocalInner {
public static void main(String[] args) {
Runner runner = Outer.getRunner();
runner.run();
System.out.println("-------------------");
Outer.outMethod();
System.out.println("-------------------");
Outer out = new Outer();
out.outTest();
}
}
class Outer{
private static String a = "外部类的静态变量a";
private String b = "外部类对象的非静态变量b";
public static void outMethod(){
System.out.println("Outer.outMethod");
final String c = "局部变量c";
class Inner{
public void inMethod(){
System.out.println("Inner.inMethod");
System.out.println("out.a = " + a);
// System.out.println("out.b = " + b);//错误的，因为outMethod是静态的
System.out.println("out.local.c = " + c);
}
}
Inner in = new Inner();
in.inMethod();
}
public void outTest(){
class Inner{
public void inMethod(){
System.out.println("out.a = " + a);
System.out.println("out.b = " + b);//可以，因为outTest是非静态的
}
}
Inner in = new Inner();
in.inMethod();
}
public static Runner getRunner(){
class LocalRunner implements Runner{
@Override
public void run() {
System.out.println("LocalRunner.run");
}
}
return new LocalRunner();
}
}
interface Runner{
void run();
}
匿名内部类
当我们在开发过程中，需要用到一个抽象类的子类的对象或一个接口的实现类的对象，而且只创建一个对象，而且逻辑代码也不复杂。那么我们原先怎么做的呢？
（1）编写类，继承这个父类或实现这个接口
（2）重写父类或父接口的方法
（3）创建这个子类或实现类的对象
这里，因为考虑到这个子类或实现类是一次性的，那么我们“费尽心机”的给它取名字，就显得多余。那么我们完全可以使用匿名内部类的方式来实现，避免给类命名的问题。
new 父类(【实参列表】){
重写方法...
}
//()中是否需要【实参列表】，看你想要让这个匿名内部类调用父类的哪个构造器，如果调用父类的无参构造，那么()中就不用写参数，如果调用父类的有参构造，那么()中需要传入实参
new 父接口(){
重写方法...
}
//()中没有参数，因为此时匿名内部类的父类是Object类，它只有一个无参构造
匿名内部类是没有名字的类，因此在声明类的同时就创建好了唯一的对象。
注意：
匿名内部类是一种特殊的局部内部类，只不过没有名称而已。所有局部内部类的限制都适用于匿名内部类。例如：
- 在匿名内部类中是否可以使用外部类的非静态成员变量，看所在方法是否静态
- 在匿名内部类中如果需要访问当前方法的局部变量，该局部变量需要加final
思考：这个对象能做什么呢？
（1）使用匿名内部类的对象直接调用方法
interface A{
void a();
}
public class Test{
public static void main(String[] args){
new A(){
@Override
public void a() {
System.out.println("aaaa");
}
}.a();
}
}
（2）通过父类或父接口的变量多态引用匿名内部类的对象
interface A{
void a();
}
public class Test{
public static void main(String[] args){
A obj = new A(){
@Override
public void a() {
System.out.println("aaaa");
}
};
obj.a();
}
}
（3）匿名内部类的对象作为实参
interface A{
void method();
}
public class Test{
public static void test(A a){
a.method();
}
public static void main(String[] args){
test(new A(){
@Override
public void method() {
System.out.println("aaaa");
}
});
}
}
举例：
public class ProductTest {
public static void main(String[] args) {
TestProduct tp = new TestProduct();
Product p = tp.getProduct();
System.out.println(p.getName());
System.out.println(p.getPrice());
// ----------------------
tp.showProduct(p);
// ------------------------
tp.showProduct(new Product() {// 创建了一个匿名类的对象。
public int getPrice() {
return 7899;
}
public String getName() {
return "iphone5s-土豪金";
}
});
}
public Product getProduct() {
// 创建了一个局部内部类的对象
// class MyProduct implements Product{
//
// @Override
// public int getPrice() {
// // TODO Auto-generated method stub
// return 3899;
// }
//
// @Override
// public String getName() {
// // TODO Auto-generated method stub
// return "ipad air";
// }
//
// }
// return new MyProduct();
return new Product() {// 创建了一个匿名内部类的对象。
public int getPrice() {
return 7899;
}
public String getName() {
return "iphone5s-土豪金";
}
};
}
public void showProduct(Product p) {
System.out.println(p.getName());
System.out.println(p.getPrice());
}
}
interface Product {
public abstract int getPrice();
public abstract String getName();
}