面向对象（Object Oriented Programming，OOP）是一种思想，Java可以通过这种思想设计程序。最笨的理解就是让别人去干活，自己做管理。
一. 类：
class Human { public static void main(String[] args) { System.out.println("HelloWorld!我是human."); }}
前面几篇中的程序上来就有一个HelloWorld类，其中有个程序入口main方法。所谓的方法也就是功能，通过它我们可以做到在屏幕上向世界问好。现在有一个类叫人类（Human），他自己在喊话，的确显得有点累。下面我们让他操作一台机器来喊话。
在同一个java文件里，我们新建了一个机器（Machine）类，此时的类Machine并不是实实在在的机器，仅仅泛指“机器”这个种类，要想让它干活，还得具体到“对象”，也就是实实在在的机器。
二. 对象：
上面再main方法中，我们根据Machine这个种类，用new创建一个实实在在的machine对象。然后让这个对象运用shout功能，去打印Hello~。
三. 类和对象：
类，是对象的“模板”；对象，是类的实例。类，比如说人；对象，具体的某个人。类，比如说狗；对象，比如说我家的狗狗。我们所在的main方法是程序的Boss，调用其它对象干活，其它对象之间也可以互相调用。main方法所在的类也可以根据需要实例化。
在编程中，我们要根据需要将一些功能集成到一个类中，然后通过调用它的实例来处理数据。当对象产生，OOP就有了封装的概念。
四. 封装：
使用既定的权限关键字修饰，我们可以对类的属性和方法进行隐藏，这里就有了封装的概念。封装显示了Java的安全性。两个对象只能根据权限互相访问调用，而不是随意的。如果你不公开姓名，我就没法知道；我不公开自己的体重，你也不会知道。
public 公开：随意访问。
private 私有：同一个类中可以访问。只能修饰类的属性、方法，或内部类
protected 保护的：同一个包内，以及子类可以访问。只能修饰类的属性、方法，或内部类
default 默认的：同一个包内可以访问。默认没有标注权限修饰符的都是default。
public class PowerTest //我。一个java文件中只能有一个public修饰的类{ public static void main(String[] args) { System.out.println("\t警察抓小偷：\n"); Thief t=new Thief(); t.Steal(); Police police=new Police(); System.out.println("\t直接叫警察，警号："+police.pliceNum); police.Call(); police.Catch(); police.Drive(); //police.Eta(); //私有的只能在同一个类中访问 Operator operator=new Operator(); System.out.println("\t打话务员报警"); operator.Call(); }} class Police //警员{ public int pliceNum=100010; //警号，公开 private int appetite=3; //饭量，私有 protected int familyMember=3; //家庭成员，受保护的 public void Call(){ System.out.println("我是警察，随时Call我"); } public void Catch(){ System.out.println("警察抓捕窃贼"); } private void Eat(){ System.out.println("警察在吃饭"); } protected void Drive(){ System.out.println("良民可以搭顺风车"); }} class Thief{ private String name="ThreeHand"; private void Eat(){ System.out.println("贼也得吃，自己吃"); } protected void Steal(){ System.out.println("小偷顺手牵羊"); }} class Operator{ public void Call(){ System.out.println("呼叫110，话务员转警察"); Police p=new Police(); p.Catch(); }}
五. 抽象：
抽象就是不仔细，没有细节，泛泛的，大体的。如果根据一群人抽象一下“人”这个概念，我们会总结身高、体重、吃饭、哭笑等等方面。身高体重是属性，这个不属于抽象的范围，但吃饭、苦笑是两个功能，属于抽象的范围，每个具体的人根据实际情况来实现吃饭或哭笑。abstract用来修饰抽象的类或方法。
如果出现了抽象方法，那么所在类一定为抽象类；但抽象类中不一定有抽象方法。
当子类没有全部实现抽象类的抽象方法时，须要下一级的子类实现剩余的抽象方法。
抽象类不能用new实例化出对象；须要被继承，并实现其定义的抽象方法。
六. 继承：
extends，继承。也就是遗传自，来源于，属于。如父子相传，小狗属于动物，大楼根据图纸盖得。当然根据封装的概念，如果图纸是保密的，大楼就没法盖。
class Human { public static void main(String[] args) { Bus bus=new Bus(); bus.shout(); bus.move(); }}abstract class Machine{ abstract void shout(); //后面没有大括号，没有任何语句 abstract void move();}class Bus extends Machine{ void shout () { System.out.println("嘀嘀！"); } void move() { System.out.println("跑~"); }}
1. 子类会得到父类所有非私有的属性和方法，
class Human { public static void main(String[] args) { Child child = new Child(); child.shout(); System.out.println(child.country); }}class Father{ String country="中国"; void shout () { System.out.println("我爱祖国"); }}class Child extends Father{ //继承了父类的属性和方法}
2. 重写，如果子类中有一个和父类中同名的方法，子类的这个会将父类中的覆盖，
/*方法覆盖*/class Father{ void shout () { System.out.println("父类中的方法"); }}class Child extends Father{ //重写父类中的同名方法 void shout () { System.out.println("子类中的方法"); }}class Human { public static void main(String[] args) { Child child = new Child(); child.shout(); }}
七. 接口：
一个特殊的抽象类，其中所有的方法都是抽象的。所有属性和方法都是public权限。接口的修饰符是interface，要实现接口需要implements。接口也是一系列功能的集合。
和抽象类一样，子类必须全部实现接口的抽象功能，否则子类也是抽象的。
class Human { public static void main(String[] args) { Child child = new Child(); child.eat(); child.shout(); System.out.println("Child实例："+child.country); System.out.println("Child类："+Child.country); System.out.println("Father类："+Father.country); }}interface Father{ public static final String country="China"; public void eat(); public void shout();}class Child implements Father{ public void eat(){ System.out.println("Eatfood."); } public void shout(){ System.out.println("Letus sing"); }}
八. 构造方法
任何一个类都有构造方法，就如任何人都有魂儿一样（唯心的说法）。当我们用new创建一个实实在在的人（对象）时，实际是在调用人（类）的灵魂（构造方法）。灵魂是不能被继承的。灵魂可以有很多（精神分裂）。灵魂可能很贪婪。灵魂也是可以沟通的。
/*方法名与类名相同的无返回值*/class Human{ //穷发飙的魂儿，无参 Human () { System.out.println("我是魂儿"); } //贪婪的魂儿，须要获取参数 Human(int i) { System.out.println("干活收费："+i+"刀"); } void shout () { System.out.println("我是人类"); }} class Structure { public static void main(String[] args) { Human h1=new Human(); h1.shout(); Human h2=new Human(10); h2.shout();}
这里又多了一个新的概念，重载。有两个构造函数，参数列表不同，两次调用实现了不同的功能。
参数列表中，如果参数数量不同，或参数的数据类型不同，或参数的顺序不同，都会发生重载。重载和构造函数的返回值无关。和参数名无关。
/*方法名与类名相同的无返回值*/class Human{ //穷发飙的魂儿，无参i Human (int i) { System.out.println("一个整型参数 "+i); } //贪婪的魂儿，须要获取参数 Human(int i, int j) { System.out.println("两个整型参数 "+i+"，"+j); } Human (int i, String s) { System.out.println("一个整型参数 "+i+"，一个字符串 "+s); } Human (String s, int i) { System.out.println("一个字符串 "+s+"，一个整型参数 "+i); }} class Structure { public static void main(String[] args) { Human h1=new Human(9); Human h2=new Human(9,8); Human h3=new Human(9,"Tom"); Human h4=new Human("Tom",8); }}
九. 多态
多种身份，见人说人话，见鬼说鬼话。比如我们有个鬼类，用它来创建了一个实实在在的人，这个人首先继承自鬼，有鬼的面孔，却说着人话。（这个例子很凌乱。）
class Ghost{ Ghost(){ } void horror () { System.out.println("鬼吓人！"); }} class Human extends Ghost{ Human(){ } void horror () //重写 { System.out.println("人吓人！"); }} class Polymorphism{ public static void main(String[] args) { Ghost gh=new Human(); gh.horror(); }}
我们无法让这个鬼面人心的家伙变得鬼面鬼心，但可以让它人面人心。修改main函数中的内容，
Ghost gh=newHuman(); //向上转型gh.horror();Humang=(Human)gh; //向下转型g.horror();
天才是百分之一的灵感加上百分之久十久的努力
