前言:

推荐免费Java基础入门视频:【狂神说Java】Java零基础学习视频通俗易懂_哔哩哔哩_bilibili

什么是面向对象

  • 面向过程思想:
    • 步骤清晰简单,第一步,第二布…
    • 面对过程适合处理一些较为简单的问题。
  • 面向对象思想:
    • 物以类聚,分类的思维模式,思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。最后,才对某个分类下的细节进行面向过程的思索。
    • 面向对象适合处理复杂的问题,适合处理需要多人协作的问题!
  • 对于描述复杂的事物,为了从宏观上把握、从整体上合理分析,我们需要使用面向对象的思路来分析整个系统。但是,具体到微观操作,任然需要面向过程的思路去处理。
  • 面向对象编程(Object-Oriented Programming,OOP)

  • 面向对象编程的本质就是:以类的方式组织代码,以对象的组织(封装)数据。

  • 抽象

  • 三大特性:

    • 封装
    • 继承
    • 多态
  • 从认知论角度考虑是先有对象后有类。对象,是具体的事物。类,是抽象的,是对对象的抽象。

  • 从代码运行角度考虑是现有类后又对象。类是对象的模板。

回顾方法的定义

  • 方法的定义:

    • 修饰符
    • 返回类型
    • break和return的区别
    • 方法名
    • 参数列表
    • 异常抛出
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    //main方法
    public static void main(String[] args) {
    }
    /*
    修饰符 返回值类型 方法名(...)
    */
    public String sayHello(){
    return "Hello World";
    }
    public int max(int a,int b){
    return a>b?a:b; //三元运算符
    }
    //抛出异常
    public void readFile(String file) throws IOException {

    }

回顾方法的调用

  • 方法的调用:

    • 静态方法
    • 非静态方法
    • 形参和实参
    • 值传递和引用传递
    • this关键字
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    package com.jokerdig.oop;

    /**
    * @author Joker大雄
    * @data 2021/8/14 - 18:01
    **/
    public class Demo02 {
    //静态方法 static
    //非静态
    public static void main(String[] args) {

    // Student student = new Student();
    // student.say();
    int a= add(1,2);
    System.out.println(a);
    //值传递
    int b = 1;
    System.out.println(b);//1
    Demo02.change(b);
    System.out.println(b);//1

    //引用传递
    Person person = new Person();
    System.out.println(person.name);//null
    Demo02.change(person);
    System.out.println(person.name);//引用传递值
    }
    //static和类一起加载
    public static void a(){
    //b();
    }
    //类实例化之后才存在
    public void b(){
    }
    //形参
    public static int add(int a,int b){
    return a+b;
    }
    //传递值,返回值为空
    public static void change(int b){
    b=10;
    }

    public static void change(Person person){
    //person是一个对象,修改类Person类里的全局变量name
    person.name="引用传递值";
    }
    }
    //定义了一个Person类,有一个属性 name
    class Person{
    String name;//null
    }

类与对象的创建

类与对象的关系:

  • 类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物。
    • 动物、植物、手机、电脑….
    • Person类、Pet类、Car类等,这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为。
  • 对象是抽象概念的具体实例
    • 张三就是人的一个具体实例,张三家里的旺财就是狗的一个具体实例。
    • 能够体现出特点,展现出功能的是具体的实例,而不是一个抽象的概念。

创建与初始化对象:

  • 使用new关键字创建对象

  • 使用new关键字创建的时候,除了分配内存空间之外,还会给创建好的对象进项默认的初始化以及对类中构造器的调用。

  • 类中的构造器也称为构造方法,实在进行创建对象的时候必须要调用的。并且构造器有以下两个特点:

    • 必须和类的名字相同
    • 必须没有返回类型,也不能写void
  • 构造器必须要掌握

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    //Application类

    //一个项目应该只存在一个main方法
    public class Application {
    public static void main(String[] args) {
    //类:抽象的,实例化new
    Student student = new Student();
    Student student1 = new Student();

    student.name="小明";
    student.age=10;

    System.out.println(student.name);
    System.out.println(student.age);

    student1.name="小红";
    student1.age=9;
    System.out.println(student1.name);
    System.out.println(student1.age);

    }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    //Student类
    public class Student {

    //属性:字段
    String name;
    int age;

    //方法
    public void study(){
    System.out.println(this.name+"在学习");
    }

    //方法
    public void say(){
    System.out.println("学生上课偷偷说话");
    }
    }

构造器详解

  • 构造器

    • 和类名相同
    • 没有返回值
  • 作用:

    • new 本质在调用构造方法
    • 初始画对象的值
  • 注意:

    • 定义有参构造后,如果想用无参,显示的定义一个无参构造
  • 实例化初始值:

    • 使用new关键字,本质是在调用构造器
    • 用来初始化值
    • alt+ins(insert) 生成构造器快捷键
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    //一个类即使什么都不写,也会存在一个方法,为构造器
    String name;
    //实例化初始值

    //无参构造
    public Persons(){
    // this.name = "构造器测试名字";
    }

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

    //main
    public static void main(String[] args) {
    //实例化对象
    // Persons person = new Persons();
    Persons person = new Persons("有参构造");
    System.out.println(person.name);
    }

创建对象内存分析

  • 创建对象内存简单分析

    f612kt.png

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    //pet类
    public class Pet {
    String name;
    int age;

    public void shout(){
    System.out.println("叫了一声");
    }
    }
    //main
    public static void main(String[] args) {
    Pet dog = new Pet();
    dog.name="二狗";
    dog.age = 3;
    dog.shout();
    }

简单小结类与对象

  • 类与对象:
    • 类是一个模板:抽象,对象是一个具体的实例。
  • 方法:
    • 定义,调用
  • 对应的引用:
    • 引用类型:基本类型
    • 对象是通过引用来操作的:栈 -> 堆
  • 属性:字段Field 成员变量
    • 默认初始化:
      • 数字:0 0.0
      • char:u0000
      • boolean:false
      • 引用:null
    • 修饰符:属性类型 属性名 =属性值
  • 对象的创建和使用
    • 必须使用new关键字创建对象,构造器
    • 对象的属性
    • 对象的方法
  • 类:
    • 静态的属性
    • 动态的方法

封装详解

  • 该露的露,该藏的藏

    • 我们程序设计要追求”高内聚,低耦合“。高内聚就是类的内部数据操作细节自己完成,不允许外部干涉;低耦合:仅暴露少量的方法给外部使用。
  • 封装(数据的隐藏)

    • 通常,应该禁止直接访问一个对象中数据的实际表示,而通过操作接口来访问,这称谓信息隐藏。
  • 记住这句话:属性私有,get/set

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
      //private 私有
    /*
    封装的优势:
    1. 提高程序的安全性,保护数据
    2. 隐藏代码的实现细节
    3. 同意接口
    4. 系统可维护性增加
    */

    private String name; //名字
    private int id; //学号
    private char set; //性别

    //get/set方法
    //get获取这个数据
    public String getName() {
    return this.name;
    }

    public void setName(String name) {
    this.name = name;
    }
    //main
    public static void main(String[] args) {
    Students st = new Students();
    st.setName("通过set赋值name");
    System.out.println(st.getName());

    }

什么是继承

  • 继承的本质是对某一批类的抽象,从而实现对像是世界更好的建模。
  • extands的意思是”扩展”。子类是父类的扩展。
  • Java中类只有单继承,没有多继承!
  • 继承是类和类之前的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等
  • 继承关系的两个类,一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
  • 子类和父类之间,从意义上将应该具有”is a”的关系。
  • object类(每个类都默认继承)

    1
    2
    3
    4
    5
    6
    7
    //继承
    Person01 per = new Person01();
    //name是persons中定义的
    // 当person01继承persons时也可使用其中公共的方法等
    per.name="222";
    System.out.println(per.name);
    //Java中所有的类都默认继承Object

super详解

  • super

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

    • 代表的对象不同,this调用本对象,super调用父类的应用。
    • this没有继承也可以用,super只能在继承条件才可以使用。
    • this();本类的构造,super();父类的构造。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    //继承
    public class Person01 extends Persons{
    private String name1="子类super";

    public void test(String name1){
    System.out.println(name1);//传输的值
    System.out.println(this.name1);//当前类的值
    System.out.println(super.name1);//父类的值
    }
    public void print(){
    System.out.println("子类print方法");
    }
    //方法也可访问
    public void test1(){
    print();
    this.print();
    super.print();
    }

    public Person01() {
    //隐藏代码:调用了父类的无参构造
    super();//这里默认隐藏了,必须在第一行
    System.out.println("person01");
    }
    }
    //main
    public static void main(String[] args) {
    //super
    Person01 per = new Person01();
    per.test("main测试super");
    }

方法的重写

  • 重写需要有继承关系,子类重写父类的方法。

  • 重写要求:

    • 方法名必须相同。
    • 参数列表必须相同
    • 修饰服:范围可扩大但不能缩小。(public>protected>default>private)
    • 抛出的异常:范围可以被缩小但不能扩大。
  • 重写子类的方法必须和父类一致,方法体不同。

  • 重写原因:

    • 父类的功能,子类不一定需要或不能满足子类需求。
    • Alt+Ins :override
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    //A类
    public class A extends B{
    //重写

    @Override
    public void test() {
    System.out.println("A->test");
    }
    }

    //B类
    public class B {
    //重写都是方法的重写
    public void test(){
    System.out.println("B->test");
    }
    }
    //main
    public static void main(String[] args) {
    //方法重写
    A a = new A();
    a.test();
    //有继承关系后,父类的引用指向了子类
    B b = new A();
    b.test();
    }
    }