Java面向对象

面向对象

面向对象&面向过程

面向过程

• 步骤简单清晰，第一步做什么，第二步做什么
• 面向过程适合处理简单的问题

面向对象

• 物以类聚，分类的思维模式，思考首先解决那些问题，然后对这些问题进行单独的思考。最后，对某个分类下细节进行过程思考
• 面向对象适合处理复杂的问题

---

什么是面向对象

• 面向对象编程（Object-Oriented Programming,OOP）
• 面向对象编程的本质是：以类的方式组织代码，以对象的组织（封装）数据
• 抽象
• 三大特征
  • 封装
  • 继承
  • 多态

例子

• 静态方法无法调用动态方法

package com.opp.demo1;

public class demo2 {
    public static void main(String[] args) {

    }
    // static 和类一起加载
    public static void a(){
        b();//无法调用，这里会报错
    }
    //对象创建之后才存在，即需要实例化
    public void b(){//这里要在void前面加上static

    }
}

---

• 类是传址，变量传值

package com.opp.demo1;

public class Demo4 {
    public static void main(String[] args) {
        //类传递的是地址，可以理解为类是一个具体的值
        
        //变量传递的是数值
        Person person=new Person();
        int a=10;
        System.out.println(person.name);		//null
        System.out.println(a);					//10
        change(a);
        change(person);
        System.out.println(person.name);		//lee
        System.out.println(a);					//10

    }
    public static void change(Person person){
        person.name="lee";
    }
    public static void change(int a){
       a=100;
    }
}

 class Person{
    String name;
 }

---

创建对象

对象是抽象概念的实例
使用关键字new来创建对象

---

构造方法

类中的构造器也被称为构造方法，是在进行创建对象的时候需要调用的。并且构造器有以下两点

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

构造器主要两个用途

一、无参构造

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

二、有参构造

1、一旦定义了有参构造，无参构造必须显式定义

---

封装

属性私有，get\set
通常应该禁止直接访问一个对象中的实际数据，而应该通过操作接口来访问，称为信息隐藏
println其实就是Java里面最大的重载

public class Room {
    //属性私有
    private String name;
    private int id;
    private char sex;
    private int age;

    public Room(){
        name="hedage";
    }
    //提供一些操作操作方法
    //提供一些public的get和set方法

    //get 获得这个数据
    public String getName(){
        return this.name;
    }
    //
       //set 给这个数据设置值
    public void setme(String name){
        this.name=name;
    }
    public int getAge(){
        return age;
    }

    /***
     * 提高程序安全性，保护数据
     * 隐藏代码细节
     * 统一接口
     * 系统可维护性增加
     *
     */

    //不合法返回三岁
    public void setAge(int age){
        if(age>120||age<0){
            this.age=3;
        }else{
            this.age=age;
        }
    }
}

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
extands的意思是“扩展”，子类是父类的扩展
Java中只有单继承，没有多继承
所有的类都默认继承object类
object类提供基础方法
私有的东西无法被继承

Super

super可以理解为是指向自己超（父）类对象的一个指针，而这个超类指的是离自己最近的一个父类。

比如super.name)\调用最近父级的name

---

super（参数）：调用父类中的某一个构造函数（应该为构造函数中的第一条语句）。
this（参数）：调用本类中另一种形式的构造函数（应该为构造函数中的第一条语句）。

class Country {
    String name;
    void value() {
       name = "China";
    }
}
  
class City extends Country {
    String name;
    void value() {
    name = "Shanghai";
    super.value();      //调用父类的方法
    System.out.println(name);
    System.out.println(super.name);
    }
  
    public static void main(String[] args) {
       City c=new City();
       c.value();
       }
}

运行结果：

Shanghai
China

---

接口

约束和实现的分离：面向接口编程

• 接口就是规范，定义的是一种规则
• 接口的本质是契约
• 接口的脊髓，就是对象的抽象

作用

1. 约束
2. 定义一些方法，让不同的人实现~10----->1
3. public abstract
4. public abstract final
5. 接口不能被实例化~，接口中没有构造方法
6. 必须要重写接口里面的方法

---

内部类

比如A类在里面定义一个B类

---

异常

异常指程序运行中出现了不期而至的各种情况
异常发生在程序运行期间，它影响了正常程序执行的流程

错误不是异常，而是脱离程序员控制的问题。错误在代码中常常被忽视

异常处理框架

public class demo1 {
    public static void main(String[] args) {
//        new demo1().a();
        int a=1;
        int b=0;

		//快捷键CTRL+alt+t异常快捷键
        try {//监控区域
            System.out.println(a/b);
        }catch (ArithmeticException e){//如果上面出现了ArithmeticException类底下的异常
            System.out.println("程序出现异常，变量不能为零");
        }catch (Throwable e) {//最大的异常放在最底下
            System.out.println("最大异常");
        }finally{
        } {//处理善后工做
            //finally 可以不用 finally正常都是执行一些关闭命令，节约资源；比如数据库
        }
    }
    public void a(){
        b();
    }
    public void b(){
        a();
    }
}