一、面向对象
- 对象：对象是类的实例，万事万物都是对象。
- 类：对具有相同属性和行为
方法的对象的抽象。
二、特征
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：回到某个模块开始。
