07-面向对象基础（抽象）

最新推荐文章于 2024-05-30 16:22:47 发布

静者，随心

最新推荐文章于 2024-05-30 16:22:47 发布

阅读量993

点赞数 1

分类专栏： Java基础文章标签： java 开发语言

本文链接：https://blog.csdn.net/yc_Cabbage/article/details/126174718

版权

Java基础专栏收录该内容

20 篇文章 1 订阅

订阅专栏

引言

面向对象是一种编程思想，是程序员思考问题的思维方式，以此为编程思想指导的程序设计，又称为面向对象程序设计( Object-Oriented Programing ,OOP，OOD,OOA ),面向对象设计思想，关注点为对象( 任何事物，万事万物 )，而非具体过程。

面向过程编程思想：也是一种编程思维，它关注的就是问题解决的步骤和实现过程，这种编程思维往往涉及到细节数据结构和算法本身。

对于不同编程思想，有不同的语言，C语言就是典型面向过程的设计语言，Java 就是面向对象的程序设计语言。

自我理解：

面向过程设计：事物的表现形式，我们只是把表现出来的形式，转化成程序代码。（它当事物发生的时候，我们才去想办法解决）
面向对象设计：根据事物的表现形式，透过表现看事物的本质，预判事物未来的发展趋势。

事物表现形式：属性和行为（面向对象的必要条件）

一. 面向对象中的类【重点】

面向对象关注的是对象，需要先理解类是什么。

1.1 类的阐述

类，是指具有相同属性和行为的一类事物的统称，相同类型事物，都具有相同属性和行为，通过类可以来把事物进行有效划分。

1.2 类的定义

在编程实践中，类通过 class 关键字定义，通常类也是面向对象程序设计的一个单元，我们在思考问题的时候，通常也是编写一个类，通过在类中抽取这类事物的属性和行为。

//定义一个类
[修饰符] class Coder{

}

1.3 类的成分

1.3.1 概括

类的抽取，往往通过属性和行为两个维度来提取。这两个维度恰好也从静态和动态两个方面对事物进行概括，属性往往描述的是事物静态的信息，行为往往就是动态方面的信息，比如描述一个人，姓名性别年龄等这些都是静态的信息。而看书，读报，撩妹都是动态的信息，一个事物通过这方面描述几乎就可以很全面的勾勒出事物的轮廓。

属性：存储状态，本质就是一个变量
行为 : 存储功能，本质就是一个方法/函数

1.3.2 属性定义语法

[修饰符] 数据类型  属性名
          String    name;
 public   String    name;

对于一个事物它的属性是非常非常多的，并不需要写完，只写你关注的，业务需要属性。

1.3.3 方法定义语法

此部分内容，在《函数》章节提过，这里定义的方法为实例方法也就是没有static

public  dataType|void method_name([ dataType var1, ...., ]){
    语句;
    [return value]
}

1.3.4 一个类的示例

class Coder{
   String name;
   int age;
   // 其他属性 .....
    
   public void sayHello(){
      System.out.println("hello");
   } 
   // 其他行为 ...... 
}

package com.qf;

/**
 * @author ：_my
 * @date ：Created in 2022/1/14 10:10
 * @description：类的定义
 * @modified By：`
 * @version: 1.0
 */

/**
 * [修饰符]+class+[标识符]+{}
 * 修饰符：保护的我类  访问层级（通俗讲：class 作用域不同，也权限）[public  默认  protected  private]
 * class 关键字： 定义我们的类  if 肯定条件
 * 标识符 ：由我们自己定义(驼峰命名)
 * {} 一个类的作用域范围[ 我们变量和方法]
 */


public class MyObject {

// 属性----> 变量（全局变量和局部变量）
// 全局变量：放在类中，方法外 称为：全局变量
//局部边框：放在方法内或者方法的参数 称为：局部变量

    //变量的定义：[修饰符]+数据类型+标识符 +赋值符号+值（修饰符可以用class 修饰符）
    //修饰符：[public  默认  protected  private]
    //全局变量[成员变量]  “可以省略” 赋值符号 和值
     int age;
// 行为-----> 方法  [修饰符 ] +[static]+数据类型(所有类型|void) +标识符 +（[参数类型]）+{ [return]}
    //修饰符：[public  默认  protected  private]，如果没有static 关键字 叫实例方法
    //static:如果加上static 这个方法叫 静态方法
    //返回值：数据类型(所有类型|void)，如果没有返回值 你必须加上void关键字（不需要return），如果有返回值，必须和return使用；
    //标识符:看我的方法定义章节
    //（[参数类型]）: 传参（形参）
    //{} ：代码块

    public static void main(String[] args) {


    }

    public  void myMethod(){

    }


}

二. 面向对象中的对象【重点】

2.1 对象的阐述
对象，是一类事物的具体实例，所以对象也称为类的实例，类只是描述了该类事物具有哪些属性和行为，只是一个模板，编程中，需要通过这个类模板，刻画出一个具体实例，比如，有一个Coder类它描述的是程序员类，它虽然记录了有哪些属性和方法，但是，具体的属性值是多少需要存在一个真是的载体，这个载体就是对象。比如这个程序员对象就是张三年龄 20 会打招呼。
对象是类的实例类是对象的模板。一个类可以实例化无数个对象。

2.2 对象创建
对象的创建需要通过 new 关键字来实现。

Java
复制代码

1
// 对象创建语法
2
类名对象名 = new 类名();
3

需要思想提升的是，** 咱们自己定义的类，它也是一种数据类型，且是一种自定义类型**，当然也可以完成其他类型完成的事情，比如定义变量，定义参数, 作为返回值类型
只不过，使用自定义类型声明的变量，咱们通常把它叫做对象名。

class TestCoder{
   public static void main(String[] args){
      
       int    a    = 10;
       coder.name = "张三";
       coder.age = 30;
       coder.sayHello();
   }
}

2.3 对象内存分布

对象是自定义类的实例，自定义类是一种引用数据类型，所以这里和前面章节学的数组一样，对象也是一种引用数据类型，它的存储必然也分堆栈，对象本质在堆内申请空间，对象引用被存在栈里面。
图：

2.4 类与对象的关系

类和对象的关系就是，抽象与实体的关系，图纸与实物的关系，一个类可以实例化出多个对象，每个对象拥有独立的内存空间，尤其是实例属性，各自有一份。
图：

一个类可以实例化出 N 个多个对象

 public static void main(String[] args) {
        // 创建对象的规则：[自定义数据类型]+标识 + 赋值符号 +方法
        // 对象的组成：变量和方法,(new 关键)；赋值符号左边就是变量，右边就是对象关键字和方法
        //Person xl  自定义变量(类的名字+标识符) ，它其实就一个 引用变量  int 【】 xx = new int[]
        //new 关键字 是创建对象的关键字
        //Person（）；方法（构造方法） //初始化我们的对象


        Person xl3 = new Person();
        Person xl = new Person("name"); //创建我实体对象 ，小李
        Person xl2 = new Person("name","sex");


        //Person xl = new Person(); //创建我实体对象 ，小李
//        Person lw = new Person(); //创建我实体对象 ，老王
//        Person xlxf = new Person(); //创建我实体对象 ，小李媳妇

//        xl.name = "小李";
//        xl.sex="男";
//
//        String msg = xl.fight("小李", "打老王");
//
//        String msg2 = xlxf.help("小李媳妇帮忙去打小李");
//
//        System.out.println(msg+","+msg2);


    }

2.5 自定义类型可以做什么？

1 定义数组

public class Dog {
    String name;
    int age;
    char gender;
    public void  bark(){
        System.out.println("一条"+age+"岁的"+gender+"狗"+name+"狂吠...");
    }
}

public class Main {

    public static void main(String[] args) {

        Dog[] dogs = new Dog[3];

        Dog d1 = new Dog();
        d1.name = "旺财";
        d1.gender ='公';
        d1.age = 3;

        Dog d2 = new Dog();
        d2.name = "来福";
        d2.gender ='公';
        d2.age = 4;

        Dog d3 = new Dog();
        d3.name = "馒头";
        d3.gender ='母';
        d3.age = 5;

        dogs[0] = d1;
        dogs[1] = d2;
        dogs[2] = d3;

        for(int i=0; i<dogs.length; i++){
            dogs[i].bark();
        }

    }
}

2 作为参数类型

/**
 * 光碟
 */
public class CD {
    //定义名字
    String movie ;
    //时长
    int time;
    //类型
    String type;

    //这里不写方法，我们认为它只是数据载体，不具备功能。
}

/**
 * DVD播放器
 * 1. 自定义类型做参数
 */
public class DVD {

    //品牌
    String brand;

    //纠错等级
    int repairLevel;

    public void play( CD cd ){
        System.out.println("影碟机:"+brand+":"+repairLevel+"级纠错功能");
        System.out.println("读碟中...请稍后..");
        try{  Thread.sleep(2000);  }catch (Exception e){   };
        System.out.println("影片:"+cd.movie);
        System.out.println("时长:"+cd.time+"分钟");
        System.out.println("类型:"+cd.type);
    }
}

3 作为返回值类型

/**
 * 自定义一个类
 * 奖品
 */
public class Prize {
       //名字
      String name;
      //加载
      double price;
}

/**
 * 人
 */
public class Person {

    String name;

    public Prize lottery(){
        //声明一个用于返回的对象
        Prize obj = null;
        Random random = new Random();
        int code =   random.nextInt(4);
        switch (code){
            case 0:
                obj = new Prize();
                obj.name = "卫生纸";
                obj.price = 4;
                break;
            case 1:
                obj = new Prize();
                obj.name = "电冰箱";
                obj.price = 4000;
                break;
            case 2:
                obj = new Prize();
                obj.name = "电饭锅";
                obj.price = 500;
                break;
            case 3:
                obj = new Prize();
                obj.name = "烧水壶";
                obj.price = 100;
                break;
        }
        return obj;
    }
}

**体会：自定义类型就是一种数据类型和其他类型具有相同的合法地位，可以定义变量作为参数类型返回值类型 **

demo 登录和注册

package com.qf.fq;

/**
 * @author ：zgz
 * @date ：Created in 2022/1/14 14:07
 * @description：用户对象
 * @modified By：`
 * @version: 1.0
 */
public class User {
    String userName;
    String passWord;

    public User(){}

    //注册
    public User(String userName,String passWord){
        //this 指定就是我们的当前对象
        this.userName = userName;
        this.passWord = passWord;
    }

    /**
     * 注册
     * @param user
     * @return
     */
    public String res(User user){
        this.userName = user.userName;
        this.passWord = user.passWord;

        return "注册成功";
    }

    public User login(String userName,String passWord){
        User user = new User();
        if(!this.userName.equals(userName)
                || !this.passWord.equals(passWord)){
            System.out.println("登录失败");
            user.userName = userName;
            user.passWord = passWord;

            return user;
        }

        user.userName = userName;
        user.passWord = passWord;

        return user;

    }

}


    public static void main(String[] args) {
        // 创建对象的规则：[自定义数据类型]+标识 + 赋值符号 +方法
        // 对象的组成：变量和方法,(new 关键)；赋值符号左边就是变量，右边就是对象关键字和方法
        //Person xl  自定义变量(类的名字+标识符) ，它其实就一个 引用变量  int 【】 xx = new int[]
        //new 关键字 是创建对象的关键字
        //Person（）；方法（构造方法） //初始化我们的对象

        //这是第一种操作方式
        User user = new User("zs","123456");//注册信息

        user = user.login("zs","123456");//登录信息

        System.out.println(user.userName+"=="+user.passWord);

        //第二种 操作方式

        User user1 = new User();
        user1.userName = "ls";
        user1.passWord = "111111";
        user1.res(user1);   //这里也是一种注册


        user1.login("ls","111");
        System.out.println(user1.userName+"=="+user1.passWord);


    }

三. 方法重载【重点】

3.1 方法重载概念
在本节中，咱们主要讨论的是实例属性和实例方法，实例属性和实例方法指的是对象调用的属性和方法。
方法的重载指的是，在一个类中，多个方法名字相同，但是参数（参数的个数, 参数类型，参数顺序）不同, 与返回值类型无关。

3.2 为什么要重载呢？
因为这些方法，功能本就类似，而方法名本身就代表功能的意义，所以这些方法同名是有基础条件的，这是重情理上说的。从理性的方式上看，可以用同相同的名字来记住这个功能，同时通过不同的参数，来使用差异化的功能，说简单点就是少记忆方法名字。

//定义一个类 演员
public class Player {

    //实例属性
    String name;

    int age;

    //实例方法
    public void  play(){
        System.out.println("大家好我是"+name+"正在拍摄电视剧，我今年"+age+"岁了");
    }
 

    public void play(String movie ){
        System.out.println("大家好我是"+name+"正在拍摄"+movie+"，我今年"+age+"岁了");
    }

    public void paly( double money   ){
        System.out.println("大家好我是"+name+"正在拍摄电视剧，我今年"+age+"岁了"+"我要的片酬是"+money);
    }

}

方法重载，是中现象，同一个方法名参数情况不同，方法是否构成重载与返回无关。方法重载实际上是一种多态，这种多态称为静态多态，编译时就可以确定最终调用方法

总结：方法重载要素
1、方法名相同
2、参数列表数量不同
3、参数数据类型不同

优点：方便代码维护

四.构造器【重点】

4.1 构造器作用
构造器，又叫构造方法，是类中定义的一种特殊方法，通过构造方法来实例化该类对象，也就是该类实例。

class Foo{
    String name;
    int age;
    public Foo(){
      System.out.println("Foo()");
    }
    public Foo(String name , int age){
        this.name = name;
        this.age = age;
    }
}

总结构造器作用 **1. 创建对象 ** 2.为对象属性赋值。

4.2 构造方法特点

构造方法有一下特点，需要背。

构造方法与类同名。
构造方法 没有返回值类型 ，也不可写void 。
构造方法通过 **new **调用
如果没有显示定义构造器，系统提供一个默认的无参构造，反之，一旦编写，系统不再提供。

class Coder{
   String name;
   int age;
   // 其他属性 .....
    
   public void sayHello(){
      System.out.println("hello");
   } 
   // 其他行为 ...... 
}

class TestCoder{
   public static void main(String[] args){
       Coder coder = new Coder();
       coder.name = "张三";
       coder.age = 30;
       coder.sayHello();
   }
}

4.3 构造方法重载

构造方法本质是方法，是方法就可以具备重载的特性， 一个类中之所以存在多个版本的构造器，是为了满足不同人对对象属性初始化的要求。

/**
 * 定义一个Java程序员类
 */
public class JavaCoder {
    //实例属性
    String name  ;
    int age ;
    //构造方法，也是一个方法，和实例方法一样定义在类中，通常情况大部分人的习惯，定义在属性后
    //无参数构造器
    public  JavaCoder(){
        System.out.println("构造器执行");
    }
    //有参数构造器
    public JavaCoder( String coderName  ){
        name=coderName;
    }
    //全参构造
    public JavaCoder( String coderName, int coderAge ){
        name = coderName;
        age = coderAge;
    }
    //实例方法
    public void writeCode(){
        System.out.println( "我是"+name+"今年" +age+"岁，正在写hello world  ");
    }
}

五.对象创建过程[了解]

六. this关键字【了解】

this 是一个java关键字

5.1 理解this 关键字

this 它是一个引用，这引用只能在类的内部使用，无需声明，直接使用，它指向(代表)的是当前对象，如何理解当前对象呢？当前对象指的是谁调用就指谁。

/**
 * 定义一个Java程序员类
 */
public class JavaCoder {

    //实例属性
    String name  ;
    int age ;
    
    //全参构造
    public JavaCoder(String name, int age ){
        this.name = name;
        this.age = age;
    }
    //实例方法
    public void writeCode(){
        System.out.println( "我是"+this.name+"今年" +this.age+"岁，正在写hello world  ");
    }
 
}

public class TestCoder {

    public static void main(String[] args) {

        JavaCoder coder = new JavaCoder("雷军",40);
        coder.writeCode();
        System.out.println("-----------------------");
        JavaCoder coder2 = new JavaCoder("比尔盖茨",50);
        coder2.writeCode();
    }
}

this 它的指向是变化的，不同时刻，它代表的对象是不同，也正是如此，才可以有效区分不同对象的属性。

5.2 this 的作用

通常 this 作用有两个：

第一个作用就是作为一个引用，可以访问当前对象的实例变量，和实例方法。
```
 比如在构造器中和方法中使用this.xxx的方式。
```

/**
 * 定义一个Java程序员类
 */
public class JavaCoder {

    //实例属性
    String name  ;
    int age ;
    
    //实例方法
    public void writeCode(){
        System.out.println( "我是"+this.name+"今年" +this.age+"岁，正在写hello world  ");
    }

}

第二个作用可以指代本类中的其他构造器

代码示例

public class Car {

    String brand;
    double pl;
    double price;

    public Car( String brand ){
        this.brand = brand;
    }
    public Car( String brand ,double pl){
        //Car(brand);//报错，想法很美好，构造器不可显示调用 ，只能 new调用
        this(brand); //为了解决这个问题 this(xx)代指构造器，必须出现在构造器中的第一行
        this.pl = pl;
        //this(brand); 只能是构造器的第一行语句
    }
    public Car( String brand ,double pl,double price){
        this(brand,pl);
        this.price = price;
    }

}

七.面向对象思想实践【熟练】

案例1：志东开凯迪拉克去王朝洗浴中心

/**
 * 编写汽车类
 */
public class Car {

    String carName; //目的地

    public Car(String carName){
        this.carName = carName;
    }

    public void run(String place ){
        System.out.println(carName+"行驶到"+place);
    }
}

/**
 * 编写人类
 */
public class Person {

    String name;

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

    //驾驶行为，需要提供 必要的车  和 目的地
    public void drive( Car car , String target ){
        //开车是人的行为
        System.out.println(this.name+"开");
        //行驶时车的行为，目的地是给车使用用
        car.run( target );
    }

}

public class TestDemo {

    public static void main(String[] args) {

        //面向对象编程 对象
        // 1.创建车对象
        Car car = new Car("凯迪拉克");

        // 2.创建人对象
        Person person = new Person("志东");

        // 3.对象调用方法
        person.drive(  car, "洗浴中心");

    }
}

总结: 这个案例想要说明的是，自定义类型也是一个类型，可以作为方法的参数类型

案例2：张飞用丈八蛇矛打关羽

分析：这里涉及到的事物类型有人(Hero) 武器( Weapon ) 两个类打是人的行为方法。

Weapon.java

/**
 * 武器
 */
public class Weapon {

    //名字
    String name;

    //攻击力
    int power;

    public Weapon() {
    }

    public Weapon(String name, int power) {
        this.name = name;
        this.power = power;
    }
}

Hero.java

/**
 * 英雄类
 */
public class Hero {

    //属性
    String name;

    //这里很重要，属性既可以是基本类型，当然也可以是自定义类型。并且我们可以把武器也作为人的必要属性。
    Weapon wq;

    public Hero() {
    }

    public Hero(String name, Weapon wq) {
        this.name = name;
        this.wq = wq;
    }

    //打实例方法，接受被打的人物对象
    public void attack(  Hero  dr  ){
        //这里由于把 被打的敌人 传进来了 ， dr就是被打的对象，那么可以从它身上获取名字 dr.name
        System.out.println(this.name+"使用杀伤力为"+this.wq.power+ "的"+ this.wq.name + "打" + dr.name );
    }

}

总结: 这个案例想要说明的是，自定义类型也是一个类型，可以作为属性的类型
**Main.java**** **

public class Main {

    public static void main(String[] args) {

        //实例化武器对象
        Weapon wq1 = new Weapon("丈八蛇矛枪",1200);
        Weapon wq2 = new Weapon("青龙偃月刀",1800);

        //实例化张飞对象
        Hero zf = new Hero("张飞", wq1 );
        //实例化关羽对象
        Hero gy = new Hero("关羽", wq2 );

        //实例化刘备对象，注意 与前面两个不同，这里使用了 匿名对象，就是没有名字的对象，效果相同，主要是简化。
        Hero lb = new Hero( "刘备",    new Weapon("雌雄双剑",800) );

        //人调用打的方法传入被打的人。
        zf.attack( gy );
    }
}

案例3：小明去动物园看猴子爬树熊猫打滚

分析：此案例涉及的事物类型有人(Person) 熊猫(Panda) 猴子(Monkey) 动物园(Zoo)

**Panda.java**** **

/**
 * 熊猫类
 */
public class Panda {
    String name;
    public Panda() {
    }
    public Panda(String name) {
        this.name = name;
    }
    public void gun(){
        System.out.println(name+"打滚....");
    }
}

**Monkey.java**** **

/**
 * 猴子类
 */
public class Monkey {
    String name;
    public Monkey() {
    }
    public Monkey(String name) {
        this.name = name;
    }
    public void climbTree(){
        System.out.println(this.name+"爬树...");
    }
}

**Zoo.java**** **

/**
 * 动物园
 * 动物园提供各式各样的动物对象
 */
public class Zoo {
    public Panda getPanda(){
        Panda tt = new Panda("团团");
        return tt;
    }
    public Monkey  getMonkey(){
        Monkey mm = new Monkey("悟空");
        return mm;
    }
}

Person.java

/**
 * 人看动物
 * look 方法重载，实现接受不同类型的动物
 */
public class Person {
    String name;
    public Person(String name) {
        this.name = name;
    }
    public Person() {
    }
    public void look(Panda panda  ){
        System.out.println(this.name+"看");
        //打滚是熊猫的行为，直接熊猫调用
        panda.gun();
    }
    public void look( Monkey monkey ){
        System.out.println(this.name+"看");
        //爬树是猴子的行为，直接猴子调用
        monkey.climbTree();
    }
}

总结: 这个案例突出** 方法重载的灵活性**

**Main.java**** **

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

        //实例化动物园
        Zoo zoo = new Zoo();
        //从动物园中获得熊猫和猴子
        Panda panda = zoo.getPanda();
        Monkey monkey = zoo.getMonkey();
        //实例化人
        Person person = new Person( "小明" );
        //人看不同的动物
        person.look(panda);
        person.look(monkey);
    }
}

作业：

1、表述  什么是类  什么是对象  举例

类：是一类事物具有相同属性和行为抽象
对象：是类的实体

2、电脑  怎么概况类 什么是对象；
答：
类：是一类事物具有相同属性和行为抽象
对象：是类的实体

电脑他是所有计算机的一个抽象出来词语，根据类定义，它就是一个类
根据对象定义，笔记本电脑，台式电脑 就一个电脑实体



3、小李去打老王，媳妇出来帮忙老王  里面哪些是类  哪些是对象   哪些是属性 哪些是行为

4、李杰去洗脚 被公安局抓住，关进少年看管所，请问 里面哪些是对象 哪些是类 哪些是行为 哪些是属性；

5、用面向对象 编写 请假流程

课前复习：
1、什么是面向对象设计？
就把一类具有公共属性和行为的事务，抽象出来，被称为：面向对象（事务：主要从属性和行为）；
2、把面向对象设计传化成 java类
class 就是java体现出来，面向对象，属性->变量，行为-方法
3、类的实例化成对象
class 实例化成对象，我们用的就是这个对象去处理我的业务逻辑；

类名（数据类型）对象名（标识符） = new 类名（）；//才是对象

4、类里面方法重载和 this classloader
构造方法：类加载器加载我们自定义数据型（对象）时候，它自动回去调用的构造方法，进行初始化；
定义构造方法：【修饰符】+类名（【参数列表】）{ //构造方法不需要返回值，连void关键字都不能加
}

a、每个类必须至少有一个构造方法
b、如果我们没有写构造方法，系统默认都会给我们提供一个public 不带参的构造方法；
c、如果我们之间编写了构造方法，系统优先调用我们的构造方法，默认的方法不在提供；

this 制定就是当前对象，这个“当前”就是你现在用这个对象；
1、作业我们的方法引用，：this.xxx
2、构造方法之间的调用：要把this 放在第一行；this.类名（）；