十一、类和对象

• 类（设计图）：是对象共同特征
• 对象：是真实存在的具体东西

一、如何定义类

格式

public class 类名{
	1、成员变量
	2、成员方法
	3、构造器
	4、代码块
	5、内部类
}

注意

• 类名首字母建议大写，需要见名知意，驼峰模式
• 一个java文件中可以定义多个class类，且只能一个类是public修饰，而且public修饰的类名必须成为代码文件名
• 成员变量的完整定义格式：修饰符 数据类型 变量名称 = 初始化值；一般无需指定初始化值，存在默认值

二、static

static表示静态，是Java中的一个修饰符，可以修饰成员方法，成员变量

• 被static修饰的成员变量，叫做静态变量

  • 特点：
    • 被该类的所有对象调用
  • 调用方式
    • 类名调用（推荐）
    • 对象名调用

• 被static修饰的成员方法，叫做静态方法

  • 特点
    • 多用在测试类和工具类中
    • JavaBean类中很少会有

  总结

  • 静态方法中没有this关键字
  • 静态方法中，只能访问静态
  • 非静态方法可以访问所有

三、封装

1、private关键字

• 是一个权限修饰符
• 可以修饰成员（成员变量和成员方法）
• 被private修饰的成员只能在本类中才能访问

2、public 关键字

• public 是最宽松的访问修饰符，修饰的成员可以被任何类访问。
• 被 public 修饰的成员可以被同一个包中的类、不同包中的类、甚至是不同项目中的类访问。
• 通常用于对外提供公共接口，或者是需要广泛访问的成员。

3、protected 关键字

• protected 修饰的成员只能被同一个包中的类或者子类访问。
• 在不同包中的类中，只能通过继承关系来访问被 protected 修饰的成员。
• 通常用于实现继承机制中，子类可以访问父类的 protected 成员，但是其他类无法访问。

4、默认访问修饰符

• 如果不使用任何关键字修饰成员（即不使用 public、protected 或 private 关键字），则成员具有默认访问权限。
• 默认访问权限的成员可以被同一个包中的类访问，但是无法被其他包中的类访问。
• 在 Java 中，默认访问权限与包访问权限是等价的。
• 通常用于实现包内部的成员，提供给同一个包中的其他类使用。

四、继承

• Java中提供了一个关键字extends，用这个关键字，我们可以让一个类和另一个类建立继承关系

  public class Student extends Person {}

• Student称为子类（派生类），Person称为父类（基类或超类）

1、特点

1. Java只能单继承，不支持多继承，但支持多层继承
2. 多层继承：子类A继承父类B，父类B可以继承父类C
3. 每一个类都直接或者间接的继承Object

2、构造方法

• 子类中的构造方法不会被子类继承
• 子类中所有的构造方法先默认访问父类中的无参构造，再执行自己

使用

• 子类构造方法的第一句默认都是：super()，不写也存在，且必须在第一行

• 如果想调用父类的有参构造，必须手动写super进行调用

  super();
  super(name,age);

3、重写

当父类的方法不能满足子类现在的需求，需要进行方法重写

（1）书写格式

在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法

（2）@Override重写注解

1. @Override是放在重写后的方法上，校验子类重写时语法是否正确
2. 加上注解后如果有红色波浪线，表示语法错误
3. 建议重写方法都加@Override，代码安全、优雅

五、多态

1、什么是多态

同类型的对象，表现出的不同形态

2、多态的表现形式

父类类型 对象名称 = 子类对象;

3、多态的前提

• 有继承关系
• 有父类引用指向子类对象
• 有方法重写

4、多态的优势

• 在多态形式下，右边对象可以实现解耦合，便于扩展和维护

  Person p = new Student();
  p.word();		//业务逻辑发生改变时，后续代码无需修改

• 定义方法的时候，使用父类型作为参数，可以接收所有子类对象，提现多态的扩展性与便利

六、抽象方法

• 抽象方法：将共性的行为（方法）抽取到父类之后，由于每一个子类执行的内容是不一样，所以，在父类中不能确定具体的方法体
• 抽象类：如果一个类中存在抽象方法，那么类就必须声明为抽象类

1、抽象方法

格式

public abstract 返回值类型 方法名(参数列表);

2、抽象类

public abstract class 类名{}

3、注意事项

• 抽象类不能实例化
• 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
• 可以有构造方法
• 抽象类的子类
  • 要么重写抽象类的所有抽象方法
  • 要么是抽象类

七、接口

1、定义和使用

• 接口用关键字interface来定义

  public interface 接口名 {}

• 接口不能实例化

• 接口和类之间是实现关系，通过implements关键字表示

  public class 类名 implements 接口名 {}

• 接口的子类（实现类）

  • 要么重写接口的所有抽象方法
  • 要么是抽象类

• 接口和类的实现关系，可以单实现，也可以多实现

  public class 类名 implements 接口名1,接口名2 {}

• 实现类还可以在继承一个类的同时实现多个接口

  public class 类名 extends 父类 implements 接口名1,接口名2 {}

2、成员变量

只能是常量，默认修饰符

public static final

3、构造方法

不存在

4、成员方法

只能是抽象方法，默认修饰符

public abstract

八、内部类

1、什么是内部类

在一个类的里面，再定义一个类

在A类的内部定义B类，B类就被称为内部类

public class Outer {
    public class Inner {       
    }
}

2、创建方式

（1）直接创建

格式：外部类名.内部类名 对象名= 外部类对象.内部类对象;

Outer.Inner oi = new Outer().new Inner();

（2）方法返回

外部类编写方法，对外提供内部类对象（private）

public class Outer {
    private class Inner {       
    }
    
    public Inner getInstance(){
        return new Inner();
    }
}

九、静态内部类

静态内部类只能访问外部类中的静态变量和静态方法

如果需要访问非静态的需要创建对象

public class Car {				//外部类
	String carName;
    int carAge;
    int carColor;
    
    static class Engine {		//静态内部类
        String engineName;
        int engineAge;
    }
}

1、创建方式

格式

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

2、静态内部类调用外部类成员变量

public class Car {				//外部类
	String carName;
    
    static class Engine {		//静态内部类
        public void show(){
            Car car = new Car();
            //car.carName
        }
    }
}

3、静态内部调用静态成员方法

Outer

public class Outer {
    static class Inner {  
        public static void show(){
        }
    }
}

内部类调用show()

（1）方式一

Outer.Inner oi = new Outer.Inner();
oi.show();

（2）方式二

Outer.Inner.show();

十、匿名内部类

格式

new 类名或者接口名(){
	重写方法;
}