一、面向对象

• 对象：对象是类的实例，万事万物都是对象。
• 类：对具有相同属性和行为 方法 的对象的抽象。

二、特征

1、封装：将客观存在的事物抽象成类，并且类内存在的数据和方法只给一定的对象访问，提高了安全性。
2、继承：将多个具有相同属性和方法的类，高度抽象出一个拥有共性的父类，共性可以从父类中继承，个性可以再本类中体现。
3、多态：一个类实例的相同方法在不同情形有不同表现形式.

        /**
         * Animal是Cat的父类，在实例化过程中可以有不同的及结果
         */
        Animal a=st.new Cat();
        Cat c=st.new Cat();

三、Java关键字
1、public：公有成员，可以被任意成员访问。
2、private：私有成员，只能在该类内部被访问。
3、protect：保护成员，可以在该类的子类或父类中进行访问。
4、static:定义完成后就已经存在，不需要对象的调用，可以直接通过类名进行调用。

public class Test {
    public String a="a";
    public final static String b ="b";
    {
        System.out.println("我是普通方法块内容！");
    }
    static{
        System.out.println("我是静态方法块内容！");
    }
    public  Test(){
        System.out.println("我是构造器方法内容！");
    }
    
    public static void main(String[] args)
    {
        Test t = new Test();
        System.out.println(t.a);
        System.out.println(t.b);
        /*
         * 我是静态方法块内容！
            我是普通方法块内容！
            我是构造器方法内容！
            a
            b
         */
        System.out.println(Test.b);
    }
}

5、abstract：用来定义类或是方法，在修饰类时，此类不可以被实例化，只有通过子类继承，覆盖父类中的抽象方法后，才可以实例化；在修饰方法时，抽象方法只需要声明，子类继承后再去实现方法。

package test_keyword;

public class AbstractTest {
    /**
     *定义一个Animal抽象类，其中包括抽象方法eat()和普通方法sleep()
     *子类Cat继承父类，重写父类中的抽象方法，才可以被实例化后调用
     *普通方法可以直接调用
     */
    abstract class Animal{
        public abstract void eat();
        public void sleep(){
            System.out.println("睡觉！！");
        }
    }
    class Cat extends Animal{
        //重写父类中的抽象方法
        public void eat(){
            System.out.println("吃饭！！");
        }
    }
    public static void main(String[] args) {
        AbstractTest at=new AbstractTest();
        Cat c=at.new Cat();
        c.eat();
        //直接调用父类方法
        c.sleep();
        
    }
}

6、this：对象创建后，就会产生一个指向自己的指针“this”。只能在非静态方法内使用。

    /**
    *以重写equals方法为例，判断两个对象是否相等
    *以此判断传入对象的属性与自身的属性是否相同   
    **/
    
    public boolean equals(Course other){
        if(this.id.equals(other.id) && this.name.equals(other.name)){
            return true;
        }
        return false;
    }

7、super：用在子类中，访问直接父类中被屏蔽的成员变量或是成员方法。

    class Animal{
        public int age;
        public void show(){
            age=11;
            System.out.println("Animal年龄为："+age);
        }
    }
    class Cat extends Animal{
        public int age;
        public void show(){
            super.show();//调用父类方法
            age=12;
            System.out.println("Cat年龄为："+age);
            System.out.println(super.age);//调用父类的age值
            System.out.println(age);
            
        }
    }
    /**
     * Animal年龄为：11
     * Cat年龄为：12
     *  11
     *  12
     * @param args
     */

8、break：跳出摸一个模块。
9、continue：回到某个模块开始。