面向对象编程

初识面向对象

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

面向过程：线性思维
面向对象：分类思维

什么是面向对象

回顾方法以及加深

return 结束方法，返回结果
参数列表 （参数类型，参数名）
static：和类一起加载的
…(可变参数)
静态方法（static）：可以直接调用（类名.方法名）
非静态方法（无static）：不可以直接调用
1、实例化这个类
2、对象类型 对象名 = 对象值
非静态方法，类实例化，之后才存在

值传递

//值传递
public class Demo01 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);//1
        change(a);
        System.out.println(a);//1
    }
    public static void change(int a){
        a = 10;
    }
}

引用传递

//引用传递：对象，本质上还是值传递
public class Demo2 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);//null
        Demo2.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;
}

类跟对象直接的关系

创建与初始化对象

构造器详解

public class Demo3 {
}
/*
public class Application {
    public static void main(String[] args) {
        Demo3 demo3 = new Demo3();
    }
}
 */

Demo3.class文件

一个类即使什么都不写，它也会存在一个方法
有参构造：一旦定义了有参构造，无参就必须显示定义

构造器作用（实例化初始值）
1、使用new关键子，本质是在调用构造器
2、用来初始化值
构造器特点
1、和类名相同
2、没有返回值

创建对象内存分析

栈相当于目录，堆相当于内容
方法区在堆中

小结

1、类和对象
类是一个模板：抽象，对象是一个具体的实例
2、方法
定义、调用！
3、对象的引用
引用类型： 基本类型（8）
对象是通过引用来操作的：栈----->堆
4、属性：字段 （Field） 成员变量
默认初始化：
数字：0 0.0
char： u000
boolean： false
引用： null
修饰符 属性类型 属性名 = 属性值；
5、对象的创建与使用
- 必须使用new关键字创造对象，构造器
- Person person = new Person();
- 对象的属性
- person.name
- 对象的方法
- person.sleep()
6、类：
静态的属性 属性
动态的行为 方法

封装详解

封装的作用

1、提高程序的安全性，保护数据
2、隐藏代码的实现细节
3、统一接口
4、系统可维护性增加了

继承

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

super

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

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

方法重写

重写都是方法的重写，和属性无关
静态方法

非静态方法

静态的方法和非静态的方法区别很大
静态方法：方法的调用只和左边，定义的数据类型有关
非静态方法：（方法重写）

重写：需要有继承关系，子类重写父类的方法！
1、方法名必须相同
2、参数列表必须相同
3、修饰符：范围可以扩大但不能缩小；public>protected>default>private
4、抛出的异常：范围，可以被缩小，但是不能扩大：
ClassNotFoundException --> Exception（大）

重写：子类的方法和父类必须要一致，方法体不同！

为什么需要重写？
父类的功能，子类不一定需要，或者不一定满足

多态

代码

多态注意事项
1、多态是方法的多态，属性没有多态
2、父类和子类，有联系 类型转换异常@！ClassNotFoundException
3、存在条件：继承关系，方法需要重写，父类引用指向子类对象！
father f1 = new Son（）；

static方法 ，属于类，它不属于实例
final 常量
private方法： 私有的
instanceof （类型转换） 引用类型

instanceof 和 类型转换

类型转换

父类引用指向子类对象
把子类转换为父类，向上转型
把父类转换为子类，向下转型：强制转换
方便方法的调用，减少重复的代码

static关键字详解

//static
public class Student {
    private static int age ; //静态的变量
    private String score ; //非静态的变量
    public void run(){
        go();
    }
    public static void go(){

    }
    public static void main(String[] args) {
        new Student().run();
        Student.go();
        Student s1 = new Student();
        System.out.println(Student.age);
        System.out.println(s1.score);
    }
}

静态代码块

public class Person {
    //2 赋初值（只执行一次）
    {
        //代码块（匿名代码块）（构造器之前）
        System.out.println("匿名代码块");
    }
    //1
    static {
        //静态代码块
        System.out.println("静态代码块");
    }
    //3
    public Person() {
        System.out.println("构造方法");
    }
    
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("================");
        Person person2 = new Person();
    }
}

执行结果

静态导入包

抽象类

提高开发效率

//abstract 抽象类 类extends：  单继承--
public abstract class Action {

    //约束  有人帮我们实现
    //abstract 只有抽象方法，只有方法名字，没有方法的实现
    public abstract void doSomething();

    //1.不能new这个抽象类，只能靠子类去实现它：约束！
    //2.抽象类中可以写普通方法
    //3.抽象方法必须写在抽象类中
    //抽象的抽象：约束
}


//抽象类的所有方法，继承了它的子类，都必须要实现它的方法，
public class A extends Action {
    @Override
    public void doSomething() {

    }
}

接口

//interface 定义的关键字 ， 接口都需要实现类
public interface UserService {
    //常量   public static final 
    int AGE = 99;
    //接口中所有定义其实都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}


public interface TimeService {
    void timer();
}


//抽象类  ： extends
// 类可以实现接口  implements 接口
//实现接口的类，就需要重写接口中的方法
//多继承-利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void timer() {
    }
    @Override
    public void add(String name) {
    }
    @Override
    public void delete(String name) {
    }
    @Override
    public void update(String name) {
    }
    @Override
    public void query(String name) {
    }
}

接口作用
1、约束
2、定义一些方法，让不同的人实现
3、public abstract
4、public static final
5、接口不能被实例化，接口中没有构造方法
6、implements可以实现多个接口
7、必须要重写接口中的方法

内部类

//成员内部类
public class Outer {
    private int id = 10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public class Inter{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性和私有方法
        public void getId(){
            System.out.println(id);
        }
    }
}
/**
 *  public static void main(String[] args) {
 *         //new
 *         Outer outer = new Outer();
 *         //通过这个外部类来实例化内部类
 *         Outer.Inter inter = outer.new Inter();
 *         inter.in();//这是内部类的方法
 *         inter.getId();//10
 *     }
 */

---

//静态内部类
public class Outer {
    private int id = 10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    //静态内部类无法直接访问非静态属性
    public static class Inter{
        public void in(){
            System.out.println("这是内部类的方法");
        }
    }
}

---

一个java文件可以有多个class类，但是只能有一个pblich class

---

public class Outer {
    //局部内部类
    public void method(){
        class Inner{
            public void in(){
                
            }
        }
    }
}

---

//匿名内部类的使用
public class Test {
    public static void main(String[] args) {
        //没有名字初始化类,不用将实例保存到变量中
        new Apple().eat();
        //匿名内部类
        UserService userService = new UserService(){
            @Override
            public void Hello() {
                
            }
        };
    }
}
class Apple{
    public void eat(){
        System.out.println("1");
    }
}
interface UserService{
    void Hello();
}

异常机制（Exception）

什么是异常

简单分类

异常体系结构

Error

Exception

异常处理机制

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        //假设要捕获多个异常：从小到大！
        try {//try监控区域

            if (b == 0)  { // throw throws
                throw new ArithmeticException();//主动的抛出异常
                //一般在方法中使用
            }
            System.out.println(a/b);

        }catch (ArithmeticException e){//catch(想要捕获的异常类型) 捕获异常
            System.out.println("程序出行异常，变量b不能为0");
            e.printStackTrace();
        }finally {//处理善后工作
            System.out.println("finally");
        }
        //finally 可以不要finally，假设IO，资源，关闭（可以使用）
        /**
         * 程序出行异常，变量b不能为0
         * finally
         */
    }
}

---

假设这方法中，处理不了这个异常，方法上抛出异常（throws）

---

自定义异常

快捷键
在idea中添加try/catch的快捷键
ctrl+alt+t（有的电脑是ctrl+win+alt+t）
选中想被try/catch包围的语句，同时按下ctrl+alt+t，

---

//自定义异常
public class MyException extends Exception {

    //传递数字>10；
    private int detail;
    public MyException(int detail){
        this.detail = detail;
    }

    //toString:异常的打印信息
    @Override
    public String toString() {
        return "MyException{" + "detail=" + detail +"}";
    }
}

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);
        }
    }
}
//传递的参数为11
//MyException=>MyException{detail=11}