类：类是抽象的，概念上的，共性的，是对象的模板
对象：个体，具体的，可以看见的，对象是个性的，是该类事物的每个个体，也称为类的实例。
类的组成：
对象的创建
对象的引用传递问题
面向对象的特性：封装，继承，多态
封装的概念：使用private实现类的封装，用private关键字修饰属性，修饰方法，private的含义是私有的，使用private修饰的方法和属性不能被外部直接访问。
封装的特性：通过使用封装的属性，要通过get,set方法来获得和设值。
构造方法的作用：构造方法的作用主要是用来构造对象并且为对象的属性赋值。构造方法的定义规则：
方法的定义
public|private|protected|默认 + static|默认|synchroized|native|abstract+返回值类型|void|空+方法名称（参数）+ throws Exception{ 方法体 }
方法的调用：
以类作为数组的类型，以对象作为数组的元素
Person p[] = new Person[10];//一类作为数组的类型,元素就是对象 for (int j = 0; j < p.length; j++) { Person px = new Person("张三",20+j); p[j] = px; } for (int j = 0; j < p.length; j++) { Person per = p[j]; System.out.println(per.getName()+"===="+per.getAge()); }
在同一个类中，方法的名称相同，返回值的类型相同，但是参数的个数，类型，顺序不同就叫做重载，重载是面向对象多态性的一个体现。
//吃饭 public void eat(){ System.out.println(name + "在吃饭"); } public void eat(int x){ System.out.println(name + "在吃饭，吃了"+ x +"碗。"); }
this关键字可以表示当前对象
this关键字可以表示当前类的属性
this关键字可以表示调用当前类的方法
this关键字调用当前类的构造方法
static变量：使用static修饰的变量就叫做静态变量
static方法：使用static修饰的方法就叫做静态方法
public class OopDemo01 { static int score = 70;//静态变量 double salary = 5000.00;//普通变量 public static void add(){//静态方法 //eat();静态方法中不能调用非静态方法 System.out.println(score); //System.out.println(salary);静态方法不能调用非静态变量 } public void eat(){//普通方法 add();//非静态方法可以调用静态方法 System.out.println(score);//普通方法可以调用静态变量 System.out.println(salary); } public static void main(String[] args) { }
对于静态方法调用的问题
栈：保存属性（变量）名称
堆：保存属性（变量）值
全局数据区： static修饰的变量
全局代码区：static修饰的方法
继承的作用：
子类通过extends关键字继承父类
继承的特点：子类可以继承父类一切非私有的属性和方法
继承的规定：
子类的实例化过程：实例化子类对象的时候会先调用父类的构造方法，说明父类也进行了实例化对象操作，实际上调用父类的构造方法构造父类对象就是为子类对象开辟空间，而且可以为父类的属性初始值。
super关键字的使用：父类也称为超类（）
方法的复写（）
方法的重写的定义：方法的返回值的类型，方法名称，方法里的参数的个数，顺序，类型一致，就是方法的复写，子类复写父类的方法，调用子类的方法，扩展父类的属性，复写分类的方法子类的访问权限必须要大于等于父类的方法，父类的方法不能为private。
复写和重载的区别：
|
序号 |
重载 |
覆写 |
|
1概念 |
名称相同，参数的个数类型顺序不同 |
方法名称相同，访问权限不小于父类被覆写方法，参数相同，返回值类型相同 |
|
2范围 |
在同一类中 |
在继承关系中，子类覆写父类方法 |
访问修饰符
|
位置 |
private |
默认 |
protected |
public |
|
同类 |
V |
V |
V |
V |
|
同包的类 |
X |
V |
V |
V |
|
不同包的字类 |
X |
X |
V |
V |
|
不同包且不是字类 |
X |
X |
X |
V |
public|private|protected|默认 + static|默认|synchroized|native|abstract+返回值类型|void|空+方法名称（参数）+ throws Exception{ 方法体 }
final :在java中final可以修饰变量方法，类
package com.wanczy.oopHightLevelDemo; public abstract class OopDemo003 {//定义就是抽象类 public abstract void eat();//声明抽象方法 }
抽象方法只需要声明不需要实现，有一个抽象方法必须定义为抽象类
抽象类和普通类相比区别：抽象类比普通类多了抽象方法，普通类中的所有定义都可以在抽象类中使用
抽象类的使用规则：
范例：现在有两类员工，一类是技术类，一类是销售类，两种员工的提升工资的方式不一样，技术员工类按照岗位等级提升，销售员工按照上一年度销售业绩来提升工资
package com.wanczy.abstractDemo; public abstract class Employee { private String name; private double salary;//工资 public Employee() { super(); // TODO Auto-generated constructor stub } public Employee(String name, double salary) { super(); this.name = name; this.salary = salary; } public String getName() { return name; } public void setName(String name) { this.name = name; } public double getSalary() { return salary; } public void setSalary(double salary) { this.salary = salary; } public abstract void updSalary();//提升工资的抽象方法 }
package com.wanczy.abstractDemo; public class TechEmployee extends Employee{ private String post;//岗位等级 @Override public void updSalary() { // TODO Auto-generated method stub double salary = super.getSalary(); if(this.post .equals("高级工程师")){ super.setSalary(salary*1.05); }else if(this.post.equals("中级工程师")){ super.setSalary(salary*1.1); }else if(this.post.equals("初级工程师")){ super.setSalary(salary*1.15); } } public String getPost() { return post; } public void setPost(String post) { this.post = post; } public TechEmployee(String post) { super(); this.post = post; } public TechEmployee() { super(); // TODO Auto-generated constructor stub } public TechEmployee(String name, double salary,String post) { super(name, salary); this.post = post; // TODO Auto-generated constructor stub } }
package com.wanczy.abstractDemo; public class OopDemo01 { public static void main(String[] args) { Employee e = new SaleEmployee("长桑",3000,100); e.updSalary(); System.out.println(e.getSalary()); } }
通过以上程序，我们可以发现，如果以后出现其他的员工类型，提升工资的方式不同，可以编写抽象类的字类完成，不需要更改顶层设计。也就是说抽象类的作用就是在于可以方便程序的扩展。
接口的声明使用interface，接口只有常量和抽象方法；
package com.wanczy.oopDemo; public interface InterfaceDemo01 { //常量 //抽象方法 public abstract void eat(); public abstract void run(); }
如果说一个抽象类只有抽象方法和常量的话，我们就可以使用接口来表示。接口中没有子类的概念，实现类，实现类通过implements实现接口，必须覆写接口中所有的抽象方法。
接口的使用规则：
抽象类与接口的区别
|
|
抽象类 |
接口 |
|
相似 |
不能直接实例化，抽象类通过子类实例化，接口通过实现类实例化 |
|
|
不同 |
包含抽象方法、一般方法、变量、长流昂、构造方法 |
常量和抽象方法 |
|
抽象类可以实现接口 |
接口不继承抽象类 |
|
|
单继承的局限性 |
多继承多实现 |
|
多态的核心就是子类对象作为父类对象来使用，抽象类的子类对象作为抽象类对象使用，实现类对象作为接口的对象来使用。
理解抽象类和接口的区别
理解重载和覆写的区别
熟记继承的特点以及规定（super关键字的使用）
原文：http://www.cnblogs.com/wusha/p/7157394.html
