面向过程和面向对象比较
面向过程的思想
? 步骤清晰简单，第一步做什么，第二部做什么，面向过程适合处理一些较为简单的问题
面向对象的思想
? 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后才对某个分类下的细节进行面向过程的思索。面向对象适合处理复杂的问题，适合处理需要多人协作的问题。
总结：
? 对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。
什么是面向对象
? 面向对象编程（Object-Orient Programing, OPP）
? 面向对象的本质：以类的方式组织代码，以对象的方式组织（封装）数据。
抽象
? 怎么样理解抽象，举个例子，一个学生管理系统，里面有学生的姓名，学号，班级，身高，体重等等。我们抽取其中的比如说姓名和学号组成一个类。这是一个对抽象形象的解释。
三大特性
封装：把代码里数据封装起来。
继承：子类可以继承父类的东西。
多态：对同一个方法，不同的事物通过这个方法所得出的结果是不一样的。
? 从认识论的角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
? 从代码运行的角度考虑是先有类后有对象，类是对象的模板。
1.类与对象
2.方法
定义、调用：！
3.对象的引用
引用类型： 基本类型（8）
对象是通过引用来操作的：栈-->堆
4.属性：字段Field 成员变量
默认初始化：
数字： 0 0.0
char： u0000
boolean： false
引用： null
? 修饰符 属性类型 属性名 = 属性值！
5对象的创建与使用
6.类：
静态的属性 属性
动态的行为 方法
使用new关键字创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象，进行默认的初始化以及对类中的构造器的调用。
创建一个Student类：
package com.oop.demo02;
//学生类 （一个类里面只有属性和方法两样东西）
public class Student {
//属性：字段
String name; //null
int age; // 0
//方法
public void study(){
System.out.println(this.name+"学生在学习");
//this代表当前这个Student类；
}
}
实例化对象：
public class Application {
public static void main(String[] args) {
//类: 抽象的， 实例化
//类实例化后会返回一个自己的对象
//student对象就是一个Student类的具体实例
Student s1 = new Student();
Student s2 = new Student();
s1.name = "张三";
s1.age = 20;
System.out.println(s1.name);//张三
System.out.println(s1.age);//20
s2.name = "李四";
s2.age = 19;
System.out.println(s2.name);//李四
System.out.println(s2.age);//19
}
}
类中的构造器也成为构造方法，是在进行创建对象的时候必须要调用的。一个类即使什么都不写，他也会存在一个方法，即构造方法（构造器）在IDEA中可以通过ALT+Insert快捷键选择生成构造器；并且构造器有两个特点：
构造器的作用
一旦定义了有参构造，无参就必须显式定义，这时调用会根据参数来判断是走无参还是有参
封装重点是对于属性的封装，方法很少用
该露的露，该藏的藏
封装（数据的隐藏）
属性私有，get/set
写一个学生类：
public class Student{
//属性私有
private String name;//名字
private int id; //学号
private char sex; //性别
//提供一些可以操作这些属性的方法
//提供一些public的get、set方法
//get 获得这个数据
public String getName(){
return this.name;
}
//set 给这个数据设置值
public void setName(String name){
this.name=name;
}
}
main方法：
public class Application{
public static void main(String[] args){
Student s1=new Student();
s1.setName("张三");
System,out.println(s1.getName());//张三
//s1.name在这里不能使用了，因为name是private的，如果换成public则可以使用
}
}
super()注意点：
VS this:
代表的对象不同：
前提：
构造方法：
重写都是方法的重写，和属性无关
重写：需要有继承关系，子类重写父类的方法！
1.方法名必须相同
2.参数列表必须相同
3.修饰符: 范围可以扩大,但不能缩小 public>Protected>Default>private
4.抛出的异常：范围可以被缩小，但不能扩大； ClassNotFoundException-->Exception(大)
重写：子类的方法和父类必须要一致；方法体不同！
为什么需要重写：
1.父类的功能子类不一定需要，或者不一定满足！
Alt+Insert：override；
静态方法和非静态方法区别：
同一对象可以根据发送对象的不同而采用多种不同的行为方式.
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
多态的存在条件
注意：
不能被重写的方法：
1.父类引用指向子类的对象
2.把子类转换为父类，向上转型：
3.把父类转换为子类，向下转型，强制转换
4.方便方法的调用，减少重复的代码！
普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范 约束和实现分离
接口就是规范，定义的一组规则
接口的本质是契约，就像人类定义的法规一样，制定好后大家都要遵守。
OO的精髓，是对对象的抽象，最能体现这一点的就是接口，声明类的关键字是class，声明接口的关键字是interface
java是单继承的，但是可以通过接口实现多进程
两个接口：
package com.oop.demo10;
public interface TimeService {
void timer();
}
package com.oop.demo10;
//interface 定义的关键字 ,接口都需要有实现类
public interface UserService {
//常量~ public static final
int AGE = 99;
//接口中的所有定义其实都是抽象的 public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
接口的实现：
package com.oop.demo10;
//抽象类 extends
//类 可以实现接口 implement 接口
//实现了接口的类，就需要重写接口中的方法
//多继承~利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
接口的作用：
约束
定义一些方法，让不同的人实现
方法都是 public abstract
常量都是常量~ public static final
接口不能被实例化，接口中没有构造方法
implements 可以实现多个接口
必须要重写接口中的方法
内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对于A类来说就称为内部类，而A类相对B类来说就是外部类。
内部类可分为：
成员内部类
package com.oop.demo11;
public class Outer {
private int id = 10;
public void out(){
System.out.println("这是外部类的方法");
}
public class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
//获得外部类的私有属性
public void getID(){
System.out.println(id);
}
}
}
package com.oop;
import com.oop.demo11.Outer;
public class Application {
public static void main(String[] args) {
//new
Outer outer = new Outer();
//通过外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.getID();
}
}
静态内部类
局部内部类
匿名内部类
package com.oop.demo11;
public class Test {
public static void main(String[] args) {
//没有名字初始化类,不用将实例保存在变量中
new Apple().eat();
}
}
class Apple{
public void eat(){
}
}
原文：https://www.cnblogs.com/ly1372/p/14641611.html