面向对象是一种以事物为中心的编程思想，把构成问题事物分解成各个对象，描述某个事物在整个解决问题的步骤中的行为。
一.创建对象,变量，类中的方法，构造器
对象的类型 对象名=new 类的方法（）；Animal animal=new Animal（）；
变量是java程序的一个基本存储单位，也就是说，在java中要存储一个数据，必须将它容纳在一个变量之中。
方法：用来定义类的某种行为，很多时候被称为：成员方法。很多时候我们把执行的算法等放入方法中，这个过程是方法的定义。
方法的格式：Public void way([参数列表]){方法内容}----->访问修饰符 返回值类型 方法名([参数列表]){方法内容};
构造器：对对象进行初始化。例：public 类名（）{}；由此可见，构造器没有返回值，也不能被继承。
构造器的例1：public class Animal(){ 构造器例2：public class Animal(){ ------->主函数类中 public static void main(String[] arg){
int eyes; int eyes;
int foot; int foot; } Animal animal()=new Animal(2,4);
//在此处创建对象，写初始化值
public Animal(){ public Animal(int eyes,int foot){
eyes=2; this.eyes=eyes;
foot=4; this.foot=foot;
} System.out.println(eyes+" "+foot)}
}
以上两种例子所表达的主意图都是一样的，初始化属性，定义属性的初始化值。第一种方法是直接初始化值，而第二种是传参数进行修改初始化值。构造器中的括号里就是参数。一个类中可以有多个构造器（构造器的重载），区别这些构造器的方法就是构造其中的数据类型，个数的不同，几个构造器的数据类型相同，那么构造器中的数据个数就不能一样，或者是类型各不相同。在构造其中的数据的类型顺序是什么，在创建的对象中就应该传怎样顺序的数据去填写。
二.访问修饰符，类的封装
访问修饰符一般有：public，protected，private，无修饰符。
public：对外公开
protected：向子类和同一包中的类公开
private：私有，完全不公开。
无修饰符：向同一包中的类公开。
封装就是隐藏实现细节，将它private。
例：public class Animal(){ --->在主函数中访问私有属性:Animal animal=new Animal();
private int eyes; animal.setEyes(2);
public int getEyes(int eyes){int animal=getEyes();
//通过setter，getter方法访问eyes属性
return eyes;
}
public void setEyes()[
this.eyes=eyes;//this代表当前类的实例
}
}
封装的实现：修改属性的可见性来实现对属性的访问。为这些属性添加setter（赋值）和getter（取值），来对这些属性进行访问。在set和get中编写这些属性的存取限制。在主函数中创建对象之后用set对属性进行赋值。用get进行取值。
修饰符：abstract（抽象）可以修饰：类，成员方法（方法）。使用abstract修饰类表示此类为抽象类，抽象类不能被实例化（不能产生对象）。抽象方法没有方法体。抽象类可以没有抽象方法，但是有抽象方法，那么这个类一定被定义为抽象类。没有抽象构造方法，抽象类的构造器是正常的。抽象类可以含有具体方法。
final（终态）：可以修饰非抽象类，非抽象方法和变量。被final修饰的类，将不能被继承。被final修饰的方法， 将不能被子类重写。final修饰的变量必须赋值，并且不能再改变，也就是常量。final方法不能被重写，不能被继承。
static（静态）：可以修饰成员变量和成员方法，代码块。被静态修饰的属性，方法和代码块不再属于某个对象，将可以直接使用类名/方法名/属性名（），这样来进行调用。使用static，在jvm虚拟机加载该类的时候调用该static修饰的部分，调用得很早（比构造器早）。被statix修饰的变量将在整个程序中只有一份，被statix修饰的方法并不需要通过所属类的实例（对象）来调用。所以在静态方法中不能使用this，也不能访问此类的非静态方法和非静态变量。
三.继承
在已有类的基础上定义新的类。而不需要把已有类的内容重新写一遍，这就叫做继承。已有的类称为父类，在此基础上建立的新类称为子类。
继承语法：public class Child extends father(){
成员列表
}
子类继承父类之后，就可以继承父类的public变量，方法。子类也可以定义自己的属性和方法，也可以重写父类的方法。在java中所有类都间接或直接的在Object类。并且Java中只支持单继承。子类继承父类的方法，想要对这个方法做修改，我们就需要对这个方法进行重写。如果子类方法与父类中的某一方法具有相同的方法名，返回类型和参数表，新方法将覆盖原有的方法，如果需要父类中原有的方法，就使用super字来引用当前类的父类。子类函数的访问权不能比父类的小。
public void work(){//父类中的work方法 ----子类-->public void work(){
System.out.println("我在工作"); String msg=this.getName+"在工作"; }
}
this表示活动对象本身，任何一个活动对象对象都有一个默认的this指针指向自己。
格式：this.成员变量名; this.成员方法名;this();
表示当前活动对象的直接父类对象:super.成员变量名; super.成员方法名; super([参数]);在静态方法中不能使用this和super。
多态：体现在继承过程中，子类和父类类型的互相转换，子类对象直接赋值给一个父类的引用变量，被称为向上转换，父类转为子类需要强制转换。
Person p=new Student();p.work();//子类引用父类的重写方法。p.eat();//eat（）为子类方法，无法引用子类独有的方法。子类转换为父类：引用变量名=new 子类型();调用得方法是子类重写或继承父类的方法。无法调用子类特有的方法。父类转子类：引用变量 =new 父类类型（）；
四.接口
接口：只有抽象方法的抽象类。
格式1：接口的类型interface 接口名{
常量(必须初始化);
成员方法定义(只有原形而无函数定义体)
}
例：public interface Person{//接口
int a=5;
void eat();
}
public class Student implements Person{
public void eat(){}
}
接口的实现：class 类名 implements 接口名1,接口名2...一个类可以使用implements，从而实现多继承的机制。
实现接口的类必须实现接口中的所有方法，否则视为抽象类。被实现的接口方法必须使用pulic权限，因为接口中的方法权限应该比实现方法的类高。接口与接口使用extends，子类实现用implements。
默认常量：public static final和public abstract。
类只能继承一个类，对于接口，可以实现继承多个接口。
五.内部类
内部类：定在一个类，内部定义的类。内部类分以下几种：成员内部类，局部内部类，匿名内部类。通过内部类可以访问外部类的所有私有成员。
成员内部类：定义在类的内部，与成员变量与方法在同一层。
class OutClass{
class InnerClass{
public void mTest(){}
}
}
使用这个内部类，获取成员内部类:OutClass.InnerClass inner=new OutClass().new InnerClass;外部类.内部类 对象名=new 外部类().new 内部类名;
注意：成员内部类可以直接访问外部类的所有成员。成员内部类中还能拥有自己的成员内部类，最里面的成员内部类可以访问所有外部类的成员。外部类不能直接访问内部类的成员，必须创建内部类的对象。内部类中不能定义静态变量和静态方法。在内部类中如有与外部类有相同的变量，需要使用：外部类名.this.变量名。这样来访问。
外部类只能使用public和default两种访问控制符。内部类和方法，属性在同一层，可以使用：public,protected,private,(default)默认即不写。
静态内部类：用static修饰内部类。
例：Class OutClass{
static class InnerClass{
}
}
创建静态内部类的对象：OutterClas.InnerClass inner=new OutterClass.InnerClass();
注意：静态内部类可以直接访问外部类的静态成员。（注意是静态成员）静态内部类中可以有静态成员也可以有实例成员。静态内部类中的静态成员可以使用这种方式调用：外部类名.内部类名.静态成员。
局部内部类：public void way(){
class InnerClass{
public void test(){}
}
new InnerClass().test();
}
由上可见该局部内部类是定义在一个方法中，所以该局部内部类只能在定义的方法内使用。局部内部类不能包含静态成员，局部内部类必须在定义后使用。局部内部类与局部变量一样不能使用访问控制符。局部内部类可以访问类中所有成员。
匿名内部类：在定义的同时创建对象，它需要父类或父类接口来帮助定义。
new SuperClass(){实现父类的抽象方法}。
匿名内部类没有构造函数，但是它会调用父类的构造函数。
匿名内部类中使用外部类的局部变量，保证局部变量被初始化，用final修饰变量称为常量。在定义匿名内部类的同时会获取到匿名内部类的对象。