精华内容
下载资源
问答
  • 「Java工具」BeanCopyUtil对象复制工具
    千次阅读
    2021-10-31 18:59:04

    介绍语

    本号主要是Java常用关键技术点,通用工具类的分享;以及springboot+springcloud+Mybatisplus+druid+mysql+redis+swagger+maven+docker等集成框架的技术分享;datax、kafka、flink等大数据处理框架的技术分享。文章会不断更新,欢迎码友关注点赞收藏转发!

    望各位码友点击关注,冲1000粉。后面会录制一些视频教程,图文和视频结合,比如:图书介绍网站系统、抢购系统、大数据中台系统等。技术才是程序猿的最爱,码友们冲啊

    如果码友觉得代码太长,可以从头到尾快速扫射一遍,了解大概即可。觉得有用后再转发收藏,以备不时之需。

    正文:

    对象复制工具类,简单好用。但是使用场景好像不多,先收藏

    例子1

    复制学生类到另一个学生类

    import java.time.LocalDate;
     ​
     public class BeanUtilTest {
         public static void main(String[] args) {
             Student student = new Student("zhang三",
                     12, "花果山", LocalDate.of(1990, 2, 26));
             Student studentCopy = new Student();
             BeanCopyUtil.merge(student, studentCopy);
     ​
             System.out.println(studentCopy);
         }
     }
     ​
     // 控制台打印
     Student(name=zhang三, age=12, address=花果山, birthday=1990-02-26)

    例子用到的实体类

    import lombok.AllArgsConstructor;
     import lombok.Data;
     import lombok.NoArgsConstructor;
     ​
     import java.time.LocalDate;
     ​
     @Data
     @AllArgsConstructor
     @NoArgsConstructor
     public class Student {
         private String name;
         private int age;
         private String address;
         private LocalDate birthday;
     }

    工具类源码:

    import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     ​
     import java.lang.reflect.Field;
     ​
     /**
      * 对象赋值工具类
      *
      * @author liangxn
      */
     public class BeanCopyUtil {
     ​
         private static final Logger logger = LoggerFactory.getLogger(BeanCopyUtil.class);
     ​
         /**
          * 相同对象合并,将原对象的非空属性的值赋值给目标对象
          *
          * @param origin      源对象
          * @param destination 目标对象
          * @param <T>         对象的类型
          */
         public static <T> void merge(T origin, T destination) {
             if (origin == null || destination == null) {
                 return;
             }
             if (!origin.getClass().equals(destination.getClass())) {
                 return;
             }
     ​
             Field[] fields = origin.getClass().getDeclaredFields();
             for (Field field : fields) {
                 field.setAccessible(true);
                 try {
                     Object value = field.get(origin);
                     if (null != value) {
                         field.set(destination, value);
                     }
                 } catch (IllegalAccessException e) {
                     logger.error("访问对象异常", e);
                 }
                 field.setAccessible(false);
             }
         }
     }

    鄙人编码十年多,在项目中也积累了一些工具类,很多工具类在每个项目都有在用,很实用。大部分是鄙人封装的,有些工具类是同事封装的,有些工具类已经不记得是ctrl+c的还是自己封装的了,现在有空就会总结项目中大部分的工具类,分享给各位码友。如果文章中涉及的代码有侵权行为请通知鄙人处理。

    计划是先把工具类整理出来,正所谓工欲善其事,必先利其器。项目中不管是普通单体项目还是多模块maven项目或是分布式微服务,一部分功能模块都是可以重用的,工具类模块就是其中之一。

    更多相关内容
  • Java对象 详解(一)

    万次阅读 多人点赞 2016-10-06 20:48:02
    一、面向对象简述面向对象是一种现在最为流行的程序设计方法,几乎现在的所有应用都以面向对象为主了,最早的面向对象的概念实际上是由IBM提出的,在70年代的Smaltalk语言之中进行了应用,后来根据面向对象的设计...

    一、面向对象简述

    面向对象是一种现在最为流行的程序设计方法,几乎现在的所有应用都以面向对象为主了,最早的面向对象的概念实际上是由IBM提出的,在70年代的Smaltalk语言之中进行了应用,后来根据面向对象的设计思路,才形成C++,而由C++产生了Java这门面向对象的编程语言。

    但是在面向对象设计之前,广泛采用的是面向过程,面向过程只是针对于自己来解决问题。面向过程的操作是以程序的基本功能实现为主,实现之后就完成了,也不考虑修改的可能性,面向对象,更多的是要进行子模块化的设计,每一个模块都需要单独存在,并且可以被重复利用,所以,面向对象的开发更像是一个具备标准的开发模式。

    在面向对象定义之中,也规定了一些基本的特征:
    (1)封装:保护内部的操作不被破坏;
    (2)继承:在原本的基础之上继续进行扩充;
    (3)多态:在一个指定的范围之内进行概念的转换。

    对于面向对象的开发来讲也分为三个过程:OOA(面向对象分析)、OOD(面向对象设计)、OOP(面向对象编程)。

    二、类与对象的基本概念

    类与对象时整个面向对象中最基础的组成单元。

    :是抽象的概念集合,表示的是一个共性的产物,类之中定义的是属性和行为(方法);
    对象:对象是一种个性的表示,表示一个独立的个体,每个对象拥有自己独立的属性,依靠属性来区分不同对象。

    可以一句话来总结出类和对象的区别:类是对象的模板,对象是类的实例。类只有通过对象才可以使用,而在开发之中应该先产生类,之后再产生对象。类不能直接使用,对象是可以直接使用的。

    三、类与对象的定义和使用

    在Java中定义类,使用关键字class完成。语法如下:

    class 类名称 {
             属性 (变量) ;
             行为 (方法) ;
    }

    范例:定义一个Person类

    class Person {     // 类名称首字母大写
        String name ;
        int age ;
        public void tell() {        // 没有static
              System.out.println("姓名:" + name + ",年龄:" + age) ;
             }
    }

    类定义完成之后,肯定无法直接使用。如果要使用,必须依靠对象,那么由于类属于引用数据类型,所以对象的产生格式(两种格式)如下:

    (1)格式一:声明并实例化对象

    类名称 对象名称 = new 类名称 () ;

    (2)格式二:先声明对象,然后实例化对象:

    类名称 对象名称 = null ;
    对象名称 = new 类名称 () ;

    引用数据类型与基本数据类型最大的不同在于:引用数据类型需要内存的分配和使用。所以,关键字new的主要功能就是分配内存空间,也就是说,只要使用引用数据类型,就要使用关键字new来分配内存空间。

    当一个实例化对象产生之后,可以按照如下的方式进行类的操作:
    对象.属性:表示调用类之中的属性;
    对象.方法():表示调用类之中的方法。

    范例:使用对象操作类

    package com.wz.classandobj;
    
    class Person { 
        String name ;
        int age ;
        public void get() {
            System.out.println("姓名:" + name + ",年龄:" + age);
        }
    }
    
    public class TestDemo {
            public static void main(String args[]) {
                Person per = new Person() ;// 声明并实例化对象
                per.name = "张三" ;//操作属性内容
                per.age = 30 ;//操作属性内容
                per.get() ;//调用类中的get()方法
            }
    }

    运行结果:

    姓名:张三,年龄:30

    以上完成了一个类和对象的操作关系,下面换另外一个操作来观察一下:

    package com.wz.classandobj;
    
    class Person { 
        String name ;
        int age ;
        public void get() {
            System.out.println("姓名:" + name + ",年龄:" + age);
        }
    }
    
    public class TestDemo {
            public static void main(String args[]) {
                Person per = null;//声明对象
                per = new Person() ;//实例化对象
                per.name = "张三" ;//操作属性内容
                per.age = 30 ;//操作属性内容
                per.get() ;//调用类中的get()方法
            }
    }

    运行结果:

    姓名:张三,年龄:30

    那么,问题来了,以上两种不同的实例化方式有什么区别呢?
    我们从内存的角度分析。首先,给出两种内存空间的概念:
    (1)堆内存:保存对象的属性内容。堆内存需要用new关键字来分配空间;
    (2)栈内存:保存的是堆内存的地址(在这里为了分析方便,可以简单理解为栈内存保存的是对象的名字)。

    1

    任何情况下,只要看见关键字new,都表示要分配新的堆内存空间,一旦堆内存空间分配了,里面就会有类中定义的属性,并且属性内容都是其对应数据类型的默认值。

    于是,上面两种对象实例化对象方式内存表示如下:
    这里写图片描述

    两种方式的区别在于①②,第一种声明并实例化的方式实际就是①②组合在一起,而第二种先声明然后实例化是把①和②分步骤来。

    另外,如果使用了没有实例化的对象,结果如何?
    如下:

    package com.wz.classandobj;
    
    class Person { 
        String name ;
        int age ;
        public void get() {
            System.out.println("姓名:" + name + ",年龄:" + age);
        }
    }
    
    public class TestDemo {
            public static void main(String args[]) {
                Person per = null;//声明对象
                //per = new Person() ;//实例化对象
                per.name = "张三" ;//操作属性内容
                per.age = 30 ;//操作属性内容
                per.get() ;//调用类中的get()方法
            }
    }

    运行结果:

    Exception in thread "main" java.lang.NullPointerException
        at com.wz.classandobj.TestDemo.main(TestDemo.java:15)

    此时,程序只声明了Person对象,但并没有实例化Person对象(只有了栈内存,并没有对应的堆内存空间),则程序在编译的时候不会出现任何的错误,但是在执行的时候出现了上面的错误信息。这个错误信息表示的是“NullPointerException(空指向异常)”,这种异常只要是应用数据类型都有可能出现。

    四、对象引用传递初步分析

    引用传递的精髓:同一块堆内存空间,可以同时被多个栈内存所指向,不同的栈可以修改同一块堆内存的内容。

    下面通过若干个程序,以及程序的内存分配图,来进行代码的讲解。

    我们来看一个范例:

    class Person {     
             String name ;
             int age ;
             public void tell() {        
                       System.out.println("姓名:" + name + ",年龄:" + age) ;
             }
    }
    public class TestDemo {
             public static void main(String args[]) {
                       Person per1 = new Person() ;         // 声明并实例化对象
                       per1.name = "张三" ;
                       per1.age = 20 ;
                       Person per2 = per1 ;  // 引用传递
                       per2.name = "李四" ;
                       per1.tell() ;
             }
    }

    对应的内存分配图如下:

    11

    再来看另外一个:

    class Person {
             String name ;
             int age ;
             public void tell() {
                       System.out.println("姓名:" + name + ",年龄:" + age) ;
             }
    }
    public class TestDemo {
             public static void main(String args[]) {
                       Person per1 = new Person() ;         // 声明并实例化对象
                       Person per2 = new Person() ;
                       per1.name = "张三" ;
                       per1.age = 20 ;
                       per2.name = "李四" ;
                       per2.age = 30 ;
                       per2 = per1 ;// 引用传递
                       per2.name = "王五" ;
                       per1.tell() ;
             }
    }

    对应的内存分配图如下:
    12

    垃圾:指的是在程序开发之中没有任何对象所指向的一块堆内存空间,这块空间就成为垃圾,所有的垃圾将等待GC(垃圾收集器)不定期的进行回收与空间的释放。

    未完待续。。。

    展开全文
  • C++类对象指针的区别

    万次阅读 多人点赞 2019-04-17 20:57:28
    一篇转载率较高的帖子:C++ 类对象和 指针的区别 大佬都不贴结果。。。。所以这里我给出代码和结果: #include<iostream> using namespace std; class Test{ public: int a; Test(){ a = 1; } }; ...

    好奇这个,所以参考了一些帖子,写下心得。


    一篇转载率较高的帖子:C++ 类对象和 指针的区别

    大佬都不贴结果。。。。所以这里我给出代码和结果:

    #include<iostream>
    using namespace std;
    
    class Test{
    public:
        int a;
        Test(){
            a = 1;
        }
    };
     
    int main()
    {
        Test* t1 = new Test();
        t1->a = 10;
        
        Test* t2 = new Test();
        t2->a = 5;
        
        cout << "&t1:" << t1 << " a = " << t1->a << endl;
        cout << "&t2:" << t2 <<  " a = " << t2->a <<endl;
        
        cout << "------------------------------" << endl;
        t2 = t1;
        cout << "&t1:" << t1 << " a = " << t1->a << endl;
        cout << "&t2:" << t2 <<  " a = " << t2->a <<endl;
        
        cout << "------------------------------" << endl;
        
        t1->a = 111;
        t2->a = 222;
        cout << "&t1:" << t1 << " a = " << t1->a << endl;
        cout << "&t2:" << t2 <<  " a = " << t2->a <<endl;
        
        return 0;
    }
    

    结果:

    说明类指针和变量指针一样,指针赋值以后改动的就是地址了

    #include <iostream>
    using namespace std;
    class Test{
    public:
        int a;
        Test(){
            a = 1;
        }
    };
    int main()
    {
        Test t1;
        t1.a = 10;
        
        Test t2;
        t2.a = 5;
        
        cout << "&t1:" << &t1 << " a = " << t1.a << endl;
        cout << "&t2:" << &t2 <<  " a = " << t2.a <<endl;
        
        cout << "------------------------------" << endl;
        t2 = t1;
        cout << "&t1:" << &t1 << " a = " << t1.a << endl;
        cout << "&t2:" << &t2 <<  " a = " << t2.a <<endl;
        
        cout << "------------------------------" << endl;
        
        t1.a = 111;
        t2.a = 222;
        cout << "&t1:" << &t1 << " a = " << t1.a << endl;
        cout << "&t2:" << &t2 <<  " a = " << t2.a <<endl;
        
        return 0;
    }
    

    说明类对象和c++中的普通变量一样,赋值就是对值进行改动,对地址没有改动


    类的指针:他是一个内存地址值,他指向内存中存放的类对象(包括一些成员变量所赋的值).   
    对象:他是利用类的构造函数在内存中分配一块内存(包括一些成员变量所赋的值).   

    指针变量是间接访问,但可实现多态(通过父类指针可调用子类对象),并且没有调用构造函数。 
    直接声明可直接访问,但不能实现多态,声明即调用了构造函数(已分配了内存)。 

    类的对象:用的是内存栈,是个局部的临时变量.   
    类的指针:用的是内存堆,是个永久变量,除非你释放它.  

     

    在应用时:   
            1.引用成员:   对象用"   .   "操作符;   指针用"   ->   "操作符.   
            2.生命期:     若是成员变量,则是类的析构函数来释放空间;若是函数中的临时变量,则作用域是该函数体内.而指针,则需利用delete   在相应的地方释放分配的内存块.   
            注意:用new   ,一定要delete.. 

    看来类指针也是需要delete的?

     

    C++的精髓之一就是多态性,只有指针或者引用可以达到多态对象不行
    类指针的优点: 
    第一实现多态。 
    第二,在函数调用,传指针参数。不管你的对象或结构参数多么庞大,你用指针,传过去的就是4个字节。如果用对象,参数传递占用的资源就太大了


    趁热打铁再来一个博客:解析C++普通局部变量与指针类型的对象变量的应用区别

    首先我们先来了解一下MFC中的CPtrArray类,他可以说是CObject类型指针对象的集合。通过int Add(CObject* newElement );注意参数是一个指针类型)可以向集合中添加元素。首先我们定义一个CPtrArray类型的对象。

    CPtrArray pArray;//他是一个全局对象

    先设定一个举例的类类型。如:

    class A
    {
    public:
        A(int i)
        {
            a = i;
        }
        ~A(){}
    public:
        int a;
    };

    现在我们需要在某个函数中要实现将一个A类型对象数据加入到一个CPtrArray对象中。此函数func1()如下:

    void func1()
    {
        //首先定义一个A类型的对象
        A a(1);
        //使用pArray对象中的成员函数将此对象加入到容器中
        pArray.Add(&a);
    }

    另一个函数中我们使用pArray容器为我们保存的数据:

    void func2()
    {
        //首先声明一个A类型的对象
        A* a;
        //使用pArray对象中的成员函数GetAt()将A类型的对象取出
        for(int i; i < pArray.GetSize();i++)
        {
            a = (A*)pArray.GetAt(i);
            //使用A中的数据进行相关的操作代码。***此时也可以使用delete释放指针指向的内存区块,防止内存泄露***当然是后面一种方法时才用到,暂时无视之。
            ...
        }
         
    }

    现在我们发现按照上面的过程,当我们在func2()函数中将要使用pArray容器对象为我们保存的数据时,我们并不能得到想要的数据!!!为什么发生以上情况?图解如下

    pArray保存a保存资源的地址;

    func1函数执行完成,a发生析构,资源不可用;

    原来在func1()函数中,a对象是一个局部对象,当我们使用pArray.Add(&a);我们将a对象的地址保存到pArray对象中。但是作为局部对象,当func1

    执行完成后,资源需要回收,此时我们定义的a对象也在A类中的析构函数中被析构释放资源!而当我们在fun2()函数中执行取出保存的对象时,

    实际是根据保存的地址去内存中找到数据,虽然此时我们能能够找到此地址,但是这个地址上面的数据并不是我们需要的了!!!所以才发生面的情况!

    那么怎么才能解决呢?

    看下面,我们只需更改func1函数中的代码:

    void func1()
    {
        //首先定义一个A类型的对象
        //A a(1);//为对比,只是注释原来那句
        A* a = new A(1);
        //使用pArray对象中的成员函数将此对象加入到容器中
        pArray.Add(a);
    }

    这样,我们就能够在func2函数中使用pArray对象中包含的数据了!那么为什么定义了一个指针类型的对象就能够完成了呢?还是一个局部对象呀,

    前面说的func1函数执行完成后此对象还是要经历析构的啊!图解如下:

    pArray中保存a指向资源的地址;

    func1函数执行完成,a对象发生析构,pArray根据地址还能能够访问到之前的资源;

    对,是要析构,但是,我们在pArray.Add(a);中加入的是a对象资源的地址,我们先看看A* a = new A(1);在堆中分配资源,我们知道,在堆中分配的资

    源是在跟程序的生命周期是一致的。a对象虽然析构了(不存在了),因为a也是一个指针,a指针也就是保存这个资源的地址!我们在pArray中保存的a的地址出的资源并没有析构!所以在func2函数中我们还能够使用此地址访问此地址对应的资源!

     

    --------------------------------END---------------------------

     

     

     

     

    展开全文
  • JAVA 面向对象 对象 封装

    万次阅读 多人点赞 2021-05-06 15:58:57
    面向对象概念 面向对象其实是一种编程思想,通过它可以把生活中复杂的事情变得简单化,从原来的执行者变成了指挥者。 面向对象是基于面向过程而言的。 面向过程强调的是过程,比如: 打开冰箱门 2. 把大象放进去 3. ...

    面向对象概念

    在学习面向对象之前,我们可以先了解一下面向过程。
    面向过程是一种编程思想,它强调的是过程,意思是我们做任何事,都需要亲力亲为。
    面向对象也是一种编程思想,相对于面向过程,我们的身份可以由原来问题的执行者变为指挥者,进而把生活中很多复杂的问题变得简单化。

    面向过程强调的是过程,比如,把大象装冰箱,一共分3步:
    第1步:打开冰箱门
    第2步:把大象放进去
    第3步:关上冰箱门
    而面向对象强调的是结果,比如:
    谁负责把大象装进去?
    有没有发现,如果是面向对象的话,干这件事的主体并不是你自己,你变成了一个指挥者?

    再比如,衣服脏了,我们可以让女盆友帮忙洗,不需要关注中间过程是怎么洗的,就可以拿到干净的衣服,当然,这首先需要有一个对象(加油哦)~

    还有,当我们想吃一道菜,其实并不需考虑这道菜是怎么做的,怎么送达的,只需点菜即可.传菜和做菜都有具体的对象来完成具体的功能.我们不需要关注实现的过程,只需要关注结果就好。
    在这里插入图片描述

    这就是我们所说的面向对象的编程思想(OOP,Object Oriented Programming)

    如果面试官问什么是面向对象?你答万物皆对象!额,不建议这样做哈,因为我们还没到大佬的这个高度,还是最好举例。
    就像是你说 : 空即是色 色即是空…信你个鬼鬼

    2 面向对象的三大特征

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

    3 类和对象

    3.1 类

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

    3.2 对象

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

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

    3.3 类和对象的关系

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

    3.4 练习:类的创建使用

    在编写代码之前,我们需要分析下需求:
    比如我们要把手机这一类事物抽象成代码:
    那么这个事物的类型就是"手机",可以用类来描述.
    类中包含的就是手机抽取出来的共性的属性与功能.

    手机的属性:颜色,尺寸,品牌,价格
    手机的功能功能:打电话,发短信,听音乐

    我们通过class关键字创建类,通过new关键字创建对象。
    接下来我们开始编码吧!
    创建包: cn.tedu.oop
    创建类: TestCreateClass.java

    package cn.tedu.oop;
    /**本类用作面向对象入门案例
     * 设计手机这一类事物:
     * 分析属性:品牌 价格 尺寸 颜色
     * 分析功能:打电话 发短信 看直播*/
    /**在一个java文件中可以写多个class`,但是,被public修饰的class只能有一个
     * 而且要求这个公共类的名字必须与文件的名字保持一致*/
    public class TestCreateClass {
        public static void main(String[] args) {
            //help-findAction 或者 Alt+7
            //4.创建手机类的对象p1
            Phone p1 = new Phone();
            //5.通过手机类对象调用手机类的功能
            p1.call();
            p1.message();
            p1.video();
            //6.通过手机类对象打印查看属性值
            System.out.println(p1.color);//null
            System.out.println(p1.price);//0.0
            System.out.println(p1.size);//0.0
            System.out.println(p1.brand);//null
        }
    }
    
    //1.通过class关键字创建手机类--用来描述手机这一类事物--属性+功能
    class Phone{
        //2.定义手机类的属性--用成员变量来描述--位置:类里方法外
        String brand;//品牌
        double price;//价格
        double size;//尺寸
        String color;//颜色
        //3.定义手机类的功能--用方法来描述--格式:修饰符 返回值类型 方法名(参数列表){方法体}
        public void call(){
            System.out.println("正在打电话~");
        }
        public void message(){
            System.out.println("正在发短信!");
        }
        public void video(){
            System.out.println("正在看直播~");
        }
    }
    

    3.5 对象在内存中的存储

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

    1. 一般来讲局部变量存在栈中,方法执行完毕内存就被释放
    2. 对象(new出来的东西)存在堆中,对象不再被使用时,内存才会被释放
    3. 每个堆内存的元素都有地址值
    4. 对象中的属性都是成员变量,是有默认值的
      TIPS: 栈与队列指的是一种数据的结构。
      栈:先进后出(FILO – First In Last Out)
      队列:先进先出(FIFO – First In First Out)
      在这里插入图片描述
      在这里插入图片描述

    对象的创建过程分析:

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

    3.6 练习2:创建多个对象

    package cn.tedu.oop;
    /**本类用作面向对象入门案例
     * 设计手机这一类事物:
     * 分析属性:品牌 价格 尺寸 颜色
     * 分析功能:打电话 发短信 看直播*/
    /**在一个java文件中可以写多个class`,但是,被public修饰的class只能有一个
     * 而且要求这个公共类的名字必须与文件的名字保持一致*/
    public class TestCreateClass {
        public static void main(String[] args) {
            //help-findAction 或者 Alt+7
            //4.创建手机类的对象p1
            Phone p1 = new Phone();
            //5.通过手机类对象调用手机类的功能
            p1.call();
            p1.message();
            p1.video();
            //6.通过手机类对象打印查看属性值
            System.out.println(p1.color);//null
            System.out.println(p1.price);//0.0
            System.out.println(p1.size);//0.0
            System.out.println(p1.brand);//null
    
            //7.创建手机类的第2个对象p2
            Phone p2 = new Phone();
            //8.通过p2对象,调用Phone类的3个方法
            p2.call();
            p2.message();
            p2.video();
            //9.给p2对象的4个属性赋值
            p2.brand = "HUAWEI";
            p2.color = "中国红";
            p2.price = 6666.66;
            p2.size = 5.6;
            //10.打印查看p2对象的4个属性值
            System.out.println(p2.brand);
            System.out.println(p2.price);
            System.out.println(p2.color);
            System.out.println(p2.size);
    
            //11.查看两个对象的地址值
            System.out.println(p1);//cn.tedu.oop.Phone@1b6d3586
    		System.out.println(p2);//cn.tedu.oop.Phone@4554617c
        }
    }
    
    //1.通过class关键字创建手机类--用来描述手机这一类事物--属性+功能
    class Phone{
        //2.定义手机类的属性--用成员变量来描述--位置:类里方法外
        String brand;//品牌
        double price;//价格
        double size;//尺寸
        String color;//颜色
        //3.定义手机类的功能--用方法来描述--格式:修饰符 返回值类型 方法名(参数列表){方法体}
        public void call(){
            System.out.println("正在打电话~");
        }
        public void message(){
            System.out.println("正在发短信!");
        }
        public void video(){
            System.out.println("正在看直播~");
        }
    }
    

    在这里插入图片描述
    p2.brand = “HUAWEI”;
    就是先到栈内存中找到p2中保存的唯一的地址值
    然后根据地址值找到对应的Phone对象,并对其对应的属性值进行修改
    p2.eat();
    也是先到栈内存中找到p2中保存的唯一的地址值
    然后根据地址值找到对应Phone对象,执行Phone对象的eat()方法

    4 封装

    4.1 概述

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

    1. 提高安全性
    2. 提高重用性

    4.2 private关键字

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

    4.3.1练习:封装的必要性

    创建包: cn.tedu.oop
    创建类: TestPrivate1.java

    package cn.tedu.oop;
    /*本类用于测试封装的必要性*/
    public class TestPrivate1 {
        public static void main(String[] args) {
            //3.创建用户类的对象
            User u = new User();
            //4.修改对象的属性值
            u.name = "李逵";
            /*需要封装属性,如果不封装的话,就可以直接修改属性的值,不安全*/
            //u.money = 999999999;
            //5.查看修改后的属性值
            System.out.println(u.name);
            //System.out.println(u.money);
            //6.4调用两个方法修改和查看属性值
            u.setMoney(8888888.88);
            System.out.println(u.queryMoney());
        }
    }
    
    //1.创建一个用户类User
    class User{
        //2.定义用户类的属性
        String name;
        //6.1封装属性--通过private关键字封装属性
        private double money = 10000;
        //6.2提供方法1:查询当前账户的余额
        public double queryMoney(){
            /*后续可以添加权限校验的操作*/
            return money;
        }
        //6.3提供方法2:修改当前账户的余额
        public void setMoney(double money){
            /*后续可以添加权限校验的操作*/
            /*当本类的成员变量与局部变量同名时
            可以使用this关键字指定本类的成员变量*/
            this.money = money;
        }
    }
    

    4.3.2 练习:封装学生案例

    创建包: cn.tedu.oop
    创建类: TestPrivate2.java

    package cn.tedu.oop;
    
    /*本类用于练习OOP的第一大特性:封装*/
    public class TestPrivate2 {
        public static void main(String[] args) {
            //4.创建学生类对象s
            Student s = new Student();
            //5.通过对象修改并查看属性值
            s.sno = 1;
            //s.name = "黄飞鸿";
            //s.subject = "Java培优";
            System.out.println(s.sno);
            //System.out.println(s.name);
            //System.out.println(s.subject);
            //6.通过对象调用方法
            s.study();
            s.eat();
            s.sleep();
            //7.3使用刚刚生成的set()设置值方法与get()获取值方法
            s.setName("十三姨");
            s.setSubject("美容美发");
            System.out.println(s.getName());
            System.out.println(s.getSubject());
        }
    }
    
    //1.定义类描述学生这一类型Student
    class Student {
        //2.特征:学号sno 姓名name 科目subject
        //7.1 封装属性--用private修饰属性
        int sno;
        private String name;
        private String subject;
    
        //7.2提供被封装属性的get与set方法
        //右键->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("吃饭ing...");
        }
    
        public void sleep() {
            System.out.println("我一点也不想睡觉,就想学Java!");
        }
    }
    

    4.3.3 练习:封装方法测试

    创建包: cn.tedu.oop
    创建类: TestPrivate3.java

    package cn.tedu.oop;
    /*本类用于测试方法的封装*/
    public class TestPrivate3 {
        public static void main(String[] args) {
            //4.创建对象测试
            Apple a = new Apple();
            //5.没有封装方法时,调用没有限制
            //a.eat();//封装eat(),此处调用报错
            a.clean();
        }
    }
    //1.创建苹果类
    class Apple{
        //2.定义方法1
        public void clean(){
            System.out.println("苹果还是要洗洗的~");
            //6.在已有的公共方法clean()中调用被封装eat()方法的功能
            eat();
        }
        //3.定义方法2
        private void eat(){
            System.out.println("要吃苹果啦~");
        }
    }
    

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

    5 拓展:OOP综合练习

    创建包:cn.tedu.oop
    创建类:TestCar

    package cn.tedu.oop;
    /*本类用于面向对象的巩固练习*/
    public class TestCar {
        //创建程序的入口函数main()
        public static void main(String[] args) {
            //3.创建汽车类对象c
            Car c = new Car();
            //4.通过汽车类对象c设置属性值
    //        c.color = "暗夜紫";
    //        c.brand = "BMW";
    //        c.price = 200;
    //        c.length = 0.2;
            //5.查看刚刚设置好的属性值
    //        System.out.println(c.brand);
    //        System.out.println(c.price);
    //        System.out.println(c.color);
    //        System.out.println(c.length);
            //6.通过c对象调用汽车类的方法
            c.start();
            //c.stop();
            //7.3调用提供的set与get方法,设置并获取对应属性的值
            c.setBrand("特斯拉");
            c.setColor("black");
            c.setPrice(200.02);
            c.setLength(3);
            System.out.println(c.getBrand());
            System.out.println(c.getColor());
            System.out.println(c.getLength());
            System.out.println(c.getPrice());
            //8.3 调用公共方法来实现私有方法功能的使用
            c.start();
        }
    }
    //1.抽象汽车这一类事物的属性与行为,封装成一个类组件
    class Car{
        //2.属性--用成员变量来描述
        //7.1封装所有的属性值--使用private修饰
        private String color;
        private String brand;
        private double price;
        private double length;
        //7.2 生成所有属性的get与set方法
        /*右键空白处->Generate->Getter and Setter->按住Shift全选所有属性生成即可*/
        public String getColor() {
            return color;
        }
    
        public void setColor(String color) {
            this.color = color;
        }
    
        public String getBrand() {
            return brand;
        }
    
        public void setBrand(String brand) {
            this.brand = brand;
        }
    
        public double getPrice() {
            return price;
        }
    
        public void setPrice(double price) {
            this.price = price;
        }
    
        public double getLength() {
            return length;
        }
    
        public void setLength(double length) {
            this.length = length;
        }
    
        //3.行为--用方法来描述
        //8.2 可以在本类公共的方法里,调用私有方法
        public void start(){
            System.out.println("汽车开动了~");
            stop();//我们通过方法名+参数列表确定要调用哪个方法
        }
        //8.1封装方法,通过private修饰符
        private void stop(){
            System.out.println("汽车停止了~");
        }
    }
    

    6 访问控制符

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

    拓展7 匿名对象

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

    展开全文
  • 类对象是将具有相似属性和方法的对象总结抽象为类对象,可以定义相似的一些属性和方法,不同的实例对象去引用类对象的属性和方法,能减少代码的重复率。 实例对象又称实例化对象,不是抽象而是一类对象中具体的一例...
  • Java对象(重点详解)

    千次阅读 多人点赞 2021-04-23 18:25:35
    类和对象类和对象的关系。类的介绍类变量(静态变量)public && private一些建议和小结写在最后的话 这段时间博主学习了一些Java中类和对象的知识,今天我们就来聊聊Java中的类和对象。 类和对象的关系。 类...
  • 类对象指针

    万次阅读 多人点赞 2018-12-06 21:04:02
    ... 类对象:Student s1 指针:Student *s2 (1)定义对象实例时,分配了内存,指针变量...(2)的指针:他是一个内存地址值,他指向内存中存放的类对象(包括一些成员变量所赋的值).   对象:他是利用的构造...
  • Python 对象

    万次阅读 多人点赞 2019-04-10 16:49:40
    对象的理解与封装特性 面向对象编程语言 - : 一个模板, (人类)---是一个抽象的, 没有实体的 - 对象: (eg: 张三, 李四) - 属性: (表示这东西的特征, 眼睛, 嘴巴, 鼻子) - 方法: (表示这物体可以...
  • C++对象数组

    万次阅读 多人点赞 2018-05-14 23:47:15
    C++对象数组 【1】对象数组 1:对象数组的定义:类名 数组名[元素个数] Eg: student asa[10];//有10个元素的学生类对象数组 2:对象数组的访问形式:数组名[下标].成员名; Eg: asa[j].print(); 3:对象...
  • 面向对象(Object Oriented,OO)。 面向对象(Object Oriented,OO)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发,扩展到如数据库系统、交互式界面、...核心特性包括:对象,方法,封装,继承...
  • 对象的理解

    千次阅读 多人点赞 2020-08-08 16:31:40
    菜鸟都能看懂(很容易理解)—— 对象 一、对象的定义 的定义: (class):是构造 对象 的模板或蓝图,也是一组相关属性和行为的集合。 属性(成员变量):就是该事物的状态信息(如同手机的颜色,...
  • 类对象与实例对象

    千次阅读 2019-05-08 14:19:56
    什么是对象? 1.世间万物皆为对象:问题...5.对象分为类对象和实例对象两大类对象是具有相同属性和行为的实例对象的抽象。同一类对象的所有实例对象如果具有相同的属性,表明它们的状态不一定相同,即属性的取值...
  • 对象、定义、创建对象

    千次阅读 2018-07-09 19:35:00
    对象面向对象编程的2个非常重要的概念:对象对象是面向对象编程的核心,在使用对象的过程中,为了将具有共同特征和行为的一组对象抽象定义,提出了另外一个新的概念——类类就相当于制造飞机时的图纸,用它...
  • 对象与接口概念

    千次阅读 2019-02-21 23:14:27
    对象与接口 内部 ​ 一个定义在另外一个的内部,分为成员内部(定义在外部的成员位置)和局部内部(定义在外部的方法里面) 成员内部 class Outer{ class Inner{} } 成员内部的特点 1、成员内部...
  • 面向对象:的概念和定义!

    万次阅读 多人点赞 2018-05-28 10:16:37
    面向对象的概念: 对象: Object,含有“物体”的概念,一切皆物体(对象)。对象由静态的属性和动态的行为组成。 属性:行为:存储、保温 : 一组具有相同属性和行为的对象的抽象。杯子: ...
  • 浅谈Python中文件对象的使用

    千次阅读 2020-10-12 11:17:03
    所谓文件对象(file-like object),简单说就是类似文件对象对象,至少要具备read()和write()两个方法。由于磁盘文件的写入和读出速度远远小于内存的读写速度,当我们使用文件作为两个连续的处理过程的数据交换...
  • 对象的关系

    千次阅读 2018-09-03 11:34:58
    简单记录一下对象的关系,问题不难,但觉得还是写出来,会帮助自己记忆更牢固,而且万一以后有需要,可以及时回顾。 参考文献: 对象的区别 Java对象 详解(一) Java对象 详解(二) 声明对象、...
  • Python中的的定义和对象的创建

    万次阅读 多人点赞 2018-08-16 17:35:59
    面向对象中两个重要的概念: ...一个可以创建无穷多个对象,每个对象都属于。 1.创建和创建类对象 1.创建主要由类名,属性,方法组成,当然创建一个时,属性和方法可以选择的。 cla...
  • 什么是对象对象(Object)是一个应用系统中的用来描述客观事物的实体,是有特定属性和行为(方法)的基本运行单位。是的一个特殊状态下的实例。对象可以是一个实体、一个名词、一个可以...对象的模板,它...
  • Java加载及对象创建过程详解

    千次阅读 多人点赞 2019-06-27 08:00:00
    加载过程 加载的五个过程:加载、验证、准备、解析、初始化。 ... 在Java堆中生成一个代表这个的java.lang.Class对象,作为方法区域数据的访问入口。 验证 验证阶段作用是保证Class...
  • 对象(一)——&对象概念及定义

    万次阅读 多人点赞 2018-05-22 00:09:19
    面向对象程序设计(OOP)是一种程序设计的泛型,同时也是一种程序开发的方法,它将对象作为程序的基本单元,将程序和数据封装其中,以提高软件的重用性、灵活性和扩展性二、对象的概念1. 是现实世界在...
  • Code is never die ! 1. 对象 对象是由属性和方法组成的:是一个...抽象了对象的公共部分,它泛指某一大(class)对象特指某一个,通过实例化一个具体的对象 对象,面向对象总结: 抽象了对象的公共部
  • 对象,方法与函数的区别

    万次阅读 多人点赞 2019-03-11 19:37:30
    面向对象(Object oriented Programming,OOP)编程 的思想主要是针对大型软件设计而来的。面向对象编程将数据和操作数据相关的方法封装到对象中,组织代码和数据的方式更加接近人的思维,使程序的扩展性更强、可读性...
  • C++对象的使用之对象指针

    万次阅读 多人点赞 2019-07-04 21:38:07
    对象的使用之对象指针 对象指针的一般概念 对象指针:指向的成员的指针。在C++中,可以说明指向的数据成员和成员函数的指针。 对象指针遵循一般变量指针的各种规则:类名 *对象指针名; 对象指针名*成员名;...
  • 适配器和对象适配器 适配器 Adapter 继承Adaptee (被适配),同时实现Target 接口(因为 Java 不支持多继承,所以只能通过接口的方法来实现多继承),在 Client 中我们可以根据需要选择并创建任一种...
  • java中map和对象互转工具

    万次阅读 多人点赞 2019-01-05 13:33:41
    在项目开发中,经常碰到map转实体对象或者对象转map的场景,工作中,很多时候我们可能比较喜欢使用第三方jar包的API对他们进行转化,而且用起来也还算方便,比如像fastJson就可以轻松实现map和对象的互转,但这里,...
  • 抽象能创建对象吗?

    千次阅读 2020-07-15 00:27:20
    在面向对象的概念中,所有的对象都是通过来描绘的,但是反过来,并不是所有的都是用来描绘对象的,如果一个中没有包含足够的信息来描绘一个具体的对象,这样的就是抽象。 抽象是不能创建对象的原因: ...
  • 什么是对象对象的关系是什么?

    万次阅读 多人点赞 2019-06-02 14:56:30
    对象 什么是对象?        ...万物皆对象。它包括现实中客观存在的事物,也包括抽象的时间、规则、思维。简单点说,对象具有状态、...具有相同特性和行为的对象组成的集合就是...
  • 基本类型的包装类对象使用 == 和 equals进行比较的结果 1、值不同,使用==和equals比较都返回false 2、值相同 使用==比较: 基本类型-基本类型、基本类型-包装对象返回true 包装对象-包装对象返回...
  • 是Class对象class<?> 因为class<?>描述的是的结构 所以一个特定的class<?>对应一个普通的所有对象(这里有点绕) Class类对象无法直接创建 因为它的构造方法是私有的 是由JVM随...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,795,850
精华内容 2,318,340
关键字:

对象跟类