Java（面向对象）

面向对象编程（oop）

• 面向编程的本质是：
  以类的方式组织代码，以对象的形式（封装）数据。

构造器

• 和类名相同
• 没有返回值
• 一个类即使什么都不写，也会存在一个方法
• 作用1：new 本质在调用构造器
• 作用2：初始化对象的值
• 注意点1：定义有参构造之后，如果想使用无参构造，需要显示的定义一个无参构造器
• 快捷键：alt+insert

封装

• 高内聚，低耦合
• 属性私有，get/set

继承

• 继承是类和类之间的一种关系，子类继承父类
• 子类继承父类的全部方法
• 类和类之间的关系还有依赖，组合，聚合等；
• CTRL+H 查看当前类的继承树
• Java中所有的类都默认继承object类
• 类只有单继承
• final修饰的类不能有子类
• this调用当前类的属性和方法
• super调用父类的属性和方法
  1 super调用父类的构造方法，必须在构造方法的第一个
  2 super 必须只能出现在子类的方法和构造方法中
  3 super和this不能同时调用构造方法
  4 this（）调用本类的构造
  5 super（）调用父类的构造

重写

• 重写，子类的方法和父类必须一致（方法名，参数列表），方法体不同
• 修饰符：范围可以扩大但不能缩小 public>protect>default>private
• 抛出的异常，范围，可以缩小，不能扩大
• 静态方法不能被重写
• 快捷键：alt+insert：override
• 子类重写了父类的方法，执行子类的方法
• 为什么 ：
  父类的功能子类不一定需要，或不一定满足

public class B {
    public static void test(){
        System.out.println("B=>test()");
    }
}

public class A extends B {
    public static void test(){
        System.out.println("A=>test()");
    }
}

public class A extends B {
    @Override
    public void test() {
        System.out.println("A=>test()");
    }
}

public static void main(String[] args) {
        A a = new A();
        a.test();
        //父类的引用指向了子类
        B b = new A();
        b.test();
    }

多态

• 即同一方法可以根据发送对象的不同而采用多种不同的行为方式
• 一个对象的实际类型是确定的，但可以指向对象的引用类型有很多（父类，有关系的类）
• 多态是方法的多态，属性没有多态
• 父类和子类，有联系 类型转换异常！
• 多态存在的条件：继承关系，方法重写，父类引用指向子类对象Father f1 = new Son();
• 无法重写：
  1 static 静态方法，属于类，不属于实例
  2 final 常量；
  3 private；

instanceof

• 判断new出来的对象所在类与instanceof右边类是否有关系

static

• static从属于类，随类一起加载
• 静态和非静态可以直接调用静态属性和方法
• 代码块

    //第二个执行，只执行一次
    //可以用来赋初始值
    {
        System.out.println("匿名代码块");
    }
    //第一个执行
    static{
        System.out.println("静态代码块");
    }
    //第三个执行
    public Student() {
        System.out.println("构造方法");
    }

导入包

• 静态导入包

import static java.lang.Math.random;
import java.lang.Math;

抽象类

• abstract
• 抽象方法，只有方法名，没有方法的实现
• 抽象类的所有抽象方法，继承了该抽象类的子类，都必须实现其方法，除非该子类也是一个抽象类
• 抽象类不能new，只能靠子类去实现它：约束！
• 抽象类可以写普通方法，但是抽象方法只能写在抽象类里
• 提高开发效率，增强程序的可扩展性

接口

• 普通类：只有具体实现
  抽象类：具体实现和规范（抽象方法）都有
  接口：只有规范。自己无法写方法
• 接口的本质是契约
• class 换成 interface
• 接口都需要有实现类
• 类 可以实现接口 implements 接口
• 实现了接口的类，就需要重写接口中的方法
• 利用接口实现多继承

public class UserServiceImpl implements UserService,TimeService { 
    @Override
    public void run(String name) {
    }

• 接口定义的都是常量public static final
• 接口中没有构造方法

内部类

• 内部类
• 静态内部类
• 成员内部类
• 方法类
• 接口类
• 。。。

public class Outer {
    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        public void getId(){
            System.out.println(id);
        }

ublic class Aplication {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.in();
        outer.out();
        inner.getId();
    }
}