面向过程思想——步骤清晰简单，按步执行
面向对象思想——分类的思维模式，思考解决问题需要哪些类型，然后分类进行细节思考
适合处理复杂问题，需要多人协作的问题
面向对象编程(Object-Oriented Programming)
本质：以类的方式组织代码，以对象的形式组织(封装)数据
三大特性：封装、继承、多态
类是一种抽象的数据类型，它是对某一类事物的整体描述、定义，但不代表某一具体的事物
对象即是抽象概念的具体实例
1 //默认初始值 2 Class name = new Class();
String name; //无参构造器，new本质上就是在调用构造器 public Class() { //实例化初始值 this.name = "name"; } ? //有参构造器，必须显示无参构造 public Class(String name) { this.name = "name"; } ? //Alt + Insert快速创建构造器
高内聚(类内部的数据操作细节自己完成，不允许外部干涉)、低耦合(仅暴露少量的方法给外部使用)
①提高程序安全性、保护数据
②隐藏代码细节
③统一接口
④提高系统可维护性
属性私有，get、set方法
本质是对某一类的抽象
extends，子类是父类的扩展
Java里只有单继承
继承是类与类之间的关系(除此之外，类与类之间的关系还有：依赖、组合、聚合等)
Java中，所有的类都直接或间接的继承Object类
this();本类的构造
super();父类的构造
可调用父类属性或方法，调用父类的构造方法必须在构造方法的第一个，且只能在子类中(super和this不能同时调用构造方法)
private无法继承
子类构造器默认包含父类无参构造器
调用父类构造器必须在子类构造器内的第一行
//A extends B //A public static void test(){sout(A.test);} //B public static void test(){sout(B.test);} //静态方法的调用只和左边定义的数据类型有关 A a = new A(); a.test();//A.test ? //父类的引用可指向子类 B b = new A(); b.test();//B.test ? //A public void test(){sout(A.test);} //B public void test(){sout(B.test);} //非静态：重写 A a = new A(); a.test();//A.test ? //子类重写的父类的方法 B b = new A(); b.test();//A.test
重写需要有继承关系，子类重写父类的方法
方法名必须相同
参数列表必须相同
修饰符范围可以扩大，但不可缩小 private<Default<Protected<public
抛出异常：范围可以被缩小，但不能扩大——>
1 ClassNotFoundException——>Exception(大)
重写的原因
父类的功能子类不一定需要，或者不一定满足。
同一方法可以根据发送对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向的引用类型不确定
1 Son s1 = new Son(); 2 Father s2 = new Son();
多态是方法的多态
存在条件：有继承关系、方法重写、父类引用指向子类对象.
1 Father f = new Son();
取决于对象左边的类型
子类能调用的方法：自己的以及继承父类的方法
父类能调用的方法：自己的方法
子类重写了父类的方法，就执行子类的方法
static方法，属于类，不属于实例，即不能重写
final修饰的内容为常量，无法重写
private私有的方法也无法重写
instanceof判断两个类之间是否有父子关系
1 //Object > Father > Son 2 //Object > Father > Son2 3 Objcet object = new Son(); 4 System.out.println(object instanceof Son);//true 5 System.out.println(object instanceof Father);//true 6 System.out.println(object instanceof Object);//true 7 System.out.println(object instanceof Son2);//false 8 System.out.println(object instanceof String);//false,对象不在同一条线上，编译不通过，说明是并列关系 9 10 //类型转换：父<-->子 11 //父方法f();子方法s(); 12 //高 低 13 Father s = new Son(); 14 //s不可执行Son里的s();方法，需要强转 15 ((Son)s).s(); 16 //子类转换为父类，直接转换，可能丢失一些方法 17 Father f = s;
父类和子类有联系才能转换，类型转换抛出异常——>
1 ClassCaseException!
1 private static int age; 2 private int score; 3 //静态变量可以直接通过类名访问 4 System.out.println(Class.age); 5 //非静态需要创建实例才能引用 6 Class c = new Class(); 7 System.out.println(c.score);
1 //静态方法和main一样和类一同加载 2 public void v1(){v2();} 3 public void v2(){} 4 public static void v3(){v4();} 5 public static void v4(){} 6 ? 7 public static void main(String[] args) 8 { 9 //静态方法可以直接访问或者通过类名访问 10 Class.v3(); 11 v4(); 12 //非静态需要创建实例才能引用 13 new Class().v1(); 14 }
1 public class C 2 { 3 //静态代码块>匿名代码块>构造器,执行循序 4 { 5 //匿名代码块，用来赋初始值，只执行一次 6 } 7 static 8 { 9 //静态代码块，每次实例化都会执行 10 } 11 pulic C 12 { 13 //默认构造器，每次实例化都会执行 14 } 15 }
1 //import java.lang.Math; 2 import static java.lang.Math.random; 3 ? 4 public static void main(String[] args) 5 { 6 //System.out.println(Math.random()); 7 System.out.println(random()); 8 }
用abstract修饰的类就是抽象类
继承抽象类的子类必须重写(实现)它的所有方法
抽象方法只能存在抽象类中，但抽象类中可以出现正常方法
存在意义：抽象化，提高开发效率，提高可扩展性
普通类：只有具体实现
抽象类：具体实现和抽象方法(规范)都有
接口：只有规范(自己无法写方法)，专业的抽象(约束)，约束和现实分离：面向接口编程
接口不能被实例化，接口中没有构造方法
类只能是单继承，但接口可多继承
1 //接口中定义的方法都是抽象的，public abstract 2 //属性定义的都是常量，public static final 3 public interface UserService{} 4 public interface TimeService{} 5 //接口都需要有实现类，且必须重写(实现)它的所有方法 6 public class UserImp implements UserService,TimeService{}
接口就是规范，定义的是一组规则
接口的本质是契约，如法律，必须遵守
OOP的精髓，是对对象的抽象，最能体现这一点的就是接口
在类内部再创建一个类
通过外部类.new来实例化内部类
内部类可以获得外部类的私有属性
一个java类中只能有一个public属性的class，但可以有多个class
这时创建的class、interface可以在main方法中实现匿名调用
在类方法内部再创建一个类
Java把异常当做对象来处理，并定义了个基类java.lang.Throwable作为所有异常的超类
异常分为Exception和Error
Error是虚拟机生成并抛出的，大多与代码编写者所执行的操作无关
一般是虚拟机JVM运行错误，内存溢出(OutOfMemoryError)时，JVM一般会选择线程终止
虚拟机执行应用时，如类定义错误(NoClassDefFoundError)、链接错误(LinkageError)，这些错误是不可查的
RuntimeException(运行时异常)
ArrayIndexOutOfBoundsException
NullPointerException
ArithmeticException
MissingResourceException
ClassNotFoundException
抛出异常
捕获异常
可以提前捕获异常，使程序的其他内容继续执行
1 //Ctrl + Alt + t 直接建立 2 try 3 { 4 //监控区域 5 //执行语句 6 //满足条件主动抛出异常(算术异常)，一般在方法中使用 7 if(Exception) 8 { 9 throw new ArithmaticException(); 10 } 11 } 12 catch(Error er) 13 { 14 //捕获Error异常，并反馈 15 //捕获到Error异常后，后面的捕获直接结束 16 er.printStackTrace(); 17 } 18 catch(Exception ex) 19 { 20 //捕获Exception异常，并反馈 21 ex.printStackTrace(); 22 } 23 catch(Throwable ta) 24 { 25 //捕获异常，并反馈 26 ta.printStackTrace(); 27 } 28 finally 29 { 30 //处理善后工作，一定执行，用于关闭I/O资源，可不要 31 } 32 ? 33 //在方法上主动抛异常 34 public void math() throws ArithmaticException 35 { 36 //满足条件主动抛出异常(算术异常)，一般在方法中使用 37 if(Exception) 38 { 39 throw new ArithmaticException(); 40 } 41 }
自定义异常
1 public class MyException extends Exception 2 { 3 private int detail; 4 5 //创建构造器 6 public MyException(int a) 7 { 8 this.detail = a; 9 } 10 11 //创建toString方法，打印异常信息 12 @Override 13 public String toString() 14 { 15 return "MyException{" + 16 "detail" + detail 17 + ‘}‘; 18 } 19 } 20 ? 21 //引用，要么在方法上抛出throws，要么在方法内捕获try/catch
原文：https://www.cnblogs.com/kevinsblog/p/12975793.html