java1.1基础（中）[面向对象、异常]

五.面向对象OOP（重点）

本质：以类的方式组织代码，以对象的形式封装数据

5.1 创建对象

5.1.1 new

类名 对象名 = new 类名(); 【 类名() => 构造器 】

注：使用new创建对象的时候，会默认分配空间、调用构造器。

5.1.2 构造器（构造方法）

* [ 生成构造器快捷键 Alt+Insert >> Constructor ]

• 构造器特点：

  1. 必须和类的名字相同
  2. 必须没有返回类型，也不能写 void

• 作用：

  1. 使用 new 关键字，本质就是在调用构造器
  2. 用来初始化对象值

• 有参构造器

  注：无参构造器默认不显示定义，但在定义了有参构造后要调用无参构造，就要显示定义。

//当前类名为 Students
  public Students(String name, int age) {
      this.name = name;
      this.age = age;
  }
  //调用：Students xMing = new Students("xiaom",20);

5.1.3内存分析

1. new一个对象的时候，首选会创建一个引用变量名存在栈中将
2. 然后将类作为模板创建一个对象到堆中（内存）
3. 并且将该对象实例与引用变量名关联起来。
   

5.2 面向对象三大特性（重）

• 5.2.1封装（高内聚，低耦合）

记：属性私有 + get/set

作用：

1. 提高程序的安全性，保护数据

2. 隐藏代码的实现细节

3. 统一接口

4. 提高系统可维护性

public class app {
    public static void main(String[] args) {
        Stu2 stu2 = new Stu2();
        stu2.setName("小明");
        System.out.println(stu2.getName());
    }
}

public class Stu2 {
    private String name;	//私有属性
    public void setName(String val){ //set方法
        this.name = "学生"+val;
    }
    public String getName(){ //get方法
        return this.name;
    }
}//在get/set中可做某些功能，或合法性验证等操作

* [ 生成get/set快捷键 Alt+Insert >> get and set ]

• 5.2.2继承（extends）

  5.2.2-1概念：

  • java中继承只能有单继承（只有一个爸爸）
  • 继承的两个类，一个是子类（派生类），一个是父类（基类）
  • 所有的类都默认直接或间接继承 Object 类

  * [ 查看继承结构快捷键 Ctrl+H ]

  5.2.2-2super : ( 就是父类的this )

  例：

  public class app {
      public static void main(String[] args) {
          son son = new son();
          son.getName("paramName");
      }
  }
  

  public class son extends father{
      private String name = "sonName";
      public void getName(String name){
          System.out.println(name);	//方法参数的name||当前类的name
          System.out.println(this.name);	//当前类的name
          System.out.println(super.name);	//父类的name
      }
  }
  

  public class father {
      String name = "faName";
  }// 如果修饰符为 private ，则子类无法通过 super 获取
  

  注意：extends 默认在当前类的 构造方法 中，优先调用父类 构造方法

  5.2.2-3重写（子类实现了和父类一样的方法就是重写）

  * [ 创建重写方法快捷键 Alt+Insert >> override ]

  • 方法名和参数列表必须一样
  • 方法是修饰符不能是static 、 final 、 private （这些不能重写）
  • 修饰符范围可以不一样，但子类方法只能大于等于父类方法
  • 抛出异常的范围只能缩小，不能扩大

• 5.2.3多态

  • 是什么

    1. 同一方法可以根据发送对象的不同而采取多种不同的行为方式 (同样都是run,但是不同引用调用的结果不一样）
    2. 一个对象的实际类型是确定的(new了什么就是什么)，但是可以指向的引用类型不唯一

  • 多态必要条件（重）：

    1.只能是有直接或间接的父子关系的类( 不能是不相关的类 )
    2. 必要条件： 继承 、 重写(静态不能重写) 、 父类引用指向子类对象

  • 注意：

    1. 能否方法看左边（父类引用不能调用子类中独有的方法）
    2. 调用结果看右边（看方法有没有被重写）

  • instanceof (类型对比)

    // Object >> ClassA >> ClassB
    Object cla3 = new ClassB();
    System.out.println(cla3 instanceof ClassB); //true
    System.out.println(cla3 instanceof ClassA); //true
    System.out.println(cla3 instanceof Object); //true
    System.out.println(cla3 instanceof String); //false
    //System.out.println(X instanceof Y) 只有X，Y指向实例存在父子关系才为true
    

5.3 抽象类 abstract0

• 定义：abstract修饰
• 使用（作为子类的模板使用，约束子类）
  1. 抽象类的抽象方法，子类必须都实现（可以有普通方法）
  2. 有抽象方法的类，必须是抽象类
  3. 不用new抽象类，只能被继承（但存在构造器，子类通过 super 可调）

5.4 接口 interface（接口的本质是规则）

• 使用 interface 定义接口 ，使用 implements 继承接口
• 注意：
  1. 接口中的方法只能是抽象方法
  2. 实现了接口的类，就要重写接口的方法
  3. 可以同时继承多个接口，使用“，”分隔

5.5 内部类

1. 成员内部类

public class Outer {
    private float num = 3.14f;
    public void out(){
        System.out.println("外部类");
    }
    public class Inter{
        public void in(){
//            获取外部私有属性
            System.out.println("内部类"+num);
        }
    }
}

public static void main(String[] args) {
    Outer outer = new Outer();
    outer.out();

    Outer.Inter inter = outer.new Inter();
    inter.in();
}

2. 静态内部类

   将内部类设置为静态后，由于静态方法先执行，所以静态方法中不能获取外部类中的非静态属性

3. 局部内部类 定义在方法中的类

---

---

六.异常（Error\Exception）

java中将异常当做对象处理，所有异常基于一个基类java.lang.Throwable

• 异常关键字：try , catch , finally , throw , throws

* 快捷键：Ctrl+Al+T

6.1处理异常

try {
    ...
}catch (ArithmeticException e){ //必须，可以有多个
    System.out.println("BUG,我逮住你了");
}finally { //可选
    System.out.println("打扫现场");
}

6.2抛出异常

public class app {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;

        try {
            new app().test(10,0);
        } catch (ArithmeticException e) {
            System.out.println("发现一个异常");
            e.printStackTrace();//打印异常信息
        }
    }
	//抛出异常
    public void test(int a,int b) throws ArithmeticException{
        System.out.println(a/b);
    }
}
// throws 用于方法头，表示的只是异常的申明；可以一次性抛出多个异常
// throw hrow用于方法内部，抛出的是 异常对象；只能抛出一个异常

自定义异常（略）

---

---

7.常用类

7.1 Math

• 绝对值 abs [参数为负数返回参数的否定，否则返回本身]

  System.out.println(Math.abs(10)); //10
  System.out.println(Math.abs(-10)); //10
  

• 取整 ceil / floor

  System.out.println(Math.ceil(12.66)); //13.0
  System.out.println(Math.floor(12.66)); //12.0
  

• 四舍五入round

  System.out.println(Math.round(12.4)); //12
  System.out.println(Math.round(12.5)); //13
  

• 随机数 random

  (int)(Math.random()*(a-b+1)+b); //范围[a,b]

7.2 System

• 终止当前运行Java虚拟机 exit [接收非零状态码表示异常终止]

  System.exit(0);

• 当前时间的时间戳 currentTimeMillis

  System.currentTimeMillis()

7.3 Object

​ 所有类的基类，即所有类可直接调用

• 转字符串 toString ，如要转换对象需先覆盖该方法

public class App {
    public String name= "ZHENG";
    @Override
    public String toString() {
        return "App{" + "name='" + name + '\'' + '}';
    }
    public static void main(String[] args) {
        App app = new App(); 
        System.out.println(app.toString()); //App{name='ZHENG'}
    }
}

• 比较对象 equals ，如要比较对象需先覆盖该方法/默认比较地址

s1.equals(s2)

7.4 Arrays

• toString（返回字符串模式） Arrays.toString(arr);

• sort （排序，默认升序） Arrays.sort(arr);

• fill （填充，没有范围默认全部填充）

  Arrays.fill(arr[ ,fromIndex,toIndex ],value);

• binarySearch （使用二分查找法查询 , 找不到返回负数）

  int num = Arrays.binarySearch(arr,value);

• copyOf （复制，可以规避引用传值） copyOf(数组,截取的长度)

  int[] arr={10,20,30,40};
  int[] arrc=Arrays.copyOf(arr,arr.length);
  arrc[0]=50;
  System.out.println(Arrays.toString(arr));//[10, 20, 30, 40]
  System.out.println(Arrays.toString(arrc));//[50, 20, 30, 40]
  

• equals （比较数组元素值是否相同，返回布尔值）

  Arrays.equals(arr,arrc)