精华内容
下载资源
问答
  • 什么是面向对象

    万次阅读 多人点赞 2019-09-09 16:54:50
    说的最多的是new个对象,其实并知道什么对象。以为对象就是一个class(类),并觉得有什么特殊。直到很久之后,面试官问到什么是OOP,嘴巴都是一个大O,OOP?WTF?那人厌恶的说到就是面向对象编程。我说:Java...

    面向对象(OOP)概述

    从我们开始接触Java这门语言后,就有人告诉我们这是一门面向对象的语言。说的最多的是new个对象,其实并不知道什么是对象。以为对象就是一个class(类),并不觉得有什么特殊。直到很久之后,面试官问到什么是OOP,嘴巴都是一个大O,OOP?WTF?那人厌恶的说到就是面向对象编程。我说:Java就是面向对象,就是一切以对象为载体,去编程,去面对。面试官: go out ! now!

    img

    滚回来的我赶紧看看什么是OOP,Object Oriented Programming,原来就是面向对象的编程啊,还有OOD(面向对象的设计),OOA(面向对象的分析)。那什么是面向对象呢?要想了解这个问题我们要先了解面向过程,这样对比我们就好理解了。

    很早很早以前的编程是面向过程的,比如实现一个算术运算1+1 = 2,通过这个简单的算法就可以解决问题。但是随着时代的进步,人们不满足现有的算法了,因为问题越来越复杂,不是1+1那么单纯了,比如一个班级的学生的数据分析,这样就有了对象这个概念,一切事物皆对象。将现实的事物抽象出来,注意抽象这个词是重点啊,把现实生活的事物以及关系,抽象成类,通过继承,实现,组合的方式把万事万物都给容纳了。实现了对现实世界的抽象和数学建模。这是一次飞跃性的进步。

    img

    举个最简单点的例子来区分面向过程和面向对象

    有一天你想吃鱼香肉丝了,怎么办呢?你有两个选择

    1、自己买材料,肉,鱼香肉丝调料,蒜苔,胡萝卜等等然后切菜切肉,开炒,盛到盘子里。

    2、去饭店,张开嘴:老板!来一份鱼香肉丝!

    看出来区别了吗?1是面向过程,2是面向对象。

    面向对象有什么优势呢?首先你不需要知道鱼香肉丝是怎么做的,降低了耦合性。如果你突然不想吃鱼香肉丝了,想吃洛阳白菜,对于1你可能不太容易了,还需要重新买菜,买调料什么的。对于2,太容易了,大喊:老板!那个鱼香肉丝换成洛阳白菜吧,提高了可维护性。总的来说就是降低耦合,提高维护性!

    面向过程是具体化的,流程化的,解决一个问题,你需要一步一步的分析,一步一步的实现。

    面向对象是模型化的,你只需抽象出一个类,这是一个封闭的盒子,在这里你拥有数据也拥有解决问题的方法。需要什么功能直接使用就可以了,不必去一步一步的实现,至于这个功能是如何实现的,管我们什么事?我们会用就可以了。

    面向对象的底层其实还是面向过程,把面向过程抽象成类,然后封装,方便我们使用的就是面向对象了。

    面向过程和面向对象的区别

    面向过程

    优点:性能比面向对象好,因为类调用时需要实例化,开销比较大,比较消耗资源。
    缺点:不易维护、不易复用、不易扩展

    面向对象

    优点:易维护、易复用、易扩展,由于面向对象有封装、继承、多态性的特性,可以设计出低耦合的系统,使系统 更加灵活、更加易于维护
    缺点:性能比面向过程差

    面向对象三大特性五大原则

    img

    面向对象的三大特性

    1、封装
    隐藏对象的属性和实现细节,仅对外提供公共访问方式,将变化隔离,便于使用,提高复用性和安全性。

    2、继承
    提高代码复用性;继承是多态的前提。

    3、多态
    父类或接口定义的引用变量可以指向子类或具体实现类的实例对象。提高了程序的拓展性。

    五大基本原则

    • 单一职责原则SRP(Single Responsibility Principle)
      类的功能要单一,不能包罗万象,跟杂货铺似的。

    • 开放封闭原则OCP(Open-Close Principle)
      一个模块对于拓展是开放的,对于修改是封闭的,想要增加功能热烈欢迎,想要修改,哼,一万个不乐意。

    • 里式替换原则LSP(the Liskov Substitution Principle LSP)
      子类可以替换父类出现在父类能够出现的任何地方。比如你能代表你爸去你姥姥家干活。哈哈~~

    • 依赖倒置原则DIP(the Dependency Inversion Principle DIP)
      高层次的模块不应该依赖于低层次的模块,他们都应该依赖于抽象。抽象不应该依赖于具体实现,具体实现应该依赖于抽象。就是你出国要说你是中国人,而不能说你是哪个村子的。比如说中国人是抽象的,下面有具体的xx省,xx市,xx县。你要依赖的抽象是中国人,而不是你是xx村的。

    • 接口分离原则ISP(the Interface Segregation Principle ISP)
      设计时采用多个与特定客户类有关的接口比采用一个通用的接口要好。就比如一个手机拥有打电话,看视频,玩游戏等功能,把这几个功能拆分成不同的接口,比在一个接口里要好的多。

    总结

    • 抽象会使复杂的问题更加简单化。
    • 从以前面向过程的执行者,变成了张张嘴的指挥者。
    • 面向对象更符合人类的思维,面向过程则是机器的思想
    展开全文
  • 为什么面向对象糟透了?

    万次阅读 多人点赞 2019-09-26 14:57:49
    Java又说道:“不一样, 写入文件是底层的实现细节,不是高层策略,假如用户不想把计算的结果保存到文件中了,而是想通过邮件发送,那你的businessLogic也得修改了,对不对?” C语言:“那肯定啊!函数调用嘛,一个...

    又是周末,编程语言“三巨头”Java, Lisp 和C语言在Hello World咖啡馆聚会。

    服务员送来咖啡的同时还带来了一张今天的报纸, 三人寒暄了几句, C语言翻开了报纸,突然眼前一亮:“这篇文章的标题写得好啊, 《为什么面向对象糟透了!》”

    (这是一篇很早之前的文章,作者是大名鼎鼎的Joe Armstrong , 也就是Erlang之父。)

    Java 大吃一惊,居然有人这么骂面向对象?!

    他赶紧抢过来,看了一会儿,说到:“虽然我对去世的Joe Armstrong老先生非常尊敬,但是我对他的观点却不敢苟同,你看他说'数据结构和函数不应该绑到一起!'”

    C语言说:“他说得很有道理啊,函数是实现算法的,就像一个黑盒子,只要理解了它的输入和输出,就理解了它的功能,而数据结构呢就是单纯的‘声明’,为什么要把他们绑在一起呢?”

    “不不不,还是绑在一起好!我给你举个例子,一个栈,如果你把它当成一个完整的对象,那用起来就方便多了。”

    Stack s = new Stack();

    s.push(100);

    s.push(200);

    s.pop();

    C语言不甘示弱:“把数据结构和函数分开也挺好啊!比如我可以创建一个叫做Stack的数据结构,然后写几个对这个数据结构操作的函数。”

    push(stack, 100);

    push(stack, 200);

    pop(stack);

    Java不屑一顾地说:“你看看你这种方式多丑陋啊。”

    C语言寸步不让:“本质都是一样的,你是o.f() ,我是f(o),  有啥区别?”

    Lisp也插了一嘴:“还有我的(f o) ”

    2

    Java无语,心说这两个家伙就是胡搅蛮缠。突然,他心中一动:我怎么忘记多态了。

    Java说:“本质是不一样的,你要知道,o.f()是可以产生多态行为的,这就带来了巨大的好处,我给你举个例子,你有一段业务逻辑,需要把计算的结果记录到文件中,将来还可能会记录别的地方,你的设计可能是这样的。”

    640?wx_fmt=png640

    C语言:“难道不应该如此吗?一个函数调用另外一个函数?”

    Java 说到:“这里有个依赖的问题,就是businessLogic()不但运行期依赖writeToFile(), 在源码级或者编译期也会依赖。”

    C语言:“这不是很正常嘛!”

    Java又说道:“不一样, 写入文件是底层的实现细节,不是高层策略,假如用户不想把计算的结果保存到文件中了,而是想通过邮件发送,那你的businessLogic也得修改了,对不对?”

    640

    640?wx_fmt=png

    C语言:“那肯定啊!函数调用嘛,一个改了,另外一个也得改。”

    “这就是问题了, 编译期/源代码的依赖导致我们没法把系统划分成独立的组件,各自独立开发,独立部署,一个的变化就影响到了另外一个。”

    C语言觉得有一定的道理,他说:“那怎么办?”

    Java说:“你看看我使用多态以后的设计,我的业务逻辑在编译时只依赖那个接口Writer,而不依赖具体的实现FileWriter和MailWriter。”

    640

    640?wx_fmt=png

    “你的意思是只要接口Writer不变化,底层的具体实现如FileWriter ,MailWriter可以随意变化,随意替换,就像插件一样,对吧?”  C语言说到。

    “对啊,编译期/源代码不依赖,运行期依赖,这就是延迟绑定带来的好处,现在你明白o.f()和 f(o)的本质区别了吧。 ”

    Lisp 不失时机又插了一嘴:“你那接口中只有一个函数,就是write(),用什么接口啊,脱裤子放屁,多此一举,在我这儿只要把不同的函数传递过去就可以了。”

    Java笑道:“别抬杠,这就是个简单的例子,不管是用接口,还是传递函数,都是延迟绑定嘛, 关键点都是要找到那个稳定的东西(Writer),就是抽象。你找不到这个稳定的东西,做不出抽象,你的系统就没法划分成可以独立开发,独立变化的组件了。”

    C语言还想反击,但一直找不到突破口。

    Lisp说道:“别听Java在哪里忽悠,C老弟,你也能实现运行期的延迟绑定,这不是Java的专利,你忘了虚函数表了?”

    C语言一拍大腿:“是啊,我忘了那一年春节回家,Linus 大神曾经告诉我,虚函数表和函数指针才是实现多态的关键,比如Unix/Linux把设备都当成了文件,有标准的open , read 等方法,对于不同的设备,都能调用对应的方法, 那是怎么实现的?也是通过虚函数表做延迟绑定嘛!”

    (码农翻身老刘注:C语言实现面向对象的详情可以移步《

    C语言高兴了:“哈哈,Java 老弟,看来我们本质上还是一样的,多态只不过是函数指针的一种应用!”

    Java说:“所以编程的关键不在于是否使用了面向对象的语言,这一点你同意吧?”

    C语言点头,编程的关键点就是找到、抽象出稳定的接口,针对这个接口编程,这样就可以让各个模块能够独立地变化。

    3

    “说起来容易,做起来难,这儿有一个例子,你给我用面向对象设计一下?”  Lisp 抛出了一道题。

    动物可以分为肉食动物,草食动物,水生动物,陆生动物,用类如何表示?

    Java 说:这还不简单,看看这名词多明显啊,都可以变成类啊,让他们都继承动物就可以了。

    640

    640?wx_fmt=png

    Lisp看到Java 掉入了陷阱,狡黠地一笑:“那有的动物就既是陆生动物,又是肉食动物,怎么表达?”

    “那我就加一个陆生肉食动物类。” 虽然觉得不妥,Java还是说了出来。

    640

    640?wx_fmt=png

    “那要是再来一个水生肉食动物怎么办?或者来了一个新的概念‘哺乳动物’, 该怎么处理?”

    “哈哈哈,我懂了,随着需求的增多,不但类会出现爆炸, 还可能会出现那种怪异的类,这面向对象编程确实是有大问题啊!”  C语言说。

    Java 低头沉思不语,突然,脑海中想起来了那句话:优先使用组合而不是继承。

    怎么使用组合?必须得改变下看待问题的方式,对,应该这样:

    640

    640?wx_fmt=png

    Java得意地说:“看看这个图, 动物具备多个特性,如'进食', '移动',将来还可以加上'哺乳方式',每个特性都是一个接口,接口是稳定的, 动物这个概念是可以通过这些接口特性给组合起来的。”

    Lisp 赞赏地点头, C语言向Java投去了钦佩的目光,这家伙经常做面向对象的设计,还是有两把刷子的,他通过特性的方式把变化给隔离了, 各个特性可以通过组合的方式,像插件一样随意替换, 嗯,这才是面向对象的真正精髓啊。

    夜已深, 最后Java做了个总结,大伙散去。

    “编程嘛就是发现变化,并且把它给隔离起来,使用各种语言都可以,面向对象的语言有着直接使用多态的便利,以后不要随随便便就diss它了。”

    参考资料:

    http://www.cs.otago.ac.nz/staffpriv/ok/Joe-Hates-OO.htm

    《敏捷软件开发:原则,模式与实践》

    《架构整洁之道》

    《面向对象开发参考手册》

    关于作者:

    ,15年以上软件开发经验,畅销书《》作者,前 IBM 架构师,领导过多个企业应用架构设计和开发工作;洞察技术本质,擅长用故事去讲解复杂技术。

    往期 精彩回顾

    640?wx_fmt=jpeg

    展开全文
  • 1) main函数在任何类里面,因为这点,所以做不到完全面向对象,下面其他的都是可以解决的 2)基本的数据类型也不是对象(从这点上看JAVA也不是完全面向对象的) 3)友元会破坏封装性 4)支持独立的函数,数据...

    1) main函数不在任何类里面,因为这点,所以做不到完全面向对象,下面其他的都是可以解决的
    2)基本的数据类型也不是对象(从这点上看JAVA也不是完全面向对象的)
    3)友元会破坏封装性
    4)支持独立的函数,数据,即过程化编程


    其实所谓的完全面向对象,是一些人想出来的卖点,并没有太大的实际意义,难道把main包含进class这种语言就强大了?


    C++支持面向过程、基于对象、和面向对象三种模式 


    所谓基于对象是指:我们采用对象封装技术,将数据和操作捆绑在一起,但是并没有合理地使用多态、继承等面向对象技术进行软件设计。很多以前从事C程序开发的人,当他采用面向对象的编程语言(如C++)进行开发时,写出来的程序却是基于对象的。或者说他们是采用面向对象的语言编写面向过程的程序!


    纯粹面向对象:

      (1)   所有东西都是对象。可将对象想象成一种新型变量;它保存着数据,但可要求它对自身进行操作。理论上讲,可从要解决的问题身上提出所有概念性的组件,然后在程序中将其表达为一个对象。
      (2)   程序是一大堆对象的组合;通过消息传递,各对象知道自己该做些什么。为了向对象发出请求,需向那个对象“发送一条消息”。更具体地讲,可将消息想象为一个调用请求,它调用的是从属于目标对象的一个子例程或函数。  
      (3)   每个对象都有自己的存储空间,可容纳其他对象。或者说,通过封装现有对象,可制作出新型对象。所以,尽管对象的概念非常简单,但在程序中却可达到任意高的复杂程度。  
      (4)   每个对象都有一种类型。根据语法,每个对象都是某个“类”的一个“实例”。其中,“类”(Class)是“类型”(Type)的同义词。一个类最重要的特征就是“能将什么消息发给它?”。
      (5)   同一类所有对象都能接收相同的消息。这实际是别有含义的一种说法,大家不久便能理解。由于类型为“圆”(Circle)的一个对象也属于类型为“形状”(Shape)的一个对象,所以一个圆完全能接收形状消息。这意味着可让程序代码统一指挥“形状”,令其自动控制所有符合“形状”描述的对象,其中自然包括“圆”。这一特性称为对象的“可替换性”,是OOP最重要的概念之一。   

    面向对象其实是现实世界模型的自然延伸。现实世界中任何实体都可以看作是对象。对象之间通过消息相互作用。

    如果说传统的过程式编程语言是以过程为中心以算法为驱动的话,面向对象的编程语言则是以对象为中心以消息为驱动。

    用公式表示:
    过程式编程语言为:程序=算法+数据;
    面向对象编程语言为:程序=对象+消息。

    展开全文
  • 新手小白学JAVA 面向对象对象 封装

    万次阅读 多人点赞 2021-05-06 15:58:57
    面向对象概念 面向对象其实是一种编程思想,通过它可以把生活中复杂的事情变得简单化,从原来的执行者...你关注中间的过程,只要找好对象就可以了~ 再比如.我们吃一道菜,无需考虑是怎么传菜,怎么做菜的,只需点菜即

    面向对象概念

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

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

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

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

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

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

    2 面向对象的三大特征

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

    3 类和对象

    3.1 类

    1. Java语言最基本单位就是类,类似于类型。
    2. 类是一类事物的抽象。
    3. 可以理解为模板或者设计图纸。

    3.2 对象

    每个对象具有三个特点:对象的状态,对象的行为和对象的标识。

    1. 对象的状态用来描述对象的基本特征。
    2. 对象的行为用来描述对象的功能。
    3. 对象的标识是指对象在内存中都有一个唯一的地址值用来和其他对象区分开来。
    4. 类是一类事物的抽象,对象是具体的实现。

    3.3 类和对象的关系

    1. 计算机语言来怎么描述现实世界中的事物的? 属性 + 行为
    2. 那怎么通过java语言来描述呢?
      我们可以通过类来描述一类事物,用成员变量描述事物的属性,用方法描述事物的行为.

    3.4 练习:类的创建使用

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

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

    对象:除此之外,我们还可以创建对象,就相当于是照着图纸制造出来的一个个的手机,比如1号手机对象,包含特有的成员变量和方法
    我们通过class关键字创建类,通过new关键字创建对象。
    接下来我们开始编码吧!
    创建包: cn.tedu.oop
    创建类: TestCreateClass.java

    package cn.tedu.oop;
    /**本类用来练习面向对象
     * 分析手机事物:--通过类来描述
     * 属性:品牌 价格 尺寸 颜色
     * 功能:打电话 发短信 听直播
     * */
    //在一个java文件中可以写多个class,但是被public修饰的只能有一个,而且这个类的名字就是文件名
    public class TestCreateClass {
    	public static void main(String[] args) {
    		//2.在main()中通过new关键字来创建对应类的对象
    		Phone p = new Phone();
    		//3.通过.来完成对象功能的调用
    		p.call();
    		p.message();
    		p.learn();
    		//4.通过.来查看对象的属性值
    		System.out.println(p.brand);
    		System.out.println(p.price);
    		System.out.println(p.size);
    		System.out.println(p.color);
    		
    	}
    }
    //1.通过class关键字创建手机类--用来描述手机这一类事物--特征+行为
    //类是一类事物的抽象,只抽象的规定这一类事物的特征和行为
    class Phone{
    	//特征(属性)--类的成员变量来描述--位置:类里方法外
    	String brand;//品牌
    	double price;//价格
    	double size;//尺寸
    	String color;//颜色
    	
    	//行为(功能)--类的方法来描述--修饰符 返回值类型 方法名(参数列表){方法体}
    	public void call() {
    		System.out.println("正在打电话");
    	}
    	public void message() {
    		System.out.println("正在发短信");
    	}
    	public void learn() {
    		System.out.println("正在看直播");
    	}
    }
    

    3.5 对象在内存中的存储

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

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

    3.6 练习2:创建多个对象

    package cn.tedu.oop;
    /**本类用来练习面向对象
     * 分析手机事物:--通过类来描述
     * 属性:品牌 价格 尺寸 颜色
     * 功能:打电话 发短信 听直播
     * */
    //在一个java文件中可以写多个class,但是被public修饰的只能有一个,而且这个类的名字就是文件名
    public class TestCreateClass {
    	public static void main(String[] args) {
    		//2.在main()中通过new关键字来创建对应类的对象
    		Phone p = new Phone();
    		//3.通过.来完成对象功能的调用
    		p.call();
    		p.message();
    		p.learn();
    		//4.通过.来查看对象的属性值
    		System.out.println(p.brand);
    		System.out.println(p.price);
    		System.out.println(p.size);
    		System.out.println(p.color);
    		
    		//5.创建第二个对象
    		Phone p2 = new Phone();
    		
    		//5.1调用模板里的功能
    		p2.call();
    		p2.message();
    		p2.learn();
    		
    		//5.2给对象的属性设置值
    		p2.brand = "HUAWEI";
    		p2.price = 8888.88;
    		p2.size = 5.6;
    		p2.color = "中国红";
    		
    		//5.3通过.来查看对象的属性值
    		System.out.println(p2.brand);
    		System.out.println(p2.price);
    		System.out.println(p2.size);
    		System.out.println(p2.color);
    		
    	}
    }
    //1.通过class关键字创建手机类--用来描述手机这一类事物--特征+行为
    //类是一类事物的抽象,只抽象的规定这一类事物的特征和行为
    class Phone{
    	//特征(属性)--类的成员变量来描述--位置:类里方法外
    	String brand;//品牌
    	double price;//价格
    	double size;//尺寸
    	String color;//颜色
    	
    	//行为(功能)--类的方法来描述--修饰符 返回值类型 方法名(参数列表){方法体}
    	public void call() {
    		System.out.println("正在打电话");
    	}
    	public void message() {
    		System.out.println("正在发短信");
    	}
    	public void learn() {
    		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) {
            //5.创建对象进行测试
            User u = new User();
            u.name = "西门庆";
            System.out.println(u.name);
            //需要封装属性,如果不封装的话,就可以直接修改属性的值
            //不需要按照我们预先设置好的方式也能操作
            //u.money = 1000000;
            //System.out.println(u.money);
            u.setMoney(109999);
            System.out.println(u.queryMoney());
    
        }
    }
    //1.创建一个用户类User
    class User{
        //2.定义用户类的属性
        public String name;
        private double money = 10000;
    
        //3.提供方法1:可以用来查询当前账户的余额
        public double queryMoney(){
            /*后续可以添加权限的校验*/
            return money;
        }
        //4.提供方法2:可以设置当前账户的余额
        public void setMoney(double money){
            /*后续可以添加权限的校验*/
            this.money = money;
        }
    }
    

    4.3.2 练习:封装学生案例

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

    package cn.tedu.oop;
    /*本类用于测试面向对象第一大特性--封装*/
    public class TestPrivate2 {
        public static void main(String[] args) {
            //4.创建学生类对象s
            Student s = new Student();
            //5.通过对象操作学生类的属性与方法
            System.out.println(s.name);//null
            s.study();//正在学习中。。。
            /*2.subject属性在Student类中被private修饰,所以此处无法直接修改或获取值*/
            //s.subject = "Java培优";
            //System.out.println(s.subject);//Java培优
            //6.3在main()里操作subject属性
            s.setSubject("CGB");//设置值
            System.out.println(s.getSubject());//获取值
            //7.3操作属性sno
            s.setSno(1);
            int snumber = s.getSno();
            System.out.println("接到的学号是:"+snumber);
            System.out.println(s.getSno()+"直接打印的");
        }
    
    }
    
    //1.描述学生这一类型
    class Student{
        //2.特征:学号 姓名 科目--成员变量/属性
        //7.1封装属性,用private修饰这个属性
        private int sno;//学号
        String name;//姓名
        /*1.private是一个修饰符,被它修饰的资源只能在本类中使用,是权限最小的修饰符*/
        //6.1封装subject属性
        private String subject;//科目
    
        //7.2添加sno属性对应的get()与set()
        public int getSno() {
            return sno;
        }
        public void setSno(int sno) {
            this.sno = sno;
        }
    
        //6.2我们需要提供一个公共的方式,供外界操作subject的属性值
        //右键空白处->Generate->Getter and Setter->选中subject属性->OK
        public String getSubject() {
            /*4.如果一个方法需要返回结果,那么这个方法定义的返回值类型就不再是void了
            * 至于具体设置成什么类型,与返回值的类型保持一致
            * 比如我们要返回的subject是String类型,所以方法的返回值类型为String
            * 返回值通过关键字return进行返回*/
            return subject;
        }
        public void setSubject(String subject) {
            /*3.如果一个类中的成员变量与局部变量同名
            * 需要使用this关键字指定,我们规定this指定的那个是成员变量*/
            this.subject = subject;
        }
    
        //3.功能:学习 吃饭 睡觉--方法
        public void study(){
            System.out.println("正在学习中。。。");
        }
        public void eat(){
            System.out.println("正在吃饭ing...");
        }
        public void sleep(){
            System.out.println("我一点也不想睡觉,就想学Java!");
        }
    }
    

    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();//又创建了一个对象调方法

    展开全文
  • 前提是:此父类对象为子类对象强转的结果 例如:  Father father = (Father)son; 当这种情况时,可以用instanceof判断是否是子类类型(实际) 然后强转回去  if(father instanceof Son)  Son son =...
  • 为什么 HashMap 常用 String 对象作 key

    万次阅读 2017-12-18 22:32:04
    偶然的一次机会看到了这个题目,有一个网上的朋友说在面试的时候面到了这道题目,没有能给出解释...String 类型的对象对这个条件有着很好的支持,因为String 对象的hashCode() 值是根据String 对象的内容计算的,并...
  • 什么是面向对象程序设计

    万次阅读 多人点赞 2019-08-22 11:10:04
    如果您看其他语言(如 java)的语法,本文涉及。 1.面向对象和面向过程区别 面向过程程序设计:所谓的面向过程程序设计就是函数的定义和调用。简单地说,过程就是程序执行某项操作的一段代码,函...
  • 面向对象与面向过程的本质的区别

    万次阅读 多人点赞 2018-01-10 20:19:04
    如果你很搞明白面向对象什么,面向过程是什么,或者说二者之间的区别是什么,那么就花费一点时间来研读一下这篇博客,你一定会有很大的收获的! 一、面向对象与面向过程的区别 面向过程就是分析出解决问题所...
  • Java什么叫面向对象

    万次阅读 多人点赞 2018-08-15 21:56:17
    什么是面向对象呢?...对象这个词你可以理解一个总称,比如男人女人都叫人,蜡烛皮鞭高跟鞋都是道具,所以面向对象原本的意思是“都叫对象”,翻译过来不是原汁原味了而已因此,房子是对象、飞机是对象...
  • 针对state为对象,要修改对象中某一个值而修改其他值,请欣赏接下来的方法 1.设置state对象 state={ datavalue:{ slid:'', name:'', memo:'', version:'', icon:defaultimg, loginlink:'', key:'', ...
  • 一、引言 最近在写微信小程序项目的时候,第一次接触到了 JavaScript。 于是乎,在一个场景中,我写了如下的代码: var a = {'name': 'wangying'};...结果我惊喜的发现,a 对象里面的 name ...这是为什么呢? ...
  • js判断对象为空以及有好几种方法了,但是个人觉得不是特别方便。 比如: 1、把对象通过 JSON.stringify 转为字符串,再判断字符串是否等于 " {} " 2、for in循环,判断key是否存在 3、jq的方法 es6已经帮我们很...
  • 面向对象什么鬼(OOP)

    万次阅读 多人点赞 2016-08-24 11:09:02
    什么是面向对象我们知道现代的编程方式基本上都是面向对象了,那么面向对象什么鬼,面向对象跟面向过程有什么不一样? 面向对象编程(英文Object Oriented Programming),所以也叫做OOP。我们知道早期的计算机...
  • js过滤出对象要的数据

    万次阅读 2019-03-11 17:05:34
    * [过滤对象] * @param obj [过滤前数据] * @param arr [过滤条件,要求为数组] */ function filterObj(obj, arr) { if (typeof (obj) !== "object" || !Array.isArray(arr)) { throw new ...
  • 面试 | 什么是面向对象(OOP)?

    千次阅读 多人点赞 2019-03-02 23:51:31
    旁白:这是一个很大的问题,我觉得面试官主要听到的一定是面向对象给编程带来的好处,也就是说它独有的特点,所以重点应该要抓住封装、继承和多态三大特性来说。这里我回答的思路是:①面向对象思想的由来;②如何...
  • 如何判断一个对象是否空{}

    万次阅读 2019-05-28 12:34:57
    我们要判断对象是否空,像基本类型那样判断是可以的, ==={} ?这样是错误的, 因为只是比较引用地址是否相同,所以可以采取下面的方法来进行判断 1.根据for...in遍历对象,如果存在则返回true,否则返回false...
  • 在jQuery中,在一个页面上选择元素返回的集合是jQuery对象而不是原始的DOM对象. 所以只能运行jQuery方法. 如果要在选择集上运行DOM方法和属性,该集合必须转化DOM对象 ...如果确实这么.那么就需要将jQu
  • 一.创建与保存 1.根据一个文件路径创建Image对象 Image image = ImageIO.read(new File(filepath)); 2.将Image对象保存文件形式 ...//要保存这个对象的话你要把image声明BufferedImage 类型
  • 什么是面向对象(OOP)

    万次阅读 多人点赞 2018-10-30 20:13:00
    说的最多的是new个对象,其实并知道什么对象。以为对象就是一个class(类),并觉得有什么特殊。直到很久之后,面试官问到什么是OOP,嘴巴都是一个大O,OOP?WTF?那人厌恶的说到就是面向对象编程。我说:Java...
  • 什么是面向对象的编程思想?

    万次阅读 2017-05-16 09:44:11
    面向对象的编程产生的历史原因:由于面向过程编程在构造系统时,无法解决重用,维护,扩展的问题,而且逻辑过于复杂,代码晦涩难懂,因此,人们开始能让计算机直接模拟现实的环境,以人类解决问题的方法,思路...
  • 项目的过程中,遇到需要在页面判断... 根据习惯,判断当对象不为空的时候,我是这么写的: $value neq null"> ****** ****** 经过运行,这么写一点效果都没有。经过翻查资料,找到了一种解决办法:($value) neq
  • 要在手机上玩转u3d,一定会的一个就是对象池,在这里我打算讨论对象池本身,基本思路大同小异。我这里讨论的是切换场景引发的对象池中对象的问题。  首先如果你什么处理,那么一旦你切换场景,你会发现...
  • 从后台获取数组对象对象添加只在前端用得上的属性如item_checked: false 代码 axios.get(url).then(response=>{ if(response.status === 200){ this.list = response.data this.list.forEach(el=>{ ...
  • java对象结构

    万次阅读 多人点赞 2017-04-19 22:31:57
    在HotSpot虚拟机中,对象在内存中存储的布局可以分为3块区域:对象头(Header)、实例数据(Instance Data)和对齐填充(Padding)。下图是普通对象实例与数组对象实例的数据结构: 对象头 HotSpot虚拟机的...
  • TP5 JSON对象数组转换普通数组

    万次阅读 2017-03-28 22:49:59
    使用TP5框架项目时,对于数据的查询返回的都是对象,虽然也可以当做普通的数组进行遍历进而进行后续处理,但这种形式直接扔给前端或者我在返回的结果中临时增加一个数据字段,此时这种json对象数组形式就方便...
  • 使用数据库的管理工具Navicat prmium查看表的sql语句,右键点击表后点对象信息没有反应
  • js中复制对象的属性值给新的对象

    万次阅读 2019-07-05 17:10:32
    我们有一个对象,且包含很多属性值和方法,但是我们把它的内部属性复制给一个新的对象时,我们如何去呢? 你可能会说直接 a = b就可以了。 no no no,这样两个对象其实指针指向的还是一个内存中的对象,当一个...
  • 你知道什么是面向对象吗?

    千次阅读 多人点赞 2019-03-05 11:02:52
    知道是不是有人和我一样,刚开始只是知道Java是面向对象开发的语言,但是什么是面向对象呢?(我开始的想法就是我知道那玩意有啥用)我在了解这个问题的过程中看到了很多答案。但是万变离其宗。 首先,什么是...
  • 在word里面插入对象显示全怎么办

    千次阅读 2019-12-23 09:37:08
    经常在word即插入对象excel,有时excel表格很长导致在word只能看到部分的excel,显示全。 怎么操作才能显示全部呢? 首先,关闭对象,来到word页面; 接着,双击word里的excel; 最后,通过拖拽边框上的黑点来调整...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,311,318
精华内容 924,527
关键字:

对象为什么不想做