日常学Java的笔记（四）-面向对象

面向过程 & 面向对象
- 什么是面向对象
类与对象的关系
构造器
this关键字
小结：
封装
标准JavaBean
继承
成员变量和局部变量区分

面向过程 & 面向对象

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

什么是面向对象

面向对象编程（Object Oriented Programming，OOP）
面向对象的本质就是：以类的方式组织代码，以对象的方式组织（封装）数据
抽象
三大特性：
- 封装
- 继承
- 多态
从认识的角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。
从代码运行角度考虑是先有类后又对象。类是对象的模板。

类与对象的关系

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

能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念

package com.oop.demo02;

public class Student {
    //属性：字段
    String name;//null
    int age;//0

    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}
/*
 //类：抽象的，需要实例化
        //类实例化后会返回一个自己的对象！
        //student对象就是Student类的具体实例
        Student xh = new Student();
        Student xm = new Student();
        xh.name = "小红";
        xh.age = 3;

        xm.name = "小明";
        xm.age = 4;
        System.out.println(xh.name);
        System.out.println(xh.age);
        System.out.println(xm.name);
        System.out.println(xm.age);
        xm.study();
 */

构造器

构造器的作用：

初始化类的对象，并返回对象的地址
构造器有几种，各自的作用：
1. 无参构造器：初始化的对象时，成员变量均采用默认值。
2. 有参构造器：在初始化对象时，同时可以为对象赋值。
构造器的注意事项
1. 任何类定义出来，默认就自带了无参构造器，写不写都有
2. 一旦定义了有参构造器，无参构造器就没有了，此时就需要自己手动写无参构造器了

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

类中的构造器也称构造方法，是在进行创建对象是必须要调用的。并且构造器有以下两个特点：

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

package com.oop.demo02;

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

    //art+insert
    //1.使用new关键字，本质上是在调用构造器
    //2.用来初始化值
    public Person() {
    }
    //有参构造：一旦定义了有参构造，无参构造就必须显示定义

    public Person(String name) {
        this.name = name;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
/*
    public static void main(String[] args) {
        //new 实例化了一个对象
        Person person = new Person("陈太帅",18);
        System.out.println(person.name);
    }

    构造器：
    1.和类名相同
    2.没有返回值
    作用：
        1.new本质在调用构造器
        2.初始化对象的值
    注意点：
        1.定义了有参构造后，如果想使用无参，必须显示定义一个无参的构造
    Alt+insert
 */

this关键字

作用：出现在成员方法中、构造器中，代表当前对象的地址，用于访问当前对象的成员变量、成员方法。

小结：

类与对象

类是一个模板：抽象，对象是一个实例
方法

定义，调用

对象的引用

引用类型：基本类型（8）种

对象是通过引用来操作的：栈--->堆
属性：字段：Field 成员变量

默认初始化：

数字： 0 0.0

char： u0000

boolean: false

引用： null

修饰符属性类型属性名 = 属性值
对象的创建和使用
1. 必须使用new关键字来创建对象，构造器 Person person = new Person ( );
2. 对象的属性 person.name
3. 对象的方法 person.eat( )
类：
1. 静态的属性属性
2. 动态的方法方法
3. 类名首字母建议大写、英文、有意义，满足驼峰模式，不能用关键字，满足标识符规定；
4. 一个代码文件中可以有多个类，但是只有有一个类是由public修饰的，public修饰的类必须是java代码的文件名称
成员变量的格式：
1. 成员变量完整定义的格式：修饰符数据类型变量名 = 初始化值；
2. 一般无需指定初始化值，存在默认值

封装

该露的露，该藏的藏
- 我们程序设计要追求"高内聚，低耦合"。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装（数据的隐藏）
- 通常，应禁止直接访问一个对象中数据的实际表示，而应当通过操作接口来访问，这称为信息隐藏。
记住：属性私有，get/set

package com.oop.demo03;

public class Student {
    //定义私有属性
    public String name;//名字
    private int age;//学号
    private char sex;//性别

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

    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }

    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if (age<0 || age>120){
            this.age = 3;
        }else {
        this.age = age;
        }
    }
    public char getSex(){
        return sex;
    }
    public void setSex(char sex){
        this.sex = sex;
    }
}
/*
1.提高程序的安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.增加系统的可维护性

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

        Student s1 = new Student();
        s1.setName("陈太帅");
        s1.setAge(18);
        s1.setSex('男');
        System.out.println(s1.getName()+s1.getAge()+s1.getSex());
    }
}*/

标准JavaBean

成员变量前必须要用private修饰
必需配有成套的get/set方法
必须构造一个无参构造方法

继承

继承的本质是对某一批类的抽象，从而实现对世界更好的建模
extends的意思是"拓展"、子类是父类的拓展
java中只有单继承，没有多继承（一个儿子只能有一个爸爸，而一个爸爸可以有多个儿子）
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends表示
子类和父类之间，从意义上讲应该具有"is a "的关系

Object类

package com.oop.demo05;

public class Person {
    public Person() {
        System.out.println("Person的无参构造执行了");
    }

    protected String name = "父类定义的名";
    public void print(){
        System.out.println("Person");
    }
}

package com.oop.demo05;

public class Student extends Person {

    public Student(){
        //隐藏代码：调用了父类的无参构造
        super();//调用父类的构造器必须在子类构造器的第一行
        System.out.println("Student的无参构造执行了");
    }
    private String name = "当前类";
    public void print(){
        System.out.println("Student");
    }
    public void test1(){
        print();
        this.print();
        super.print();
    }
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

package com.oop;
import com.oop.demo05.*;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.test("我是实参");
        student.test1();
    }
}

output:
		Person的无参构造执行了
        Student的无参构造执行了
        我是实参
        当前类
        父类定义的名
        Student
        Student
        Person

super

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

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

为什么需要重写：

1. 父类的功能子类不一定需要，或者不一定满足 Alt+insert：override

成员变量和局部变量区分

区别	成员变量	局部变量
类中位置不同	类中，方法外	常见于方法中
初始化值不同	有默认初始值	没有，使用之前要赋值
内存位置不同	堆内存	栈内存
生命周期不同	随着对象的创建而存在，随着对象的消失而消失	随着方法的调用而存在，随着方法的运行结束而消失
作用域不同		在所属的大括号中

posted @ 2022-01-07 11:10 tryAgainCs 阅读(37) 评论(0) 编辑收藏举报

刷新页面返回顶部

再试一次Again

日常学Java的笔记（四）-面向对象

面向过程 & 面向对象

什么是面向对象

类与对象的关系

构造器

this关键字

小结：

封装

标准JavaBean

继承

成员变量和局部变量区分

公告