Java大数据学习第六天------面向对象 类 对象 封装

于 2021-12-07 18:44:44 发布
阅读量970 收藏
点赞数
分类专栏： Java大数据学习 文章标签： java big data 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61747318/article/details/121775993
版权

面向过程:

​ 强调的是过程,

面向对象:

​ 强调的是结果,只需要关注结果就好。

面向对象的三大特征:

  1. 封装: 把相关的数据封装成一个“类”组件
  2. 继承: 是子类自动共享父类属性和方法，这是类之间的一种关系
  3. 多态: 增强软件的灵活性和重用性

类:

  1. Java语言最基本单位就是类，相当于类型。
  2. 类是一类事物抽取共同属性与功能形成的。
  3. 可以理解为模板或者设计图纸。
    注意:类在现实世界并不存在,它只是一种对象的数据类型

对象:

每个对象具有三个特点：对象的属性，对象的功能和对象的标识。

  1. 对象的属性用来描述对象的基本特征。
  2. 对象的功能用来描述对象的可以完成的操作。
  3. 对象的标识是指每个对象在内存中都有一个唯一的地址值用于与其他对象进行区分，类似于我们的身份证号

类和对象的关系

  1. 我们先创建类，再通过类创建出对象
  2. 我们可以通过一个类创建出多个对象
  3. 类是抽象的，对象是具体的

对象在内存中的存储

Java把内存分成5大区域，我们重点关注栈和堆。

一般来讲局部变量存在栈中，方法执行完毕内存就被释放
对象(new出来的东西)存在堆中，对象不再被使用时，内存才会被释放
每个堆内存的元素都有地址值
对象中的属性都是成员变量,是有默认值的
TIPS: 栈与队列指的是一种数据的结构。
栈：先进后出（FILO – First In Last Out）----比如 手枪子弹
队列：先进先出（FIFO – First In First Out）—比如 排队打饭

img

img

对象创建过程分析

Phone p = new Phone(); 这句代码，再内存中会发生什么呢？
1.在栈内存中开辟一块空间,存放引用类型Phone类型的变量p
2.在堆内存中开辟一块空间,存放Phone类型的对象
3.要给这个对象进行初始化,比如:String brand = null;
4.当对象准备好以后,会生成一个唯一的地址值,然后将此地址值交给引用类型的变量p来保存
5.如果以后想要操作此对象的各种资源,可以通过p变量保存的地址值找到该对象,比如:p.call(); p.price = 66.6;

在这里插入图片描述

封装

  • 封装是隐藏对象的属性和实现细节,仅仅对外提供公共的访问方式,比如类和方法
    好处:

  1. 提高安全性

  2. 提高重用性

  3. private关键字

    是一个权限修饰符 ,可以用来修饰成员变量和成员方法.被私有化的成员只能在本类中访问

  • TIPS:如何封装?封装后的资源如何访问?
    我们可以使用private关键字来封装成员变量与方法
    如何访问私有资源?
    关于成员变量:
    setXxx – 对外提供公共的设置值方式
    getXxx – 对外提供公共的获取值方式
    关于成员方法:
    把私有方法放在公共方法里供外界调用即可

访问控制符

用来控制一个类，或者类中的成员的访问范围。
在这里插入图片描述
TIPS:default是表示不写修饰符,默认,如果写default单词来修饰会报错

匿名对象

没有名字的对象，是对象的简化表示形式。
使用场景：
当被调用的对象只调用一次时（多次会创建多个对象浪费内存）
Demo d = new Demo();
d.sleep();
d.game();
//这个d就是对象的名字。
也可以写成：
new Demo().show();//创建了一个对象调方法
new Demo().game();//又创建了一个对象调方法

今日案例

案例一
    package cn.tedu.oop;
/**本类用作面向对象oop入门案例
 * 设计手机这一类事物
 * 分析属性:品牌 价格 尺寸 颜色
 * 分析功能:打电话 发短信 看直播*/

/*在一个Java文件中可以写多个class 但是被public修饰的class只能有一个 并且要求这个公共类的名字必须与文件名一致*/
public class TestCreateClass {
    public static void main(String[] args) {
        //4.创建手机类的对象
        /**我们使用new关键字创建对应类的对象*/
        new Phone();//新建phone类的一个对象 但是还没起名字 是匿名对象 在堆内存里
        Phone p1 = new Phone();//给新建的对象起一个名字 前后类必须一致 所以p1是引用类型 在栈内存里
        //5.通过手机类的对象p1 调用手机类的功能---方法
        p1.call();
        p1.message();
        p1.video();
        //6.通过手机类的对象p1 打印查看对象的属性---成员变量
        System.out.println(p1.brand);
        System.out.println(p1.color);
        System.out.println(p1.price);
        System.out.println(p1.size);

        //7.创建手机类的第二个对象
        Phone p2 = new Phone();
        //8.通过p2对象 调用手机类的三个功能方法
        p2.call();
        p2.message();
        p2.video();
        //9.通过手机类的对象p2,给四个属性赋值并查看
        p2.brand="华为";
        p2.color="中国红";
        p2.price=8888.88;
        p2.size=5.6;

        System.out.println(p2.brand);
        System.out.println(p2.color);
        System.out.println(p2.price);
        System.out.println(p2.size);


        System.out.println(p1);
        System.out.println(p2);
    }
}



//1.通过class关键字  创建一个手机类 ----用来描述手机这一类事物
class Phone{
    //2.定义手机类的属性---用成员变量来描述---位置:类里方法外
    double price;//价格
    String brand;//品牌
    double size;//尺寸
    String color;//颜色

    //3.定义手机类的功能--用方法来描述--修饰符  返回值类型  方法名(参数列表){方法体}
    public void call(){
        System.out.println("正在打电话~");
    }
    public void message(){
        System.out.println("正在发短信~");
    }
    public void video(){
        System.out.println("正在看直播~");
    }
}






案例二
    package cn.tedu.oop;

public class TestPhoneClass {
    public static void main(String[] args) {
        //新建一个Phone类的对象  此时对象是匿名对象
        new Phone2();
        //给新建的对象起名 保存对象的地址值
        Phone2 p2 = new Phone2();
        //调用手机类功能
        p2.call();
        p2.message();
        p2.vedio();
        //调用手机属性并赋值输出  华为手机  星辰银 6.1寸 5888.88元
        p2.brand="华为手机";
        p2.color="星辰银";
        p2.size=6.1;
        p2.price=5888.88;
        System.out.println(p2.brand);
        System.out.println(p2.color);
        System.out.println(p2.size);
        System.out.println(p2.price);
    }

}




//创建手机类
class Phone2{
    //创建手机类的属性--成员变量
    double price;
    double size;
    String brand;
    String color;
    //创建手机类的功能--方法
    public void call(){
        System.out.println("正在打电话~~");
    }
    public void message(){
        System.out.println("正在发短信~~");
    }
    public void vedio(){
        System.out.println("正在看直播~~");
    }
}









案例三
    package cn.tedu.oop;
/**本类用于测试封装的必要性*/
public class TestPrivate1 {
    public static void main(String[] args) {
        //3.创建用户类对象
        User u = new User();
        //4.修改对象的属性值
        //u.name="李逵";

        u.setName("李逵");
        System.out.println(u.getName());
        /*需要封装属性,如果不封装的话,就可以直接修改这个属性的值,不安全*/
       // u.money=1000000000;  封装以后显示错误:'money' has private access in 'cn.tedu.oop.User' 钱是私有权限
        //5.查看属性

       // System.out.println(u.money); 封装以后显示错误
        //6.4调用操作money的方法
        u.setMoney(2000);
        System.out.println(u.getMoney());
    }

}
//1.创建用户类User
class User{
    //2.定义用户类的属性
   private String name;//7.1封装name属性
   /*空白行右键-->Generate-->Getter and Setter-->CTRL+A 全选所有属性,回车*/
    //6.1封装属性--通过private关键字修饰属性即可---因为money是不能让随便修改的 所以需要封装private
    private double money = 1000;


    //6.2因为属性封装了不能用  需要提供公共的方法让外界使用 1:查询当前账户余额
    public double getMoney() {//查询
        /*后续可以在这个位置添加权限校验的代码*/
        return money;
    }
    //6.3因为属性封装了不能用  需要提供公共的方法让外界使用 2:修改当前账户余额
    public void setMoney(double money) {
        /*后续可以在这个位置添加权限校验的代码*/
        /*当本类的成员变量与局部变量同名时,可以使用this关键字指定本类的成员变量*/
        this.money = money;
    }
    public String getName() {//有返回值 获取姓名
        return name;
    }

    public void setName(String name) {//设置姓名 得有参数
        this.name = name;
    }

}








案例四
    package cn.tedu.oop;
/**本类用于练习oop的第一大特性:封装*/
public class TestPrivate2 {
    public static void main(String[] args) {
        //4.创建学生类对象s1
        Student s1=new Student();
        //4.1 学号10 名字 海绵宝宝  科目 洗碗
        s1.sno=10;
        //s1.name="海绵宝宝";  没封装前
       // s1.subject="洗碗";   没封装前
        /*6  封装后*/
        s1.setName("海绵宝宝");
        s1.setSubject("洗碗");
        //4.2 查看修改后的s1对象属性
        System.out.println(s1.sno);
       // System.out.println(s1.name);
       // System.out.println(s1.subject);
        /*6  封装后*/
        System.out.println(s1.getName());
        System.out.println(s1.getSubject());
        //创建学生类对象s2 并调用学生类对象三个功能方法
        Student s2=new Student();
        s2.study();
        s2.eat();
        s2.sleep();
        //7.使用对应的get set方法 将s2对象name subject 修改为 派大星  跳草裙舞
        s2.setName("派大星");
        s2.setSubject("跳草裙舞");
        System.out.println(s2.getName());
        System.out.println(s2.getSubject());

    }
}



//1.定义学生类型
class Student{
    //2.属性:学号 sno   姓名 name  科目 subject
    //6.封装name  subject属性
    int sno;
    private String name;
    private String subject;


//6.1   右键空白行->Generate->Getter and Setter->按住shift选择属性->OK
    public String getName() {
        return name;
    }

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

    public String getSubject() {
        return subject;
    }

    public void setSubject(String subject) {
        this.subject = subject;
    }

    //3.
    public void study(){
        System.out.println("正在学习~~~~");
    }
    public void eat(){
        System.out.println("正在吃饭~~~~");
    }
    public void sleep(){
        System.out.println("我一点也不想睡觉,就想学习Java");
    }
}




案例五
    package cn.tedu.oop;
/**本类用于练习方法的封装*/
public class TestPrivate3 {
    public static void main(String[] args) {
        //4.创建苹果类对象a1并调用两个功能
        Apple a1 = new Apple();
        a1.clean();
       // a1.eat();   没封装前


    }
}




//1.创建苹果类
class Apple{
    //2.定义方法1
    public void clean(){
        System.out.println("苹果要先洗一下~");
        //6.当eat()方法被封装,外部其他的类是无法直接使用的 所以我们可以在本类Apple类中的clean()里直接调用eat()
        eat();
    }
    //3.定义方法2  public void eat(){}
    //5.使用private 修饰eat()
    /*private是一个修饰符,被private修饰的资源是私有资源,只能在本类中使用*/
    private void eat(){
        System.out.println("可以吃苹果了~");
    }

}









案例六
    package cn.tedu.oop;
/**苯类用于oop巩固练习*/
public class TestCar {
    public static void main(String[] args) {
        //4.1创建汽车对象c1,属性: 宝马  五彩斑斓的黑 100.1 666 4  查看对象的属性 调用汽车类型的方法
        //4.2  创建c2   特斯拉  黑不溜秋的白 120.5 34 2   查看对象的属性 调用汽车类型的方法
        Car c=new Car();
        c.start();//调用启动方法
        c.stop();//调用停止方法
        //给汽车属性赋值
        c.brand="BMW-M4 power 雷霆版 v8 双涡轮";
        c.color="银色";
        c.id=1314521;
        c.speed=420;
        c.load=4;
        System.out.println(c.brand);
        System.out.println(c.color);
        System.out.println(c.id);
        System.out.println(c.speed);
        System.out.println(c.load);

        //4.1
                Car c1=new Car();
                c1.start();
                c1.brand="宝马";
                c1.color="五彩斑斓的黑";
                c1.id=666;
                c1.speed=100.1;
                c1.load=4;
                System.out.println(c1.brand);
                System.out.println(c1.color);
                System.out.println(c1.id);
                System.out.println(c1.speed);
                System.out.println(c1.load);
                c1.stop();
         //4.2
        Car c2=new Car();
        c2.start();
        c2.brand="特斯拉";
        c2.color="黑不溜秋的白";
        c2.id=34;
        c2.speed=120.5;
        c2.load=2;
        System.out.println(c2.brand);
        System.out.println(c2.color);
        System.out.println(c2.id);
        System.out.println(c2.speed);
        System.out.println(c2.load);
        c2.stop();

    }

}
//1.定义汽车类型Car
//2.定义汽车各种属性
//品牌brand  颜色color 速度speed 编号id 载客量load
class Car{
    //属性
    String brand;
    String color;
    double speed;
    int id;
    int load;

    //3.定义汽车类的启动功能start(),打印 我的小车车启动了~~
    //定义汽车类的停止功能stop(),打印 哎呀妈呀熄火了~~
    public void start(){
        System.out.println("我的小车车启动了~~");
    }

    public void stop(){
        System.out.println("哎呀妈呀熄火了~~");
    }
}










案例七
    package cn.tedu.oop;

public class TestDemo {
    public static void main(String[] args) {
        User2 u=new User2();
        u.setName("张三");
        u.setPrice(1999);
        u.setId(66);
        System.out.println(u.getName());
        System.out.println(u.getPrice());
        System.out.println(u.getId());
    }
}




class User2{
    private String name;
    private double price;
    private int id;

    /*空白行右键-->Generate-->Getter and Setter-->CTRL+A 全选所有属性,回车*/
//    public String getName() {
//        return name;
//    }
//
//    public void setName(String name) {
//        this.name = name;
//    }
//
//    public double getPrice() {
//        return price;
//    }
//
//    public void setPrice(double price) {
//        this.price = price;
//    }

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

    public double getPrice() {
        return price;
    }
    public void setPrice(double price){
        this.price=price;
    }
    public int getId(){
        return id;
    }
    public void setId(int id){
        this.id=id;
    }
}
打字超慢
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
定义一个汽车类Car
m0_53572054的博客
10-09 7744
属性包括:汽车品牌brand(String类型)、颜色color(String类型)和速度speed(double类型)，并且所有属性为私有。* 定义测试类CarTest,在其main方法中创建一个品牌为“benz”、颜色为“color”的汽车。* 至少提供一个有参的构造方法(要求品牌和颜色可以初始化为任意值，但速度的初始值必须为0)* 为私有属性提供访问器方法。注意:汽车品牌一旦初始化之后不能修改。* 定义一个汽车类Car。
使用Java 编程定义一个汽车类Car
热门推荐
sinat_51673411的博客
02-03 2万+
编程定义一个汽车类Car 要求如下： （1）定义成员变量：品牌（String brand），价格(double price)，颜色（String color），销售日期（Calendar date）； （2）定义无参构造方法和带参构造方法，其中无参构造方法调用带参构造方法来初始化类中的变量； （3）定义上述成员变量所对应的getXxx()/setXxx()方法；以及一个显示所有成员信息的toString()方法； （4）定义一个测试类CarDemo，使用无参构造方法创建Car对象car1，调用toSt
java string 类 上机_5.14java上机
weixin_39785422的博客
02-13 477
1、(1)定义一个汽车类Vehicle，要求如下：(知识点：类的继承方法的覆盖)(a)属性包括：汽车品牌brand(String类型)、颜色color(String类型)和速度speed(double类型)。(b)至少提供一个有参的构造方法(要求品牌和颜色可以初始化为任意值，但速度的初始值必须为0)。(c)为属性提供访问器方法。注意：汽车品牌一旦初始化之后不能修改。(d)定义一个一般方法run(...
Python编写汽车类
qq_43191251的博客
06-09 1万+
Python编写汽车类 编写程序并测试，有一个汽车类 Vehicle，类中的私有数据成员为车轮个数 wheels 和车重 weight；小车类 Car 是汽车类 vehicle 派生类，其中包含载客人数 passenger_load，默认 4 人；卡车类 Truck 是汽车类 vehicle 派生类，其中包含载客 人数 passenger_load 和载重量 payload。 代码如下： class Vehicle(object): def __init__(self,wheels,weight):
Python 封装、继承、多态
雷银行的博客
07-27 515
面向对象的三大特征： 封装 确保对象中的数据安全 继承 保证了对象的可扩展性 多态 保证了程序的灵活性 封装 封装是面向对象的三大特性之一 封装指的是隐藏对象中一些不希望被外部所访问到的属性或方法 如何隐藏一个对象中的属性？ 将对象的属性名，修改为一个外部不知道的名字 如何获取（修改）对象中的属性？ 需要提供一个getter和setter方法使外部可以访问到属性 getter 获取对象中的指定属性（get_属性名） setter 用来设置对象的指定属性（set_属性名） 使用封
java代码-25 曾骞 大数据1班 例2-2
07-15
5. **类和对象**：Java是面向对象的语言，所以代码可能包含自定义类和对象，用于封装数据和行为。 6. **异常处理**：Java中的try-catch语句用于处理可能出现的错误，确保程序的健壮性。 7. **多线程**：在大数据...
java自动化之自动化框架项目（第二天-读取数据文件并封装对象）代码
最新发布
02-28
本项目旨在教你如何利用Java技术实现这一目标，特别是针对第二天的学习内容——从数据文件中读取信息并将其封装到对象中。 1. **数据文件读取**： 在自动化测试中，我们经常需要从CSV、Excel或JSON等格式的数据...
java代码-大数据一班陈志勇 07
07-15
1. **类与对象**：Java是一种面向对象的语言，`main` 方法往往存在于一个类中，而这个类可能封装了特定的数据结构和操作数据的方法。 2. **输入/输出流**：处理大数据时，文件I/O操作至关重要。Java提供了丰富的I/O...
java代码-大数据1班 陈瑞杰 01
07-15
【标题】"java代码-大数据1班 陈瑞杰 01" 暗示了这是一个与Java编程相关的学习资源，特别针对大数据处理的初学者，由学生陈瑞杰在第一堂课中编写的代码。这可能是为了练习或演示如何用Java解决大数据问题。 【描述...
java代码-大数据1 39李升耀 p21【2-2】
07-15
9. **面向对象编程**：作为面向对象的语言，Java允许我们将数据和操作数据的方法封装在一起，形成类。在大数据处理中，这种特性可以帮助我们更好地组织和管理复杂的数据模型。 10. **异常处理**：在处理大数据时，...
封装、property装饰器
微信公众号进阶的阿牛哥的博客
04-02 172
一、封装 封装是指隐藏对象中一些不希望被外部所访问到的属性或方法。（我个人理解其具体的隐藏方法或者思路，实际上就是在定义属性名的时候，属性名不要取的太常规） 出现封装的原因：我们需要一种方式来增强数据的安全性 • 1. 属性不能随意修改 • 2. 属性不能改为任意的值 比如： class Car(): def __init__(self,name,color): self.name=name self.color=color def run(self): print(self.name,
2021-03-09 代码封装复用，防止对个地方修改
weixin_44819948的博客
03-09 169
问题： 有些重复率较高，逻辑一致的代码，要封装成一个小模块(函数或其他)供其他模块调用，防止逻辑稍有变化就需要修改程序多个地方的风险。 示例： 为调试验证程序，需要添加一些调试信息，且调试信息都有弹框提示afxmessagebox…，且在程序中多个地方添加可一样的调试弹框代码，如果软件要正式使用，需要去掉弹框，这时就需要一个一个的去注释弹框代码；如果把多地方使用，重复率较高的调试弹框代码封装成函数，程序通过调用函数来使用调试功能，若程序需要正常使用去掉弹框调试，则只需要修改弹框调试代码注释掉即可，不需要满程
封装方法或者属性
weixin_33874713的博客
05-24 151
百科：封装：指隐藏对象的属性和实现细节，仅对外提供公共访问方式；比如电脑机箱、笔记本等 好处： 将变化隔离； 方便使用； 提高复用性； 提高安全性（防止被随意修改） 一次封装，可以无限调用，并且对属性可以限定关键字private：封装在代码中的体现 (1)私有的意思，权限修饰符 (2)用来修饰成员变量和成员函数 (3)用private修饰的成员只在本类中有效,本类成员可以直接调用priv...
第八章 面向对象特征一：封装性
yrxfight的博客
09-01 120
Java面向对象基础 面向对象特征一：封装性 一、
2021-11-3 C语言实现数据的封装 (即面向对象的数据成员封装)
林微的博客
11-03 495
C语言中函数和数据在编译层面默认都是Public，但是我们可以通过利用C编译器的基本编译规则，实现C编译器对数据成员的封装 (即面向对象的数据成员封装)。基本的原理是：把数据结构的声明部分让main函数可见，然后把数据结构的定义部分让main函数不可见(即定义部分放到main函数之外的其他源文件中)。 例子一 (变量的定义部分放在main函数能直接访问的头文件/源文件，无法实现数据的封装): 举例而言，如果将结构体变量的声明和定义都放在main函数能直接访问的头文件/源文件，那么该结构体的内部数据成员是ma
2、设计2个类，要求如下：[必做题] 2.1 定义一个汽车类Vehicle， 2.1.1 属性包括：汽车品牌brand（String类型）、颜色color（String类型 ）和速度speed（do
你虎哥还是你虎哥的博客
09-01 1万+
2.1 定义一个汽车类Vehicle 2.1.1 属性包括：汽车品牌brand（String类型）、颜色color（String类型）和速度speed（double类型）。 2.1.2 至少提供一个有参的构造方法（要求品牌和颜色可以初始化为任意值，但速度的初始值必须为0）。 2.1.3 为属性提供访问器方法。注意：汽车品牌一旦初始化之后不能修改。 2.1.4 定义一个一般方法run()，用打印语...
【Java学习】面向对象三大特性之封装
洛秋猫的Java学习之旅
07-16 142
目录前言1. 前言 1.
2018.12.11 第2题：2、设计2个类，要求如下： [必做题] 2.1 定义一个汽车类Vehicle， 2.1.1 属性包括：汽车品牌brand（String类型）、颜色color（Strin
weixin_43986018的博客
12-12 1万+
#2、设计2个类，要求如下： [必做题] 2.1 定义一个汽车类Vehicle， 2.1.1 属性包括：汽车品牌brand（String类型）、颜色color（String类型）和速度speed（double类型）。 2.1.2 至少提供一个有参的构造方法（要求品牌和颜色可以初始化为任意值，但速度的初始值必须为0）。 2.1.3 为属性提供访问器方法。注意：汽车品牌一旦初始化之后不能修改。 2....
封装属性_Java类中的封装
weixin_42099987的博客
01-13 967
1.Java类中的封装学习了访问权限修饰符后，应该可以理解封装性的概念和含义。封装性是面向对象三大特征之一封装性是一种信息隐藏技术2.封装的概念在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据，必须通过严格的接口控制。封装...
面向对象技术Java-期末复习试卷(三).docx
12-18
面向对象技术Java-期末复习试卷(三).docx是一份涵盖了面向对象技术的Java编程语言的期末复习试卷。该试卷涵盖了多个单项选择题，以下是其中的两道题目： 1、有一段java应用程序，其中包含一个公共类，名字为...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值