面向对象

Java的核心思想就是面向对象编程（OOP）

面向对象&面向过程（不可分割）

1. 面向过程：第一步做什么，第二步做什么...适合处理一些简单问题

2. 面向对象：以类的方式组织代码，以对象组织（封装）数据

   分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。适合处理复杂的问题，适合处理多人协作的问题。

3. 三大特征：

   （1）封装：高内聚：类的内部数据操作细节自己完成，低耦合：仅暴露少量方法给外部使用；

   get，set方法用于获得private的属性

   意义：提高代码的安全性；隐藏细节；统一接口；系统的可维护性增加了

   （2）继承：

   • 在java中，所有的类，都默认直接或者间接继承Object；

   • super()：1. 隐藏方法，默认调用父类的无参构造，必须在构造方法的第一个；

   2. 必须只能出现在子类的方法或者构造方法中
   3. super(父类的构造)和this（本类的构造）不能同时调用构造方法

   • 注意：java中只有单继承，没有多继承（即一对多的关系）

   • 方法重写：1. 需要有重写关系，子类重写父类的方法，父类方法会被覆盖，子类方法名相同，方法体不同

     2. 方法名必须相同

     3. 参数列表必须相同

     4. 抛出的异常：范围可以被缩小但不能扩大

     5. @Override 只在非静态方法中出现

     6. 修饰符：范围可以扩大但不能缩小，关键字只能是public

     为什么要重写？子类的方法父类不一定需要，或不一定满足

   （3）多态：存在继承关系，方法需要重写，父类引用指向子类对象

   //父类引用指向子类对象
   Student s1 = new Student();
   Person s2 = new Student();
   Object s3 = new Student();
   

类型转换：instanceof 高转低强制转换

例：Person obj = new Student();

Student student = (Student) obj;//将Person父类转化为子类Student类

方法

1. 静态方法（static）&非静态方法

   静态方法调用：类名.方法名

   非静态方法：将对象实例化(new一个对象：对象类型 对象名 = 对象值)

   对象名.方法名调用

类与对象的关系

类：是一种抽象的数据类型，对某一事物整体描述/定义，但是并不能代表某一个具体事务。（人，动物，植物）

对象：是抽象概念的具体实例。（张三是人的一个具体事例）

构造器

作用：如果需要在实例化对象的同时就为这个对象的属性进行赋值，可以通过构造方法来实现。构造方法是类的一个特殊成员。

默认有一个无参构造器（隐藏的）

条件：1. 方法名与类名相同；

2. 在方法名前面没有返回值类型的声明

有参构造；无参构造

有参构造：

    //声明int类型的变量age
    int age;
    public Person(int a){
        age = a;   //为age属性赋值
    }
    
    //定义speak()方法
    public void speak(){
        System.out.println("我今年"+age+"岁了");
    }
}

public class Example{
    public static void main(String[] args){
        Person p = new Person(18); //实例化Person对象
        p.speak();
        
    }
}

快捷键：有参构造器自动生成快捷键：Alt+insert

注意点：定义了一个有参构造之后，如果想使用无参构造，必须显示的定义一个无参构造

抽象类

(1)通过abstract修饰的类

(2)抽象类，只有方法名字，没有方法的实现

(3)不能New这个抽象类，只能靠子类去实现它：通过extends关键字

(4)抽象类里面可以写普通方法，但是抽象方法必须写在抽象类中

接口

1. 区别：普通类：只有具体实现；抽象类：具体实现和规范都有；

   接口：只有规范，自己无法写方法，约束与实现相分离：面向接口编程

2. 接口的本质是契约

3. 声明接口的关键字是interface

4. 接口中的所有定义方法其实都默认是抽象的public abstract，常量默认为public static final

5. 可以通过implements实现接口，实现了接口的类，就需要重写接口中的方法，可以实现多个类

static静态类先执行

异常Exception

1. Error类对象由Java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关

2. 在Exception分支中有一个重要子类RuntimeExcetipn（运行时异常），这是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生

3. 异常处理机制

   • 发现异常 try

   • 捕获异常 catch

   • 抛出异常 throw :
     throw是语句抛出一个异常，一般是在代码块的内部，当程序出现某种逻辑错误时由程序员主动抛出某种特定类型的异常。

     public static void main(String[] args) { 
         String s = "abc"; 
         if(s.equals("abc")) { 
           throw new NumberFormatException(); 
         } else { 
           System.out.println(s); 
         } 
       }
     

     throws:
     1）throws 语句时用在方法声明后面，表示如果抛出异常，由该方法的调用者来进行异常的处理。
     2）throws 主要是声明这个方法会抛出某种类型的异常，让它的调用者要知道需要捕获的异常的类型。
     3）throws 表示表现出现异常的一种可能性，并不一定会发生这种异常

     
     public void function() throws Exception{......}
     
     
     public class testThrows {
      
         public static void function() throws NumberFormatException {
             String s = "abc";
             System.out.println(Double.parseDouble(s));
         }
      
         public static void main(String[] args) {
             try {
                 function();
             } catch (NumberFormatException e) {
                 System.err.println("非数据类型不能强制类型转换。");
             }
         }
     }
     
     

4. 快捷键：ctrl+alt+T

5. 用户自定义异常类：只需要继承Exception类即可

alt+enter：报错提示信息

​