day04-面向对象-2021年10月15日

1、面向对象

（1）创建对象内存分析

（2）封装

​ 高内聚，低耦合

​ 属性私有，提供一些public的get/set方法（alt+insert 自动生成get/set）

（3）继承

​ 继承是类和类之间的关系，子类extends父类 ，重写父类方法，子类可以通过super.来调用父类的属性和方法，但是父类priavte的属性和方法是无法被继承即使用super也不行

（4）super注意点：
1、super调用父类的构造方法，必须在构造方法的第一个
2、super必须只能吃现在子类的方法或者构造方法中
3、super和this不能同时调用构造方法

（5）重写
需要有继承关系，子类重写父类的方法
1、方法名必须相同
2、参数列表必须相同
3、修饰符：范围可以扩大但是不能缩小

（6）多态

​ 注意事项：

• 多态是类的方法多态，属性没有多态

• 父类和子类之间多态，没有联系如果多态会出现类型转换异常

• 继承关系，方法需要重写，父类引用指向子类对象 ，例如

  Father fa = new Son();
  

  static 修饰的静态方法属于类不属于实例

  final 常量

  private方法

（7）instanceof 类型转换

可以判断两个类是否是父子关系

Object obj = new Student();

System.out.println(obj.instanceof Student);    // true
System.out.println(obj.instanceof Person);     // true
System.out.println(obj.instanceof Object);	   // true
System.out.println(obj.instanceof String);     // false

低转高 不需要强转 直接转，高转低如果 需要转化需要强制转换

class Student extends Person{
    public void study(){
        System.out.println("这名学生正在学习中");
    }
} 

class Person{
    public void eat(){
        System.out.println("这个人正在吃饭");
    }
}


public class Test{
    public static void main(String[] args){
        //高              低
		Person p1 = new Student();
        System.out.println((Student)p1.study());
    }
}

（8）static

静态代码块：可以加载一些初始化的

• 匿名代码块

  {
      System.out.println("匿名代码块");
  }
  

• 静态代码块（只执行一次）

  static {
      System.out.println("静态代码块");
  }
  

（9）抽象类

被abstract修饰的类，在方法中添加abstract后就是抽象方法，抽象类只能单继承 ，一个类如果有抽象方法，这个类一定是抽象类，但是抽象类里面可以有普通方法

//只有方法的名字，没有方法体
public abstract void shout();

当A类继承B类，如果B类里面有抽象方法，A类必须重写B类里面的抽象方法进行实现（除非A类也是抽象类）

问：抽象类存在的意义是什么？

答：如果一个对象需要反复创建，那么可以把共有的部分放到抽象类中，让这个类继承抽象类，从而实现抽象方法，这样更方便

（10）接口

接口可以多继承，接口中只有规范无法自己写方法，达到了约束和实现分离,接口的定义用interface

public interface UserService{
   // public abstract可以省略
   public abstract void run();
}

public class UserServiceImpl implements UserServic{
    @Override
    public void run(){
        System.out.println("这是一个实现方法");
    }
}

（11）内部类

• 成员内部类

  public class Outher{
      private int id;
      public void out(){
          System.out.println("这是一个外部类方法");
      }
      public class Inner(){
          public void in(){
              System.out.println("这是一个内部类方法");
          }
      }
  }
  //如果想调用内部类的方法
  Outher outher = new Outher();
  Outher.Inner inner = outher.new Inner();
  

  （12）异常

  • 检查性异常 ，例如：打开文件，文件不存在
  • 运行时异常 例如：程序员可以避免的异常
  • 错误，错误不是异常

​ Error：由JVM虚拟机生成并抛出，大多数错误于代码编写者所执行操作无关，例如OutOfMemoryError内存溢出 这些异常发生时jvm会线程终止

​ Exception：

处理异常：try catch throw throws finally

public class Test{
    public static void main(String[] args){
        int a = 10;
        int b = 0;
        try{
            if(b == 0){
                throw new ArithmeticException(); //主动抛出异常，一般在方法中使用
            }
            System.out.println(a/b);
        }catch(ArithmeticException e){
            System.out.println("程序出现异常，变量b不能为0");
        }finally{
            //finally可以省略
            System.out.println("finally");
        }    
    } 
}

throws:

//此处如果抛出异常，那么调用test方法的时候需要捕获异常进行处理try catch
public void test(int b) throws Exception{
    if(b == 0){
        throw new ArithmeticException();
    }
}

自定义异常：

//继承Exception类
public class MyException extends Exception{
    private int detail;
    
    //无参构造方法
    public MyException(int a){
        this.detail = a;
    }
    
    @Override
    public String toString(){
        return "MyException{"+ detail s+"}";
    }
}

//测试自定义异常
public class Test{
    static void test(int a) throws MyException{
        System.out.println("传递的参数为："+a);
        if(a>10){
            throw new MyException(a);
        }
        System.out.println("OK");
    }
	
    public static void main(String[] args){
        try{
            test(11);
        }catch(MyException e){
            System.out.println("MyException=>"+e.getMessage());
        } 
    }

}

    System.out.println("OK");
}

public static void main(String[] args){
    try{
        test(11);
    }catch(MyException e){
        System.out.println("MyException=>"+e.getMessage());
    } 
}

}