day07-面向对象

最新推荐文章于 2024-10-18 13:02:57 发布
最新推荐文章于 2024-10-18 13:02:57 发布
阅读量76 收藏
点赞数 1
分类专栏： 日记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangyosh/article/details/114303282
版权

面向对象基础

1.类和对象

1.1什么是对象

万物皆对象，客观存在的事物皆为对象

1.2什么是面向对象

1.3什么是类

类是对现实生活中一类具有共同属性和行为的事物的抽象

类的特点：

  • 类是对象的数据类型
  • 类是具有相同属性和行为的一组对象的集合

1.4什么是对象的属性

属性：对象具有的各种特征，每个对象的每个属性都拥有特定的值

1.5什么是对象的行为

行为：对象能够执行的操作

1.6类和对象的关系

类：是对现实生活中一类具有共同属性和行为的事物的抽象

对象：是能够看得到摸得着的真实存在的实体

1.7类的定义

类的重要性：是Java程序的基本组成单位

类是什么：是对现实生活中一类具有共同属性和行为的事物的抽象，确认对象将会拥有的属性和行为

类的组成：属性和行为

  • 属性：在类中通过成员变量来体现（类中方法外的变量）
  • 行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）

类的定义步骤：

  1. 定义类
  2. 编写类的成员变量
  3. 编写类的成员方法

例：Phone.java

package com.itheima_01;
/*
    类的定义

    类的定义步骤：
        定义类
        编写类的成员变量
        编写类的成员方法

    手机类：
        类名：
        手机(Phone)

        成员变量：
        品牌(brand)
        价格(price)

        成员方法：
        打电话(call)
        发短信(sendMessage)
 */
public class Phone {
    //成员变量
    String brand;
    int price;

    //成员方法
    public void call() {
        System.out.println("打电话");
    }

    public void sendMessage() {
        System.out.println("发短信");
    }
}

1.8对象的使用

创建对象

  • 格式：类名 对象名 = new 类名();
  • 范例：Phone p = new Phone();

使用对象
1：使用成员变量
格式：对象名.变量名
范例：p.brand
2：使用成员方法
格式：对象名.方法名()
范例：p.call()

PhoneDemo.java

package com.itheima_01;
/*
    创建对象
        格式：类名 对象名 = new 类名();
        范例：Phone p = new Phone();

    使用对象
        1：使用成员变量
            格式：对象名.变量名
            范例：p.brand
        2：使用成员方法
            格式：对象名.方法名()
            范例：p.call()
 */
public class PhoneDemo {
    public static void main(String[] args) {
        //创建对象
        Phone p = new Phone();

        //使用成员变量
        System.out.println(p.brand);
        System.out.println(p.price);

        p.brand = "小米";
        p.price = 2999;

        System.out.println(p.brand);
        System.out.println(p.price);

        //使用成员方法
        p.call();
        p.sendMessage();
    }
}

同1.7代码使用

案例：学生

  • 需求：首先定义一个学生类，然后定义一个学生测试类，在学生测试类中通过对象完成成员变量和成员方法的使用

  • 分析：
    成员变量：姓名，年龄…
    成员方法：学习，做作业…

  • 思路：

    1. 定义一个学生类

      类名：Student
      成员变量：name，age
      成员方法：study()，doHomework()

    2. 定义学生测试类
      类名：StudentDemo
      因为要做测试，所以有一个主方法：main方法

    3. 在学生测试类中通过对象完成成员变量和成员方法的使用
      给成员变量赋值，输出成员变量的值
      调用成员方法

Student.java

package com.itheima_02;
/*
    学生类
 */
public class Student {
    //成员变量
    String name;
    int age;

    //成员方法
    public void study() {
        System.out.println("好好学习，天天向上");
    }

    public void doHomework() {
        System.out.println("键盘敲烂，月薪过万");
    }
}

StudentDemo.java

package com.itheima_02;

/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();

        //使用对象
        System.out.println(s.name + "," + s.age);

        s.name = "林青霞";
        s.age = 30;

        System.out.println(s.name + "," + s.age);

        s.study();
        s.doHomework();
    }
}

2.对象内存图

2.1对象内存图（单个对象）

StudentTest01.java

package com.itheima_03;

/*
    单个对象
 */
public class StudentTest01 {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        System.out.println(s);

        //使用成员变量
        System.out.println(s.name + "," + s.age);

        s.name = "张曼玉";
        s.age = 28;

        System.out.println(s.name + "," + s.age);

        //使用成员方法
        s.study();
        s.doHomework();
    }
}

2.2对象内存图（多个对象）

StudentTest02.java

package com.itheima_03;

/*
    多个对象
 */
public class StudentTest02 {
    public static void main(String[] args) {
        //创建第一个对象并使用
        Student s1 = new Student();

        s1.name = "林青霞";
        s1.age = 30;
        System.out.println(s1.name + "," + s1.age);

        s1.study();
        s1.doHomework();

        //创建第二个对象并使用
        Student s2 = new Student();

        s2.name = "张曼玉";
        s2.age = 28;
        System.out.println(s2.name + "," + s2.age);

        s2.study();
        s2.doHomework();
    }
}

2.3对象内存图（多个对象指向相同）

StudentTest03.java

package com.itheima_03;

/*
    多个对象指向相同
 */
public class StudentTest03 {
    public static void main(String[] args) {
        //创建第一个对象并使用
        Student s1 = new Student();

        s1.name = "林青霞";
        s1.age = 30;
        System.out.println(s1.name + "," + s1.age);

        //把第一个对象的地址赋值给第二个对象
        Student s2 = s1;

        s2.name = "张曼玉";
        s2.age = 28;
        System.out.println(s1.name + "," + s1.age);
        System.out.println(s2.name + "," + s2.age);
    }
}

3.成员变量和局部变量

3.1什么是成员变量和局部变量

成员变量：类中方法外的变量

局部变量：方法中的变量
在这里插入图片描述

3.2成员变量和局部变量区别

在这里插入图片描述

4.封装

4.1private关键字

  • 是一个权限修饰符
  • 可以修饰成员（成员变量和成员方法）
  • 作用是保护成员不被别的类使用，被private修饰的成员只在本类中才能访问

针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作

  • 提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
  • 提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰

Student.java

package com.itheima_04;

/*
    学生类
 */
public class Student {
    //成员变量
    String name;
//    int age;
    private int age;

    //提供get/set方法
    public void setAge(int a) {
//        age = a;

        if(a<0 || a>120) {
            System.out.println("你给的年龄有误");
        } else {
            age = a;
        }
    }

    public int getAge() {
        return age;
    }

    //成员方法
    public void show() {
        System.out.println(name + "," + age);
    }
}

StudentDemo.java

package com.itheima_04;

/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();

        //给成员变量赋值
        s.name = "林青霞";
//        s.age = 30;
//        s.age = -30;
        s.setAge(30);
//        s.setAge(-30);

        //调用show方法
        s.show();
    }
}

4.2private关键字的使用

一个标准类的编写：

  • 把成员变量用private修饰
  • 提供对应的getXxx()/setXxx()方法

Student.java

package com.itheima_05;

/*
    学生类
 */
public class Student {
    //成员变量
    private String name;
    private int age;

    //get/set方法
    public void setName(String n) {
        name = n;
    }

    public String getName() {
        return name;
    }

    public void setAge(int a) {
        age = a;
    }

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

StudentDemo.java

package com.itheima_05;

/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();

        //使用set方法给成员变量赋值
        s.setName("林青霞");
        s.setAge(30);

        s.show();

        //使用get方法获取成员变量的值
        System.out.println(s.getName() + "---" + s.getAge());
        System.out.println(s.getName() + "," + s.getAge());

    }
}

4.3this关键字

  1. this修饰的变量用于指代成员变量

    • 方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量

    • 方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

  2. 什么时候使用this呢？解决局部变量隐藏成员变量

  3. this：代表所在类的对象引用

    • 记住：方法被哪个对象调用，this就代表哪个对象

Student.java

package com.itheima_06;

/*
    学生类
 */
public class Student {
    private String name;
    private int age;

//    public void setName(String n) {
//        name = n;
//    }

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

    public String getName() {
        return name;
    }

//    public void setAge(int a) {
//        age = a;
//    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

StudentDemo.java

package com.itheima_06;
/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();

        //使用set方法给成员变量赋值
        s.setName("林青霞");
        s.setAge(30);

        //调用show方法
        s.show();
    }
}

4.4this内存管理

在这里插入图片描述

4.5封装

  1. 封装概述
    是面向对象三大特征之一（封装，继承，多态）
    是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的
  2. 封装原则
    将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
    成员变量private，提供对应的getXxx()/setXxx()方法
  3. 封装好处
    通过方法来控制成员变量的操作，提高了代码的安全性
    把代码用方法进行封装，提高了代码的复用性
    在这里插入图片描述

5.构造方法

5.1构造方法概述

构造方法是一种特殊的方法
作用：创建对象

格式：
public class 类名{
修饰符 类名( 参数 ) {
}
}

功能：主要是完成对象数据的初始化
在这里插入图片描述

Student.java

package com.itheima_07;

/*
    学生类

    构造方法：
        作用：创建对象
        功能：完成对象数据的初始化

    格式：
        修饰符 类名(参数) {

        }

        修饰符一般用：public
 */
public class Student {
    private String name;
    private int age;

    //构造方法
    public Student() {
        System.out.println("无参构造方法");
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

StudentDemo.java

package com.itheima_07;
/*
    测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        s.show();
    }
}

5.2构造方法的注意事项

  1. 构造方法的创建

    • 如果没有定义构造方法，系统将给出一个默认的无参数构造方法
    • 如果定义了构造方法，系统将不再提供默认的构造方法

  2. 构造方法的重载

    • 如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法

  3. 推荐的使用方式

    • 无论是否使用，都手工书写无参数构造方法

Student.java

package com.itheima_08;
/*
    学生类
 */
public class Student {
    private String name;
    private int age;

//    public Student() {
//        System.out.println("无参构造方法");
//    }

    public Student() {}

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

    public Student(int age) {
        this.age = age;
    }

    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

StudentDemo.java

package com.itheima_08;

/*
    测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s1 = new Student();
        s1.show();

        //public Student(String name)
        Student s2 = new Student("林青霞");
        s2.show();

        //public Student(int age)
        Student s3 = new Student(30);
        s3.show();

        //public Student(String name,int age)
        Student s4 = new Student("林青霞",30);
        s4.show();
    }
}

5.3标准类制作

  1. 成员变量
    • 使用private修饰
  2. 构造方法
    • 提供一个无参构造方法
    • 提供一个带多个参数的构造方法
  3. 成员方法
    • 提供每一个成员变量对应的setXxx()/getXxx()
    • 提供一个显示对象信息的show()
  4. 创建对象并为其成员变量赋值的两种方式
    • 无参构造方法创建对象后使用**setXxx()**赋值
    • 使用带参构造方法直接创建带有属性值的对象

Student.java

package com.itheima_09;

/*
    成员变量
        使用private修饰

    构造方法
        提供一个无参构造方法
        提供一个带多个参数的构造方法

    成员方法
        提供每一个成员变量对应的setXxx()/getXxx()
        提供一个显示对象信息的show()
 */
public class Student {
    //成员变量
    private String name;
    private int age;

    //构造方法
    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //成员方法
    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

StudentDemo.java

package com.itheima_09;

/*
    创建对象并为其成员变量赋值的两种方式
        1:无参构造方法创建对象后使用setXxx()赋值
        2:使用带参构造方法直接创建带有属性值的对象
*/
public class StudentDemo {
    public static void main(String[] args) {
        //无参构造方法创建对象后使用setXxx()赋值
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(30);
        s1.show();

        //使用带参构造方法直接创建带有属性值的对象
        Student s2 = new Student("林青霞",30);
        s2.show();
    }
}
W_Jackson
关注
专栏目录
Java 第三章 面向对象
meini32的博客
05-16 352
面向对象：java中的核心内容，最重要的内容，Java语言的特色。 C语言：纯面向过程，C++：半面向对象；JAVA:纯面向对象。 1.面向过程和面向对象的区别： 面向过程：关注因果关系，因果关系构成一个一个的模块，整个流程。 -优点：对于业务的逻辑比较简单，可以达到快速开发，前期投入成本比较低。 -缺点：面向过程的方法很难解决非常复杂的业务逻辑，导致软件元素之间的“耦合度”比较高，只要其中一个环节出现问题，整个程序都会收到影响。 面向对象：关注对象（人的习惯），独立体能完成哪些功能。 -优点：“耦合度”低
Java实验二 : 面向对象（一）
Monster的博客
11-14 616
实验目的：在集成开发环境下，运用Java语言的面向对象的特性来实现类的封装、构造方法的定义以及对象的实例化和对象方法的调用。 实验目标： (1)能够根据实际的一类对象通过Java语言来进行类的定义； (2)能够熟练运用构造方法来实例化对象以及调用对象的方法。 实验内容： 1．定义一个汽车类，要求该类中至少包含5个私有的属性（为每个属性定义设置和获取方法）,该类中至少包含两个构造方法（一个无参，一个有参），以及包含5-6个方法来描述汽车对象的行为（其中一个方法要能打印输出汽车对象的所有属性值）。 2．定义一个
定义类成员
weixin_34309543的博客
01-24 94
访问级别：publicprivateinternal  成员只能由定义它的项目（程序集）内部的代码访问protected  成员只能由类或派生类中的代码访问protected internal  只能由项目（程序集）中派生类的代码来访问 定义字段：readonly: 表示这个字段只能在执行构造函数的过程中赋值，或由初始化赋值语句赋值static：静态字段 定义方法：staticvirtual ...
Scala编程学习之六-面向对象基础
smsmtiger的博客
12-02 1551
6.1类与对象 6.1.1问题的提出 张老太养了只猫猫:一只名字叫小白,今年3岁,白色。还有一只叫小花,今年10岁,花色。请编写一个程序，当用户输入小猫的名字时，就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，则显示 张老太没有这只猫猫。 //问题 1.因为猫有多个属性[年龄，姓名，颜色]，属性的类型不一样. 2.猫有自己的行为(cry, run, cal) 3.需要一种新的数据类型，这种...
Scala面向对象编程(OOP)
jiandanbuguo的博客
10-25 395
Scala OOP一、类 class 一、类 class 与Java相通的地方 通过class关键字定义 通过new关键字创建实例 可以定义成员变量个方法 类的成员可以用public，private、protected修饰，默认为public 与Java不同的地方： 类中无法定义静态成员变量和方法 类无需明确定义构造方法。通过构造参数列表声明为类的一部分 类成员访问修饰符 java 修饰符 同一个类 同一个包 子类中 任意地方 private 可以 不可以 不可以 不可以 d
Java基础--面向对象 day07-面向对象的引入
张准的博客
11-13 286
1.面向对象的引入
Day07-面向对象（一）
2301_80336940的博客
02-27 1632
面向对象编程（Object-Oriented Programming，OOP）以类的方式组织代码，以对象的组织（封装）数据抽象三大特性：封装继承多态从认识论角度考虑先有对象后有类。对象，是具体的事物；类，是抽象的，是对对象的抽象从代码运行的角度考虑现有类后有对象。类是对象的模板。
day07-面向对象（对应视频内容p99-p114）
gh0stf1re的博客
09-07 2014
1. 类和对象 1.1 类和对象的理解 客观存在的事物皆为对象 ，所以我们也常常说万物皆对象。 类 类的理解 类是对现实生活中一类具有共同属性和行为的事物的抽象 类是对象的数据类型，类是具有相同属性和行为的一组对象的集合 简单理解：类就是对现实事物的一种描述 类的组成 属性：指事物的特征，例如：手机事物（品牌，价格，尺寸） 行为：指事物能执行的操作，例如：手机事物（打电话，发短信） 类和对象的关系 类：类是对现实生活中一类具有共同属性和行为的事物的抽象 对象：是能够看得到摸的着的真实存
day07-面向对象 java
06-11
day07-面向对象 java
day07-面向对象1
08-04
1.4 封装【概念与实现】封装是面向对象编程的核心特性之一，它将数据和操作数据的方法绑定在一起，作为一个相互依赖的整体——对象。封装的目的是隐藏对象的属性和实现细节，仅对外提供公共访问方式。实现封装的步骤...
day08-面向对象-类和对象
12-12
本资源摘要信息涵盖了面向对象编程的基础知识点，包括类和对象的概念、面向对象编程的特点、类和对象的关系、面向对象编程的三个基本特征、面向对象和面向过程的比较等。 一、类和对象的概念 在面向对象编程中，类...
day08-面向对象.md
12-16
day08-面向对象.md
day07-面向对象基础
weixin_48686586的博客
08-02 467
一、面向对象 1.类和对象的关系 什么是类 具有相同属性和行为的对象的集合 类就是一种抽象的广泛的概念。例如：水果类、动物类 类的组成部分： 属性(成员变量)：就是类中有哪些描述信息 行为(成员方法)：就是类可以做哪些事情 什么是对象 对象就是某一个类事物中的具体的体现 例如：水果类-苹果、动物类-狗 类和对象的关系 对象是根据类来创建出来的！ 2.定义类 明确类的名字 见名知意 明确类中有哪些属性 属性-成员变量 数据类型 变量名; 明确类中有哪些行为 行
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 379
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 683
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
确保Spring Boot定时任务只执行一次方案
2301_76419561的博客
10-14 497
确保Spring Boot定时任务只执行一次有多种方法，你可以根据实际需求选择最适合的方法。如果你需要更复杂的任务调度或周期性执行，@Scheduled注解和接口是更合适的选择。而对于一次性的初始化任务或应用程序启动任务，注解和实现接口则更为简洁明了。
SpringBoot智能物流管理系统开发指南
最新发布
2401_85762266的博客
10-18 805
在概念模式的设计中，E-R模型法是最常见的设计方法。B/S架构的运行方式是在远程的服务器上把开发的软件系统部署在远程的服务器上，在部署好软件系统之后就可以实现在任何接入互联网的电脑上访问部署好的软件系统。6、网络上的客户端和服务器可以用来编程任何独立的编程环境，也有中国，GB2312，BIG5，日文写作，一般基金，用于支持多国语言，并且可以嵌入在数据表和其他软件shift_jis访问柱可以用作的名称。编程语言，如C, C ++，Python和Java的，的Perl，PHP，埃菲尔铁塔，Ruby和Tcl的。
【SpringBoot的启动、处理请求整体流程（二）】
m0_50149847的博客
10-13 900
同时，如果文章有错误，也欢迎批评指正。本篇文章继之后，可以先阅读第一篇文章。
spring task的使用场景
qq_40603125的博客
10-13 336
spring任务调度框架约定的时间。
Java面向对象编程精华：Day04-09核心内容概览
2. **面向对象编程** (Day04) - Java是一种面向对象的语言，这一阶段将深入讲解对象和类的概念，包括封装、继承、多态性等核心原则，以及如何创建和管理对象。 3. **高级编程接口** (Day05 - Day07) - **Java图形...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值