JavaSE面向对象编程OOP（学习狂神day04）

当前位置:

首页 > 编程开发 > Java教程 >

JavaSE面向对象编程OOP（学习狂神day04）

1.初识面向对象

面向对象编程：oop，
面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。
抽象
三大特性：封装、继承、多态
代码运行角度：先有类后有对象

2.方法回顾和加深

方法的定义：
- 修饰符
- 返回类型
- break：跳出switch，结束循环和return的区别。
- 方法名：注意规范，见名知意
- 参数列表：（参数类型，参数名）（可变参数...）
- 异常抛出：后面讲解
方法的调用
- 静态方法：
- 非静态方法：
- 形参和实参
- 值传递和引用传递
- this关键字

package com.oop.demo01;

public class Demo01 {
    public static void main(String[] args) {
        //静态方法 static
        //调用
        Student.say();

        //非静态方法 调用(创建一个new对象)
        Student student = new Student();
        student.say1();
    }

    //和类一起加载（可理解为static随类存在就已经存在）
    public static void a(){
        //b(); //会报错
    }

    //类实例化（new）之后才存在
    public void b(){

    }
}

package com.oop.demo01;

//引用传递：对象，本质还是值传递
//对象和内存
public class Demo03 {

    public static void main(String[] args) {
        Perosn perosn = new Perosn();
        System.out.println(perosn.name);  //null

        Demo03.change(perosn);
        System.out.println(perosn.name);  //师兄
    }
    public static void change(Perosn perosn){
        //perosn是一个对象，指向的：--->Perosn perosn = new Perosn();这是一个具体得人，可以改变其属性。
        perosn.name = "师兄";
    }
}
//定义一个Perosn类，有一个属性name
class Perosn{
    String name;
}

3.对象的创建和分析

类是一种抽象的数据类型，对某一类事物整体的描述，并不代表某一个具体的事物。
对象是抽象概念的具体实例。
使用new关键字创建对象：会分配好内存空间，还会给创建好的对象默认的初始化以及对类中构造器的调用。
类中的构造器也成为了构造方法，是在进行创建对象的时候必须要调用的，并且有以下特点：
- 必须和类的名字相同
- 必须没有返回类型，也不能写void
构造器必须掌握
构造器详解：

作用：

       1. new本质在调用构造方法
          始化对象的值
          **注意点**：
                     1. 定义了有参构造之后，若想使用无参构造，则必须显示无参的构造方法
                        Insert
                                this.当前类的属性=构造器的属性。

package com.oop.demo02;

public class Person {

    //一个类即使什么都不写，他也会存在一个方法
    //显示的定义构造器
    String name;
    int age;

    //默认构造器
    //1.使用new关键字，本质是在调用构造器
    //2.是用来初始化值的
    public Person() {

    }

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

    //构造器快捷键：ALT+Insert
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

/*
    public static void main(String[] args) {
        //new实例化了一个对象
        Person person = new Person("shixiong",23);
        System.out.println(person.name + person.age +"岁了");

    }

    构造器：
        1.和类名相同
        2.没有返回值
     作用：
        1.new本质在调用构造方法
        2.初始化对象的值
     注意点：
        1.定义了有参构造之后，若想使用无参构造，则必须显示无参的构造方法
     Alt+Insert
     this.当前类的属性=构造器的属性。


 */

创建对象内存分析：

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

4.面向对象三大特性

封装（数据的隐藏）：高内聚低耦合，高内聚（类的内部数据操作由自己完成）、低耦合（仅暴露少量的方法给外部使用）。

属性私有private，get/set

继承：本质是对某一类的抽象
extends的意思是扩展。子类是父类的扩展。
java中类只有单继承，没有多继承。（一个儿子只有一个爸爸，一个爸爸可以有多个儿子）
- 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
- 继承父类的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，用关键字extends来表示。
- 子类和父类之间，从意义上讲应该具有“is a”的关系。
[ ] object类：在Java中所有的类，都默认直接或间接继承object

[ ] super VS this

super注意点：
    1.super调用父类的构造方法，必须在构造方法的第一行
    2.super必须只能出现在子类的方法或者构造方法中！
    3.super和this不能同时调用构造方法！
VS this：
    代表的对象不同：
        this：本身调用者者对象
        super：代表父类对象的引用
    前提：
        this：没有继承也可以使用
        super：只能在继承条件才可以使用
    构造方法：
        this();本类的构造
        super();父类的构造

[ ] 方法重写：--->多态

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

为什么需要重新：
    1.父类的功能：子类不一定需要，或者不一定满足
    Alt + Insert：override（重写）

[ ] 多态
- 即同一个方法可以根据发送对象的不同而采用多种不同的行为方式
- 一个对象的实际类型是确定的，但可以指向对象的类型有很多
- 多态存在的条件：有继承关系、子类重写父类的方法、父类引用指向子类对象
- 注意：多态是方法的多态，属性没有多态性
- instanceof （类型转换）引用类型，判断一个对象是什么类型

多态注意事项：
1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系类型转换异常！ClassCastException！
3. 存在条件：有继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new Son();
4. 不能重写的方法：
  - static 方法，属于类，他不属于实例
  - final 常量
  - private方法
instanceof关键字：
1. 父类引用指向子类的对象
2. 吧子类转换为父类，向上转型
3. 吧父类转换为子类，向下转型：强制转换
4. 方便方法的调用，减少重复的代码！简介
抽象：封装、继承、多态！抽象类，接口

static关键字：代码块只执行一次

可以直接调用：

//静态导入包
import static java.lang.Math.random;

5.抽象类和接口

抽象类：abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法，如果修饰类，那么该类就是抽象类。
抽象类中可以没有抽象方法，但是有抽象方法的类一点要声明为抽象类
抽象类不能使用new关键字来创建对象，他是用来让子类继承的。
抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

接口：
- 普通类：只有具体实现
- 抽象类：具体实现和规范（抽象方法）都有！
- 接口：只有规范！专业的约束，约束和分离：面向接口编程
接口就是规范，定义一组规则
接口的本质就是契约。
OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、java、c等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。
声明类的关键字是class，声明接口的关键字是interface

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

6.内部类及OOP实战

内部类就是在一个类的内部在定义一个类。

一个Java类中可以有多个class类，但是只能有一个public class类

成员内部类

private int id = 45;
public void out(){
    System.out.println("这是外部类的方法");
};

public class Inner{        //加上一个static就是静态内部类，但id无发调用
    public void in(){
        System.out.println("这是内部类的方法");
    }

    /*public void getID(){
        System.out.println(id);
    }*/

//一个Java类中可以有多个class类，但是只能有一个public class类
class A{

}

静态内部类
局部内部类

public class Outer {

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

            }
        }
    }*/

匿名内部类

package com.oop.demo10;

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();
}

来源：https://www.cnblogs.com/sxstudy/p/15367485.html

栏目列表