java面向对象

Java的核心思想就是OOP(Object-Oriented Programming，面向对象编程)

面向对象

一、三大特点：

• 封装
• 继承
• 多态

二、创建与初始化对象：

• 使用new关键字创建对象的时候，除了分配内存空间，还会给创建好的对象进行默认的初始化以及调用类中的构造器
• 类中的构造器也叫构造方法，是在进行new对象时必须要调用的，new的本质就是在调用构造方法
• 构造器有两个特点：必须和类名相同；必须没有返回类型，也不能写void
• 如果定义了有参构造，想要调用无参构造时，那么必须显示无参构造
• idea开发工具里面有个快捷键：Alt+Insert ，可以生成有参或无参构造方法

三、封装：

• 高内聚，低耦合：高内聚就是类的内部数据操作由类自己完成，不允许外部干涉；低耦合就是暴露少量的端口给外部使用
• 应禁止直接访问对象中数据的实际表示，应通过操作接口来访问
• 属性私有，使用private修饰属性(字段)

四、继承(extends)：

• Java中只有单继承，没有多继承
• 继承是类和类之间的关系；除此之外，类和类之间的关系还有依赖、组合、聚合等
• 继承关系的两个类，一个是子类(派生类)，一个是父类(基类)；子类继承父类，通过关键字extends实现；父类里面私有的属性及方法是不能被继承的
• Java中所有的类都默认直接或间接继承Object类

五、super：

• super和this区别：this表示当前类，super表示当前类的父类；this没有继承也可以使用，super只能在继承时才能调用
• super必须只能出现在子类的方法或构造方法中
• 子类继承父类时，子类的构造方法会默认调用父类的构造方法，并且父类的构造方法必须在子类构造方法的第一行(默认是隐藏的)
• super和this不能同时调用构造方法

六、重写(override)：

• 重写是方法的重写，与属性无关
• 重写的前提：需要有继承关系，子类重写父类的方法
• 方法名称必须相同，参数列表必须相同，方法体不同
• 修饰符的范围可以扩大但不能缩小：public>protected>default>private
• 抛出的异常的范围可以缩小但不能扩大
• 不能被重写的方法：static修饰的方法，static修饰的方法属于类，不属于实例；final修饰的方法；private修饰的方法；

七、多态：

• 多态存在条件：有继承关系；子类重写父类方法；父类引用指向子类对象
• 多态是方法多态，属性没有多态
• 子类转为父类，不需要强制转换；父类转换为子类，需要强制转换
• instanceof(引用类型转换)： x instanceof y；x和y必须要有联系，它们两个之间是父子关系；若没有联系，编译就会报错
• 当前类中，非静态方法可以调用静态方法，但静态方法不能调用非静态方法
• 通过final修饰的类是不能被继承的，是没有子类的

public class Person {
    {
        // 代码块(匿名代码块)：在创建Person对象的时候创建的，在构造器之前
        System.out.println("匿名代码块");
    }

    static{
        // 静态代码块
        System.out.println("静态代码块");
    }

    public Person() {
        System.out.println("构造器代码块");
    }

    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("================");
        Person person1 = new Person();
    }
}

// 执行main方法，输出结果为：
静态代码块
匿名代码块
构造器代码块
================
匿名代码块
构造器代码块

// 静态代码块只执行一次

八、抽象类：

• 由abstract修饰符修饰
• abstract可以修饰类，修饰的类叫抽象类；也可以修饰方法，修饰的方法叫抽象方法；
• 抽象类中可以没有抽象方法，但是有抽象方法的类必须声明为抽象类
• 抽象类不能使用new关键字来创建对象，它是需要子类来实现的
• 抽象方法：只有方法的声明，没有方法的实现，需要子类来实现
• 子类继承抽象类，必须要实现抽象类没有实现的抽象方法，否则子类也需要声明为抽象类

// 抽象类
public abstract class Person {
    // 抽象方法：之后方法名，没有方法的实现
    public abstract void eat();
}

public class Student extends Person{
    // 抽象类的所有方法被其子类所实现，除非子类也是抽象类，则不需要实现方法
    @Override
    public void eat() {
        System.out.println("吃饭!");
    }
}

九、接口：

• 类由class关键字声明；接口由interface关键字声明
• 普通的类只有具体的实现；抽象类有具体实现也有抽象方法(规范)；接口只有抽象方法(规范)
• 在接口里面，方法默认是public abstract修饰的，属性默认是public static final修饰的
• 接口都需要实现类，通过implements关键字
• 实现了接口的类，必须要重写接口里面的所有方法
• 一个类可以实现多个接口
• 接口中没有构造方法

// 接口
public interface Cat {
    void run();
}
public interface Dog {
    void jump();
}
// 接口的实现类
public class PetImpl implements Cat,Dog {
    @Override
    public void run() {
        System.out.println("跑");
    }

    @Override
    public void jump() {
        System.out.println("跳");
    }
}

十、内部类：

• 内部类就是在一个类内部再定义一个类；A类里面定义了一个B类，那么B类就是A类的内部类，而A类就是B类的外部类
• 内部类分为：成员内部类、静态内部类、局部内部类、匿名内部类
• 静态内部类是无法访问外部类的非静态属性的
• 一个java类中，只能有一个public class类，但可以有多个class类

public class Outer {
    private int id;

    public void out(){
        System.out.println("外部类方法");

        // 局部内部类：在方法里面定义的类
        class partInner{
        }
    }

    // 成员内部类
    public class Inner{
        public void in(){
            System.out.println("内部类方法");
        }

        // 获取外部类的私有属性
        public void getId(){
            System.out.println(id);
        }
    }

    // 静态内部类
    public static class Inner01{
    }
}

public class Demo1 {
    public static void main(String[] args) {
        Outer outer = new Outer();
        
        // 通过外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.getId();

        // 匿名内部类，不用将实例保存到变量中
        outer.new Inner().getId();
    }
}