面向对象

类是抽象的概念, 对象是具体的实例

Java类及类成员

public class Person {
    private String name;
    private Integer age;

    static {
        System.out.println("静态代码块, 只在类加载的时候执行一次");
    }

    {
        System.out.println("代码块, 每次new对象都会执行");
    }


    /**
     * 无参构造器
     */
    public Person() {
    }

    /**
     * 含参构造器
     *
     * @param name 姓名
     * @param age  年龄
     */
    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public Person(Person p) {
//        为了展示效果, 添加一个后缀
        this.name = p.getName() + "_copy";
        this.age = p.getAge();
    }

    /**
     * 方法
     *
     * @return 获取name属性值
     */
    public String getName() {
        return name;
    }

    public Integer getAge() {
        return age;
    }

    /**
     * 实现链式编程, 设置姓名
     *
     * @param name 输入的姓名字符串
     * @return 当前对象
     */
    public Person setName(String name) {
        this.name = name;
        return this;
    }

    public Person setAge(Integer age) {
        this.age = age;
        return this;
    }


    public static void main(String[] args) {
        Person p1 = new Person("Tom", 18);
//        给对象p1取别名
        Person p2 = p1;
        p2.setName("June");
        System.out.println(p1.getName());

//        使用该方法需要提供一个构造器
        Person p3 = new Person(p1);
        System.out.println(p3.getName());

    }
}

权限修饰符

修饰符	类内部	同一个包	不同包的子类	同一个工程
private	√
default	√	√
protected	√	√	√
public	√	√	√	√

继承性

无论对于属性和还是方法, 默认都省略了this.方法名/属性, 如果想要使用父类中的方法, 则使用super.方法名/属性

如果子类和父类有同名属性或方法, 二者都会被保留下来, 只是调用方式不同.

使用this调用子类中的属性或方法, 如果子类中的属性或方法是继承于父类的, 则等同于使用super调用父类中的该属性或方法. 只有在调用同名属性或方法时, this和super的调用结果才有区别

多态性

父类的引用指向子类的对象, 但在调用子类和父类的重名方法时, 实际执行的是子类中的方法, 并且不能执行子类中特有的方法

比如排序, 不同的子类中具体实现排序的方法可能不同, 在写父类的时候只需要关注宏观把握, 具体实现由实际生成的子类去按照对应的特性优化实现

多态性方便实现虚拟方法的调用, 在父类中定义虚拟方法, 在子类中实现

List<Integer> list = new ArrayList<>();

多态性的优点

可以和函数调用进行类比, 使用函数相比于代码写死的优点是可以根据传入的形参得到不同的结果. 而多态性的优点是可以将父类作为一种变量类型, 传入不同的子类从而去执行不同的方法, 得到不同的运行结果

public abstract class Animal {
    abstract void shout();
    abstract void eat();
}

public class Dog extends Animal {
    @Override
    void shout() {
        System.out.println("汪汪汪");
    }

    @Override
    void eat() {
        System.out.println("狗吃狗粮");
    }
}

public class Cat extends Animal {
    @Override
    void shout() {
        System.out.println("喵喵喵");
    }

    @Override
    void eat() {
        System.out.println("猫吃猫粮");
    }
}

public class TestAnimal {
    void func(Animal animal) {
//        使用父类对象实现虚拟方法的统一
        animal.shout();
        animal.eat();
    }

    public static void main(String[] args) {
        TestAnimal testAnimal = new TestAnimal();
//        多态性的使用, 将子类当作参数传递
        testAnimal.func(new Dog());
        testAnimal.func(new Cat());
    }
}

强制类型转换(向下转型)

由于多态性中使用父类引用指向子类的对象, 因此不能直接调用子类对象中的特有方法, 但是实际上这些方法是存在于子类对象中的. 向下转型则是为了实现该功能

instanceof: 用于判断一个对象实例本质上是否属于某个类, 一般用于强制类型转换之前进行判断

JDK中主要的包

JDK包	功能
java.lang	核心类, 包含String、Math、System、Thread等常用功能
java.net	执行与网络相关的操作
java.io	提供多种输入/输出功能
java.util	工具类, 例如日期时间, 系统特性, 接口的集合框架等
java.text	java格式化相关的类
java.sql	进行JDBC数据库编程相关的类
java.awt	用于构建图形化用户界面

MVC设计模式

将整个程序分为三个层次: 视图模型层、控制器层、数据模型层

模型层model: 主要处理数据

• 数据对象封装: model.bean/domain
• 数据库操作类: model.dao
• 数据库: model.db

视图层view: 显示数据

• 相关工具类: view.utils
• 自定义类: view.ui

控制器层controller: 处理业务逻辑

• 应用界面相关: controller.activity
• 存放fragment: controller.fragment
• 显示列表的适配器: controller.adapter
• 服务相关: controller.service
• 抽取的基类: controller.base