2021-06-13

1.初识面向对象

·物以类聚，分类的思维模式。
· 面向对象编程OOP
**·面向对象编程的本质：**以类的方式组织代码，以对象的方式 封装数据。
**三大特性：**封装、继承、多态

2.方法回顾和加深

方法的定义：

• 修饰符
• 返回类型
• break和return的区别
• 方法名
• 参数列表
• 异常抛出

package com.dyo.OOP;

import java.io.IOException;

//Demo01 类
public class Demo01 {
    //main 方法
    public static void main(String[] args) {

    }
    /*
    修饰符 返回值类型 方法名（）{
        //方法体
        return 返回值；
    }
     */
    public String sayHello(){
        return "hello,world";
    }

    public void hello(){
        return;//void 可不写返回值
    }

    public int max(int a,int b){
        return a>b?a:b;//三元运算符
    }

    //=======break和return的区别
    //return结束方法，返回一个结果
    //break：跳出switch和结束循环

    //异常抛出示例
    public  void readFile(String file) throws IOException {

    }
}

方法的调用：

• 静态方法
• 非静态方法
• 形参和实参
• 值传递和引用传递
• this关键字

package com.dyo.OOP;

public class Demo02 {
    public static void main(String[] args) {
        //如果是静态方法，直接调用
//        Student.say();

        //无法直接调用非静态方法
        //需要实例化这个类  new
        Student student = new Student();

        student.say();
    }

    public void a(){
        b();//a可以直接调用b；或两者都是静态方法时，可互相调用
    }
    public void b(){

    }
    public static void c(){
        b();//错误
            //c是和类一起加载的，存在时间特别早
            //类实例化之后，b才存在
    }

}

package com.dyo.OOP;

public class Demo03 {
    public static void main(String[] args) {
        //调用add()方法1
        new Demo03().add(1,4);
        //调用add()方法2:add方法加static成为静态方法再调用
//        int add = Demo03.add(1,5);
//        System.out.println(add);
    }

    public int add(int a , int b){
        return a+b;
    }
    
}

package com.dyo.OOP;
//值传递
public class Demo04 {
    public static void main(String[] args) {
        int a = 1;
        Demo04.change(a);
        System.out.println(a);//1
        //change里的a是一个形参，并未返回一个结果
        //a=10只是走了一个过程，并未返回
    }
    //返回值为空
    public static void change(int a) {
        a= 10;
    }

}

package com.dyo.OOP;
//引用传递：对象，本质还是值传递
public class Demo05 {
    public static void main(String[] args) {
       Person person = new Person();

        System.out.println(person.name);//null

        Demo05.change(person);
        System.out.println(person.name);//小白
    }

    public static void change(Person person  ){
        //person是一个对象，指向的是第五行的——>Person person = new Person();
        //这是一个具体的人，可以改变属性
        person.name="小白";
    }
}
//定义一个Person类，有一个属性：name
class Person{
    String name;//null

}

3.对象创建分析

类：一种抽象的数据类型，是对某一类实物整体描述，但不能代表某一个具体事物。 对象是具体的事物，类是对象的抽象。

package com.dyo.OOP.Demo02;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

//一个项目里只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //类是抽象的，需要实例化
        //类实例化后会返回一个自己的对象
        //student对象就是一个Student类的具体实例
//    Student student = new Student();

        Student xiaoming = new Student();
        Student xiaohong = new Student();
        
        xiaoming.name = "小明";
        xiaoming.age = 3;

        System.out.println(xiaohong.name);
        System.out.println(xiaohong.age);
    }
}

——构造器详解——
特点：

1. 必须和类的名字相同
2. 从

package com.dyo.OOP.Demo02;

public class Person {
    //一个类即使什么都不写，也会存在一个方法
    //以下就是一个无参构造

    String name;

    //实例化
    //构造器核心内容
    //1.使用new关键字，必须要有关键字，本质是在调用构造器
    //2.构造器用来初始化值
    public Person(){
        this.name = "dyo";
    }


    //有参构造:一旦定义了有参构造，无参就必须显示定义
    public Person(String name){
        this.name = name;
    }
}

4.面向对象三大特性**

**封装：**属性私有，set/get
1.提高程序的安全性
2.隐藏代码细节
3.统一接口
4.系统可维护性增加

package com.dyo.OOP;

import com.dyo.OOP.Demo04.Student;
import com.dyo.OOP.Demo03.Pet;

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("小白dyo");

        System.out.println(s1.getName());
    }
}

package com.dyo.OOP.Demo04;
//类    private：私有
public class Student {
    //=======属性私有==========
    private String name;//名字
    private char sex;//性别
    private int id;//ID

    //提供一些可以操作这些属性的方法
    //set和get方法

    //get获得这个方法
    public String getName(){
        return this.name;
    }

    //set给这个数据设置值
    public void setName(String name){
        this.name = name;
    }

}

继承:
——是类与类之间的一种关系。
//所有类都默认直接或间接继承Object
//java中类只有但继承，没有多继承

package com.dyo.OOP;


import com.dyo.OOP.Demo05.Student;

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

        Student student = new Student();
        student.say();

        System.out.println(student.getMoney());
    }
}

package com.dyo.OOP.Demo05;
//Person:父类
public class Person {

    private int money = 10_0000_0000;//子类无法直接调用
    public void say(){
        System.out.println("hello");
    }
    //帮助获取私有属性
    public int getMoney() {
        return money;
    }

    public void setMoney(int money){
        this.money = money;
    }
}

======Super详解
注意点

• super调用父类的构造方法，必须在构造方法的第一个
• super必须只能出现在子类的方法或构造方法中
• super和this不能同时调用构造方法

Super VS this

• 代表对象不同：
  this：本身调用这个对象
  super：代表父类对象的应用
• 前提：
  this：没有继承也可以使用
  super：只能在继承条件下才可以使用
• 构造方法：
  this()：本类的构造
  super()：父类的构造

===方法重写
重写：需要有继承关系，子类重写父类

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可扩大，但不能缩小public>protected>default>private
4. 抛出的异常，范围可以被缩小，但不能扩大。

=多态注意事项=

1. 多态是方法的多态
2. 父类和子类，有联系
3. 存在条件：方法需要被重写，父类引用指向子类对象

package com.dyo.OOP;

import com.dyo.OOP.Demo06.Person;
import com.dyo.OOP.Demo06.Student;

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //Studen能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //Person父类型，可以指向子类，但不能调用子类独有的方法
        //父类的引用指向子类
        Person s2 = new Student();
        Object s3 = new Student();

        //
//        s2.eat();
        s2.run();
        s1.run();
    }
}

package com.dyo.OOP.Demo06;

public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}

package com.dyo.OOP.Demo06;

public class Person {
    public void run(){
        System.out.println("run");
    }
}

5.抽象类和接口

抽象

1. abstract，抽象方法，只有方法名字，没有方法的实现
2. 不能new这个抽象类，只能靠子类去实现它
3. 抽象类中可以写普通方法
4. 抽象方法必须在抽象类中

接口
作用：

1. 约束
2. 定义一些方法，让不同的人实现
3. 方法都是public abstract
4. 常量都是public static final
5. 接口不能被实例化
6. implement可以实现多个接口
7. 必须要重写接口中的方法

6.异常

1. 异常的定义（Exception）：
   程序运行中出现的不期而至的各种状况，如：文件找不到，网络连接失败，非法参数。
   简单分类：检查性异常；运行时异常；错误error。
2. 异常体系结构
   Java把异常当做对象来处理，并定义一个基类java.Throwable作为所有异常的超类。
   Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception。
3. Java异常处理机制
   五个关键词：try、catch、finally、throw、throws
4. 处理异常
5. 自定义异常