面向对象编程

对象的创建面向对象的三大特性抽象类和接口内部类及OOP实战

面向过程&面向对象

面向过程为线性思维，一次性完成面向对象使用了分类的思维模式，各个部分完成不同的工作，使架构更加清晰 三大特性 封装继承多态

类的调用

调用静态方法(static)使用class.method()调用非静态方法需要进行实例化，即创建一个对象 对象类型 对象名 = 对象值; Student student = new Student();同一class中static无法调用非static方法

类与对象的创建

public class Student { //属性 字段 String name; int age; //方法 public void study(){ System.out.println(name+" "+age); } } public class Application { public static void main(String[] args) { Student person = new Student(); person.name = "小明"; person.age = 6; person.study(); } } 使用new关键字进行对象创建的时候，除了分配内存空间之外还会给创建好的对象进行默认的初始化操作，以及对类中构造器的调用可以new一个方法属性为空的类，此时只包含构造器public class Person { //一个类即使什么也不写，也会存在一个方法，这个方法叫构造器 //以下为一个显示的定义构造器 String name; //实例化初始值 //new的本质就是调用构造器 //无参构造 public Person(){} //有参构造 //定义有参构造，必须存在以上无参构造 public Person(String name){ this.name = name; } }

封装

追求 高内聚低耦合 高内聚：类的内部数据操作细节自己完成，避免外部干涉 低耦合：进暴露少量的方法给外部使用属性私有 get/set alt+insert自动生成

私有属性定义以及调用

public class Student { //私有属性 private String name; private int id; //私有方法 private void study(){ System.out.println(name+" "+id); } //提供public get/set方法来取得私有值 //alt + insert 自动生成 //设置值 public void setName(String name){ this.name = name; //可以在方法中添加安全性检查提高程序的可维护性 } //返回值 public String getName(){ return this.name; } } public class Application { public static void main(String[] args) { Student student = new Student(); student.setName("XX"); System.out.println(student.getName()); } }

方法的重载

参数名相同，参数列表不同

继承

Java中所有类继承于Object类Java只有单继承没有多继承类与类之间的一种关系，除此之外还有组合，依赖，聚合等关系继承关系的两个类，一个为子类，一个为父类//父类 public class Person { public void say(){ System.out.println("shout"); } } //子类 public class Student extends Person{ } public class Application { public static void main(String[] args) { Student student = new Student(); student.say(); } }

super

用于调用父类的方法或属性

子类的构造器方法中包含父类构造器，嵌套关系，

注意点

super调用父类的构造方法，必须在构造方法的第一个super必须只能出现于子类的方法或构造方法中super和this不能同时调用构造方法，因为他们都必须存在于构造方法的第一行

this()调用本类的构造

super()调用父类的构造

方法重写

父类的功能子类不一定需要或不满足，此时就要重写方法需要有继承关系，子类重写父类的方法方法名相同，参数列表相同修饰符的范围可以变大不能减小 public>protect>default>private无法重写的方法 static final private public class Father { public void say() { System.out.println("father"); } } public class Son extends Father { //重写 @Override public void say() { System.out.println("son"); } } public class APP { public static void main(String[] args) { //静态方法调用只和左边定义类有关 //非静态方法才能重写 Father father = new Son(); father.say(); Son son = new Son(); son.say(); } }

多态–动态编译

方法的多态父类和子类，有联系才能进行转换存在条件：继承关系，方法需要重写，父类引用指向子类对象 Father f = new Son（）；增强扩展性 public class Father { public void run(){ System.out.println("Father"); } } public class Son extends Father { @Override public void run() { System.out.println("son"); } public void eat() { System.out.println("haha"); } } public class Applicat { public static void main(String[] args) { //一个对象的实际类型是确定的 //new Son(); //new Father(); //可以指向的引用类型不确定:父类的引用指向子类； Son s1 = new Son(); Father f1 = new Son();//父类引用指向子类对象，father转son Object s2 = new Son(); //能执行的方法看左边对象，父类不能用子类方法，被子类重写的方法用子类的 s1.run(); f1.run(); ((Son) f1).eat(); //强制转换 高转低 } instanceof 用于判断父子类型关系的判断类型转换 父类引用指向子类对象，father转son需要强制，反之自动转换方便调用方法，减少重复代码

代码块

静态代码块 最先执行且只执行一次匿名代码块 每次创建对象都会执行一次 -都在构造方法之前执行

抽象类

//abstract 抽象类 public abstract class App { //抽象方法，只有声明没有方法 //继承他的非抽象子类需要实现他的方法 public abstract void doThing(); //不能new抽象类 只能靠子类重写来实现 // 抽象类中可以写普通方法 // 抽象方法只能存在于抽象类中 . }

接口

只存在规范，自己无法写方法，约束和实现分离，本质是一种约束接口中的方法默认是public abstractimplement可以进行接口多继承来同时实现多个接口的方法实现接口的类必须进行重写 定义与实现 public interface TimeService { void time(); } public interface UserService { int age = 88; //默认public abstract final常量 void add(String name); //默认是public abstract void delete(String name); } public class UserServiceImpl implements UserService,TimeService{ //UserService @Override public void add(String name) { } @Override public void delete(String name) { } //TimeService @Override public void time() { } }

内部类

public class InsideClass { private int id = 10; public void out(){ System.out.println("外部类的方法"); class A{ //局部内部类 } } class Inner{ public void in(){ System.out.println("这是内部类"); } //内部类的方法可以访问外部类的私有属性或方法 public void getId(){ System.out.println("id = " + id); } } } public class UserService { public static void main(String[] args) { //首先定义外部类 InsideClass out = new InsideClass(); //通过外部类实现内部类 InsideClass.Inner inside = out.new Inner(); inside.in(); inside.getId(); } }

异常-Exception

定义体系结构处理机制处理自定义

定义

实际工作中程序会遇到各种无法继续执行的情况 检查性异常 用户使用时的错误操作导致的异常，程序无法预见。例如需要打开的文件不存在。一般在编译时可以避免运行时异常 程序编写时存在被忽略的错误，编译可通过存在运行隐患错误-ERROR 不是异常，脱离程序员控制的问题，例如栈溢出等底层问题

体系结构

try { System.out.println(a/b); }catch (ArithmeticException/*捕获的异常类型*/ e){ System.out.println("异常：b不能为0"); }finally { System.out.println("善后操作"); }