对象&异常

面向对象编程

• 对象的创建
• 面向对象的三大特性
• 抽象类和接口
• 内部类及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

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

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

• 注意点

  1. super调用父类的构造方法，必须在构造方法的第一个
  2. super必须只能出现于子类的方法或构造方法中
  3. 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();
    }

}

多态–动态编译

1. 方法的多态
2. 父类和子类，有联系才能进行转换
3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象
   Father f = new Son（）；
4. 增强扩展性

  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 abstract
• implement可以进行接口多继承来同时实现多个接口的方法
• 实现接口的类必须进行重写
  定义与实现

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

1. 定义
2. 体系结构
3. 处理机制
4. 处理
5. 自定义

定义

• 实际工作中程序会遇到各种无法继续执行的情况

1. 检查性异常
   用户使用时的错误操作导致的异常，程序无法预见。例如需要打开的文件不存在。一般在编译时可以避免
2. 运行时异常
   程序编写时存在被忽略的错误，编译可通过存在运行隐患
3. 错误-ERROR
   不是异常，脱离程序员控制的问题，例如栈溢出等底层问题

体系结构

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