自学javase的回顾（2/5）

继续回顾javase的知识，持续更新…

1、面向对象之封装

首先需要复习一下什么是面向对象？
面向对象就是面向具体的某一类的实例化的产物去处理事务。
创建对象之前要先构造一个类，类就是具有相同属性和方法的抽象成一种类。
类的语法：class 类名{
属性；
方法；
}

class Animal{
    String name;
    public static void run(){ 
    }
}

接下来就可以创建对象，创建对象的语法：类名 变量名=new 类名();

Animal dog=new Animal();

面向对象的三大特性之一：封装
封装的含义就是使类中的属性变的私有化，保护数据的安全，关键字是private。
被private修饰的属性，是无法被其他类访问和修改的。所以可以通过在本类写好访问和修改的方法，其他类间接的调用这个类的属性。

public class Test {
    public static void main(String[] args) {
        Animal dog=new Animal();
        dog.setName("阿黄");
        System.out.println(dog.getName());//阿黄
    }
}
class Animal{
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

构造方法：
它是一个比较特殊的方法，和其他方法不同，想要使用此方法必须调用new 类名(实际参数)，能够方便快捷的赋给属性值的方法。构造方法语法：[修饰符列表] 类名(形式参数){方法体;}

public class Test {
    public static void main(String[] args) {
        Animal dog=new Animal("阿黄");
        System.out.println(dog.getName());//阿黄
    }
}
class Animal{
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public Animal() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

注意：写出有参数的构造方法的同时，别忘了加上无参数的构造方法。

static关键字：
static被翻译成静态的，它能够使用在方法和属性上，被static修饰的方法和属性，被称为静态方法和静态变量，与之相反的是实例方法和实例变量。静态方法和静态变量都属于类的方法和属性。例如构建一个Person类，身高可以属于类的属性，那么高个子就是属于对象的属性。被static修饰的方法和属性，调用直接通过类名.方法/属性。

public class Test {
    public static void main(String[] args) {
        System.out.println(Person.name);//null
        Person.getName();//null
    }
}
class Person{
    static String name;
    public static String getName(){
        return name;
    }
}

static代码块：
语法：static{方法体;}写在类中，如果有多个就自上而下的执行，并且在类加载时只加载一次。

public class Test {
    public static void main(String[] args) {
        new Person();//类加载了
    }
}
class Person{
    String name;
    static {
        System.out.println("类加载了");
    }
}

实例代码块：类似于static代码块，它在创建对象的时候执行，只执行一次。

public class Test {
    public static void main(String[] args) {
        new Person();//对象创建了
    }
}
class Person{
    String name;
    {
        System.out.println("对象创建了");
    }
}

this关键字：
this代表这个的意思，它在类中的含义是本对象的属性和方法，出现在实例方法和构造方法（因为静态方法不需要创建对象），this()只能出现在构造方法第一行，类似于递归。在某些地方可以省略不写。但是在某些地方不能省略，例如形参和属性名相同时，就不能省略this。上述get属性()方法中的this就是不能省略的。

2、面向对象之继承

面向对象之继承：
顾名思义，继承就是类似于父亲的财产，儿子去继承。类之间也存在继承关系，其对象也存在继承关系。关键字：extends。只要没被private修饰过的都能够被继承。java中只能实现单继承，多继承不能实现。

public class Test {
    public static void main(String[] args) {
        Chinese zhangsan=new Chinese();
        zhangsan.speak();//People speaking
        zhangsan.name="张三";
        System.out.println(zhangsan.name);//张三
    }
}
class Person{
    String name;
    public void speak(){
        System.out.println("People speaking");
    }
}
class Chinese extends Person{
}

方法覆盖(方法重写)：
方法覆盖就是子类中继承父类的方法不能满足子类的需求时去重新写方法体。
条件1：返回类型、方法名和形式参数必须相同
条件2：两者必须有继承关系
条件3：修饰符访问权限不能更低，可以更高（例如父类中可以protected修饰，子类覆盖方法可以public修饰）（修饰符权限从高到低：public>protected>default>private）
条件4：子类不能比父类抛出更多异常

public class Test {
    public static void main(String[] args) {
        Chinese zhangsan=new Chinese();
        zhangsan.speak();//Chinese speaking
    }
}
class Person{
    String name;
    public void speak(){
        System.out.println("People speaking");
    }
}
class Chinese extends Person{
    @Override
    public void speak() {
        System.out.println("Chinese speaking");
    }
}

super关键字：
和this相同原理，this是调用本对象的方法和属性，super是调用父类的方法和属性。super()在构造方法中第一行有效，所以this()和super()在构造方法中不能并存，不能使用在静态方法中。

public class Test {
    public static void main(String[] args) {
        Chinese zhangsan=new Chinese("张三");
        System.out.println(zhangsan.name);//张三
    }
}
class Person{
    String name;
    public Person(String name) {
        this.name = name;
    }
}
class Chinese extends Person{
    public Chinese(String name) {
        super(name);
    }
}

注意：所有类的父类都是Object

3、面向对象之多态

面向对象之多态：
有了继承，才能有多态。多态是对不同的类拥有不同的形态做的诠释。
前提：继承、方法重写、父类的引用指向子类的对象
语法：父类名 变量名=new 子类名();

public class Test {
    public static void main(String[] args) {
        Person zhangsan=new Chinese();
        zhangsan.speak();//说中国话
        Person peter=new American();
        peter.speak();//说漂亮话
    }
}
class Person{
    String name;
    public void speak(){
        System.out.println("说话");
    }
}
class Chinese extends Person{
    @Override
    public void speak() {
        System.out.println("说中国话");
    }
}
class American extends Person{
    @Override
    public void speak() {
        System.out.println("说漂亮话");
    }
}

注意：编译时看左边，运行时看右边。如果类型错误，可以用instanceof判断是否属于这个类型，如果不属于，可以使用(想转到的类型)对象进行强制转换，但是相互转换必须有继承关系。

抽象类：
属于类的一种，这种类顾名思义，是一个抽象的类，抽象到没有具体方法的实现。
抽象类无法创建对象，是用来被子类继承的，关键字abrstract。
抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类。

public class Test {
    public static void main(String[] args) {
        Person zhangsan=new Chinese();
        zhangsan.speak();//说中国话
        Person peter=new American();
        peter.speak();//说漂亮话
    }
}
abstract class Person{//抽象类
    abstract public void speak();//抽象方法
}
class Chinese extends Person{
    @Override
    public void speak() {
        System.out.println("说中国话");
    }
}
class American extends Person{
    @Override
    public void speak() {
        System.out.println("说漂亮话");
    }
}

final关键字：
表示最终的、不可变的，一般修饰在类、引用、方法、变量上，修饰在变量上的时候，变量只可以赋值一次，并且不可修改。修饰在类上的时候，类不能被继承。修饰在方法上的时候，方法不能被覆盖。修饰在引用的时候，不能被重新引用，即不可修改保存的内存地址，和变量同理。

4、对象的内存图结构

5、接口

接口：
接口是一种完全抽象的，当一个类所有方法都是抽象的时候，这个类就可以写成接口，接口中不存在变量，但是存在常量，还有抽象方法，因为方法都是抽象和公开的，所以方法前public abstract可以省略不写，因为都是常量，所以常量前public static final也可以不写。接口之间可以有继承关系。如果一个类implement了接口，就必须现实接口中的抽象方法，一个类可以实现多个接口，就弥补了单继承的缺点，关键字：implement。

public class Test {
    public static void main(String[] args) {
        Person zhangsan=new Chinese();
        zhangsan.speak();//说中国话
        Person peter=new American();
        peter.speak();//说漂亮话
    }
}
interface Person{
    void speak();
}
class Chinese implements Person{
    final String name="zhangsan";
    @Override
    public void speak() {
        System.out.println("说中国话");
    }
}
class American implements Person{
    @Override
    public void speak() {
        System.out.println("说漂亮话");
    }
}

番外：什么是API？
它是应用程序编程接口。
每一个API都有一份编程文档。