精华内容
下载资源
问答
  • 很不理解,今天就跟同学们聊聊西方一周的第一天为什么是Sunday,而不是Monday?其实语言文化的载体,语言历史演变的体现者。一周七天制度其实来自著名的古巴比伦,后来传到了古埃及和古罗马,古罗马人用...

    语言不枯燥,带着好奇学。Hello guys, this is Mr.Shao.很多同学在选择西方第一天的时候下意识地按照现在中国人的习惯错误地选择了Monday,结果发现正确答案是Sunday。很不理解,今天就跟同学们聊聊西方一周的第一天为什么是Sunday,而不是Monday?

    5de527a3a18e789a5141c8c3ff9fb548.png

    其实语言是文化的载体,语言是历史演变的体现者。一周七天制度其实来自著名的古巴比伦,后来传到了古埃及和古罗马,古罗马人用自己信奉的神的名字命名了一周七天,星期日是Sun’s Day(太阳神日),星期一是Moon’s Day(月亮神日),每一天来代表一个神。那周日太阳神之日为什么成了一周的第一天呢?

    一种说法是来自太阳崇拜,

    66ade85673e5bab797f9049e5e14659c.png

    古埃及人崇拜太阳神而设立了太阳日“day of the sun”,太阳是太阳系中的第一,是所有天体中对人类意义最大的,

    9bc604fc52c57eb26156e943def12af5.png

    所以,太阳神被放在最尊崇的位置

    另一种说法是,基督教和伊斯兰教开始以星期为单位进行宗教礼拜活动,因此礼拜也成了星期的另外一种说法。

    根据《圣经创世纪》

    ee85663c76b7fc05c49ee67f0eb49360.png

    ,上帝在一周的星期一到星期六创造了世界,然后在星期日休息,所以犹太教和基督教星期日要做礼拜,敬神这样的事情自然要优先,所以放在每星期的第一天也就是周日来做

    还有一种说法是耶稣是在星期日复活的

    7de3459f453d4e91a3006edae3982601.png

    ,所以将礼拜日作为星期日,咱们知道复活节就是在春分月圆之后第一个星期日。

    所以,最后因为种种原因,星期日成为了西方的一周第一天。这样了解知识背后的文化后再去理解记忆是不是比死记硬背有意思?

    感觉有收获的话,请点赞加关注!也可以转发到您的朋友圈,感谢支持!我会持续更新的!

    展开全文
  • Java学习第七天 ———— 第一周学习汇总 第一章Java Java一门面向对象编程语言,不仅吸收了C++语言的各种优点,还摒弃了C++里难以理解的多继承、指针等概念,因此Java语言具有功能强大和简单易用两个特征。Java...

    Java学习第七天 ———— 第一周学习汇总

    第一章Java

    Java是一门面向对象编程语言,不仅吸收了C++语言的各种优点,还摒弃了C++里难以理解的多继承指针等概念,因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表,极好地实现了面向对象理论,允许程序员以优雅的思维方式进行复杂的编程 [1]

    1.1 什么是Java

    1.1.1java发展史

    1991年,Sun公司为了进军家用电子消费市场,成立了一个代号为Green的项目组。 Oak(橡树)系统出现。

    Oak以C++语言为蓝本,吸收了C++中符合面向对象程序设计要求的部分,同时加入了一些满足网络设计要求的部分。

    1994年,Green项目组成员认真分析计算机网络应用的特点,认为Oak满足网络应用所要求的平台独立性、系统可靠性和安全性等,并用Oak设计了一个称为WebRunner(后来称为HotJava)的WWW浏览器。

    1995年5月23日,Sun公司正式发布了Java和HotJava两项产品。

    Java语言一经推出,就受到了业界的关注。Netscape公司第一个认可Java语言,并于1995年8月将Java解释器集成到它的主打产品Navigator浏览器中。接着,Microsoft公司在Internet Explorer浏览器中认可了Java语言。Java语言开始了自己的发展历程。

    目前使用的Java版本是Java2,它包括J2SE、J2EE、J2ME三个版本,分别用于不同的领域。

    J2SE(Java Standard Edition)—用于工作站、PC机,为桌面开发和低端商务应用提供了Java标准平台。

    J2EE(Java Enterprise Edtion)—用于服务器,构建可扩展的企业级Java平台。

    J2ME(Java Micro Edtion)—嵌入式Java消费电子平台,适用于消费性电子产品和嵌入式设备。

    1.2 java的特性

    Java语言是简单的、面向对象的语言,它具有分布式安全性,又可以实现多线程,更主要的是它与平台无关,解决了困扰软件界多年的软件移植问题。

    1.2.1面向对象

    面向对象(object-oriented)程序设计模式是近代软件工业的一种革新,它提供软件的弹性度(flexibility)、模块化(modularity)与重复使用率(resability),降低开发时间与成本。Java是完全对象化的程序语言,编程重点在于产生对象、操作对象以及如何使对象能一起协调工作,以实现程序的功能。

    1.2.2语法简单

    Java语言的语法结构类似于C和C++,熟悉C++的程序设计人员不会对它感到陌生。与C++相比,Java对复杂特性的省略和实用功能的增加使得开发变得简单而可靠

    1.2.3平台无关系

    平台无关性是指Java能运行于不同的系统平台。Java引进虚拟机概念,Java虚拟机(Java Virtual Machine,称为JVM)建立在硬件和操作系统之上,用于实现对Java字节码文件的解释和执行,为不同平台提供统一的Java接口。这使得Java应用程序可以跨平台运行,非常适合网络应用。

    1.2.4安全性

    安全性是网络应用系统必须考虑的重要问题。Java设计的目的是提供一个网络/分布式的计算环境,因此,Java特别强调安全性。Java程序运行之前会利用字节确认器进行代码的安全检查,确保程序不会存在非法访问本地资源、文件系统的可能,保证了程序在网络间传送运行的安全性。

    1.2.5分布式应用

    Java为程序开发提供了Java.net包,该包提供了一组类,使程序开发者可以轻易实现基于TCP/IP的分布式应用系统。此外,Java还提供了专门针对互联网应用的一整套类库,供开发人员进行网络程序设计。

    1.2.6多线程

    Java语言内置了多线程控制,可使用户程序并行执行。利用Java的多线程编程接口,开发人员可以方便地写出多线程的应用程序。Java语言提供的同步机制可保证各线程对共享数据的正确操作。在硬件条件允许的情况下,这些线程可以直接分布到各个CPU上,充分发挥硬件性能,提高程序执行效率。

    1.3JDK和JRE

    1.3.1 JDK

    Java不仅提供了一个丰富的语言和运行环境, 而且还提供了一个免费的Java软件开发工具集(Java Developement Kits, 简称JDK)。到目前为止,Sun公司先后发布了多个主要的JDK的版本。其主要版本的发布时间和特点如下:

    ① JDK1.0:1995年推出,是Java最早的编译环境。

    ② JDK 1.2:1998年发布,在图形化用户界面、数据库互连以及其他许多方面作了重大改进。这个版本也称作带有JDK 1.2的Java 1.2版本。由于该版本具有重大改变,所以从Java 1.2版本后的Java语言也称作Java 2语言。

    ③JDK 1.3:在多媒体应用、编译速度等方面做了改进。

    ④JDK 1.4:是目前的最新版本。

    通常所说的J2SDK,是指与Java 2语言相对应的Java SDK(Java Software Developement Kits),它是对较新版本中JDK的一个特定称呼。J2SDK(JDK)包括Java的编译器、解释器、调试器等开发工具以及Java API类库。编程人员和最终用户可以利用这些工具来开发java程序。其调试工具主要包括Java语言编译javac,用于编译Java源程序;Java字节码解释器java,用于解释运行Java程序,显示程序运行结果;小应用程序浏览工具appletviewer,用于测试并运行Java小程序。

    1.3.2JDK安装与配置

    为了建立起Java的运行环境,可以到SUN公司的网站(http://www.sun.com)上下载最新的JDK。建议同时下载其Java Documentation,这是Java帮助文档。

    以JDK1.4.2版的J2SDK为例(即j2sdk 1.4.2),运行下载的j2sdk-1_4_2_02-windows-i586.exe文件,开始进行Java环境的正式安装。默认安装于c:/j2sdk1.4.2目录下,用户可以更改这个默认安装目录,但建议安装路径不要有空格,因此不宜安装在/Program Files目录下。

    接下来需要设置运行环境参数,以便能够在Windows的任何目录下面都能编译和运行Java程序。对于使用Win95/98的用户,需要编辑autoexec.bat文件,在其最后面添加如下的2行语句,保存文件并重新启动系统。

    set path=%path%;c:/j2sdk1.4.2/bin

    set classpath=.; c:/j2sdk1.4.2/lib

    对于Win2000或xp的用户,使用鼠标右击【我的电脑】,依次选择【属性】│【高级】│【环境变量】,打开【环境变量】对话框,在【系统变量】列表框中,单击【新建】按钮,新建环境变量classpath,其变量值为“.; c:/j2sdk1.4.2/lib”;选择path变量,单击【编辑】按钮,在path变量的变量值后面加上“;c:/j2sdk1.4.2/bin”。或者,直接编辑path变量,在其变量值后面加上“;c:/j2sdk1.4.2; c:/j2sdk1.4.2/lib;c:/j2sdk1.4.2/bin”。

    1.3.3java运行和编译

    Java源程序是一种文本文件,可以使用任何的文本编辑器编写,只是要注意存储时的文件名后缀名必须是.java。建议读者把所有源程序文件都保存在一个指定的目录下,便于调试和运行。

    这里向大家推荐两种编辑器:一是Windows的记事本,一是文本编辑工具UltraEdit和EditPlus。使用Windows记事本编辑Java源程序文件,存储时先选择*.*(所有文件)的文件类型,然后,输入带有.java后缀的文件名;或者直接以带英文双引号“XXXX.java”的形式输入文件名。UltraEdit和EditPlus是两个非常易用且功能强大的文本编辑工具。编辑时,它们自动地把关键字、常量、变量等不同元素用不同的颜色区分开来,从而有助于减少语法错误。

    如果读者习惯使用像Word这类文字处理软件,则应注意不要在文件中加入任何格式排版信息,确保得到的文件是文本文件。应当指出,尚有其它的Java开发工具可供选择,如JCreator、JBuilder 、Eclipse、NetBean、Visual J++等。

    Java是解释型语言。Java源程序必须先由Java编译器进行编译,生成字节码文件(也称类文件),然后在Java解释器的支持下解释运行。

    Java编译器是javac.exe,其用法如下:

    javac filename.java

    其中filename.java是java源程序文件的文件名。如果编译器没有返回任何错误信息,则表示编译成功,并在同一目录下生成与类名相同的字节码文件filename.class。如果编译出错,则需查找错误原因,进一步修改源程序,并重新编译。

    Java解释器是程序java.exe,其用法如下:

    java filename

    其中filename是编译生成的java字节码文件的文件名,注意不要带后缀名.class。

    1.4java语言开发步骤

    Java程序的运行必须经过编写编译运行三个步骤。

    编写是指在Java开发环境中进行程序代码的输入,最终形成后缀名为.java的Java源文件。

    编译是指使用Java编译器对源文件进行错误排查的过程,编译后将生成后缀名为.class的字节码文件,这不像C语言那样最终生成可执行文件。

    运行是指使用Java解释器将字节码文件翻译成机器代码,执行并显示结果。这一过程如图1.1所示。

    img

    字节码文件是一种和任何具体机器环境及操作系统环境无关的中间代码,它是一种二进制文件,是Java源文件由Java编译器编译后生成的目标代码文件。编程人员和计算机都无法直接读懂字节码文件,它必须由专用的Java解释器来解释执行,因此Java是一种在编译基础上进行解释运行的语言。

    Java解释器负责将字节码文件翻译成具体硬件环境和操作系统平台下的机器代码,以便执行。因此Java程序不能直接运行在现有的操作系统平台上,它必须运行在被称为Java虚拟机的软件平台之上。

    Java虚拟机(JVM)是运行Java程序的软件环境,Java解释器就是Java虚拟机的一部分。在运行Java程序时,首先会启动JVM,然后由它来负责解释执行Java的字节码,并且Java字节码只能运行于JVM之上。这样利用JVM就可以把Java字节码程序和具体的硬件平台以及操作系统环境分隔开来,只要在不同的计算机上安装了针对于特定具体平台的JVM,Java程序就可以运行,而不用考虑当前具体的硬件平台及操作系统环境,也不用考虑字节码文件是在何种平台上生成的。JVM把这种不同软硬件平台的具体差别隐藏起来,从而实现了真正的二进制代码级的跨平台移植。JVM是Java平台无关的基础,Java的跨平台特性正是通过在JVM中运行Java程序实现的。Java的这种运行机制可以通过图1.2说明。

    img

    Java语言这种“一次编写,到处运行(write once,run anywhere)”的方式,有效地解决了目前大多数高级程序设计语言需要针对不同系统来编译产生不同机器代码的问题,即硬件环境和操作平台的异构问题,大大降低了程序开发、维护和管理的开销。

    需要注意的是,Java程序通过JVM可以达到跨平台特性,但JVM是不跨平台的。也就是说,不同操作系统之上的JVM是不同的,Windows平台之上的JVM不能用在Linux上面,反之亦然。

    1.5面向对象程序设计

    面向对象程序设计(Ojbect-Oriented Programming,OOP)是近代软件设计领域的一大革命。在大型系统的开发中,OOP技术使得程序结构简单,相互协作容易,更重要的是提高了程序的重复使用率,并降低了维护成本。

    Java语言是一种完全面向对象的程序设计语言,它通过类、对象等概念来组织和构建整个程序,因此,理解面向对象的基本概念是学习Java的前提和基础。

    1.5.1类和对象

    所谓对象就是真实世界中的实体,对象与实体是一一对应的,也就是说现实世界中每一个实体都是一个对象,它是一种具体的概念。

    类是具备某些共同特征的对象的集合,用程序设计的语言来说,类是一种抽象的数据类型。

    类是对对象的抽象,而对象是对类的具体化。

    面向对象的程序设计方法,首先是进行合理的抽象,即把问题中涉及的客观实体分割出来,抽取其共同的属性和方法;然后根据抽象出的结果设计可重复使用的类;通过类去定义一个个的对象(称为类的实例化)。最后,按照问题的要求,操作对象实现软件的功能。

    1.5.2类的封装,继承,多态

    在面向对象的程序设计中,描述对象特征的属性由变量来表示,也称为数据

    描述对象行为的方法由函数来实现。这样对象就是数据加方法

    将数据及对数据的操作方法捆绑在一起构成类,就是所谓的封装。这是面向对象程序设计的重要特性之一。

    无论一个对象方法的目的是什么,最终都表现为对对象数据的操作,包括把对象的状态告知外界以及改变对象的状态等。只要有足够的方法,就没有必要去直接操作对象的属性,对象与外界打交道全部通过其自身的方法来实现。封装性有效地把对象的属性隐藏在对象的内部,以避免属性被不正当的存取。同时,对于外界而言,不需要了解对象的方法是如何工作的,只需要知道对象有哪些方法以及如何调用这些方法。就好比一辆汽车要停车,你并不需要知道变速箱、液压系统、刹车系统等机构的细节如何运作,只要踩下离合器和刹车踏板即可。因此,封装使得程序的设计与实现有效地分开,降低了方法之间的相互依赖,提高了对象之间的独立程度,提升了程序的可维护性。

    继承是指在一个已有类的基础上,通过添加新的数据和方法,从而构成一个新类的过程。继承是一种机制,它使得一个新类不仅拥有自己独特的数据和方法,而且具有被继承类的数据和方法,但却不用写重复的代码,实现了代码复用,方便了功能扩充。由继承得到的类称为子类,被继承的类叫做父类或超类。

    多态,这个词是从希腊文而来,意思是“许多状态”。在同一个类中可有许多同名的方法,但其参数数量与类型不同,这些同名不同参数的方法之间构成多态。

    作为面向对象的设计语言,Java很好地实现了类的封装、继承、多态。这将在以后的内容中逐步展开学习。

    第二章 变量和常量

    2.1常量及常量的分类

    在程序运行过程一直不会改变的量称为常量,通常也成为"final变量"。常量在整个程序中只能被赋值一次。在为所有的对象共享值时,常量是非常有用的。声明常量的标准语法为:final 数据类型 变量名[=值]

    常量名通常使用大写字母,但这不是必须。很多Java程序员使用大写字母表示常量,是为了清楚的表明正在使用常量

    当定义的final变量为成员变量时,必须在定义时就设定它的初始值,否则将会提示编译错误。

    
    

    2.2数据类型

    数据类型可以分为基本数据类型和引用数据类型

    基本数据类型,可分为四类

    • 整型 byte short int long
    • 浮点型 float double
    • 逻辑型 boolean
    • 字符型 char

    基本数据类型对应包装类

    java.lang.Byte、java.lang.Short、java.lang.Integer、java.lang.Long、java.lang.Float、java.lang.Double、java.lang.Boolean、java.lang.Character

    八种基本数据类型的默认值

    序号 数据类型 大小/位 封装类 默认值(零值) 可表示数据范围
    1 byte(字节) 8-bit Byte (byte)0 -128~127
    2 short(短整数) 16-bit Short (short)0 -32768~32767
    3 int(整数) 32-bit Integer 0 -2147483648~2147483647
    4 long(长整数) 64-bit Long 0L -9223372036854775808~9223372036854775807
    5 float(单精度) 32-bit Float 0.0F 1.4E-45~3.4028235E38
    6 double(双精度) 64-bit Double 0.0D 4.9E-324~1.7976931348623157E308
    7 boolean but its “size” isn’t something that’s precisely defined. Boolean flase true或false
    8 char(字符) 16-bit Character ‘\u0000’(对应数字0,输出为空) 0~65535

    2.3变量

    2.3.1定义

    变量的定义:定义变量就是要告诉编译器这个变量的数据类型,这样编译器才知道需要分配多少空间给它,以及它能存放什么样的数据。在程序运行过程中空间的值是变化的,这个内存空间就成为变量。为了便于操作,给这个变量取个名字,称为变量名。

    2.3.2命名规则

    1. 变量名必须是一个有效的标识符
    2. 变量名不可以使用Java中的关键字
    3. 变量名不能重复
    4. 应选择有意义的单词作为变量名。

    命名方式

    1. 大驼峰
    2. 小驼峰

    2.3.3使用变量的使用以及注意事项

    创建一个变量的格式;

    1. 数据类型 变量名;

    2. 数据类型 变量名 = 数据值;

    3. 数据类型 变量名,变量名,… ;

    4. 数据类型 变量名 = 数据值,变量名 = 数据值,… ;

    使用变量时的注意事项
    1.如果创建多个变量,那么变量之间的名称不可以重复
    2.对于使用float 和long类型来说,字符后缀的F或L不要丢掉
    3.如果使用byte或者short 类型的变量,那么右侧的数据值不能超过左侧的类型取值范围
    4.没有进行赋值的变量,不能直接使用,一定要赋值之后,才能使用
    【作用域】:从定义一个变量的一行开始,直到所属的大括号结束为止
    5.变量使用不能超过作用域的范围
    6.可以通过一个语句来创建多个变量,一般情况下不推荐使用

    2.3类型转换

    当数据类型不一样时,将会发生数据类型转换

    数据类型转换分为自动类型转换(隐式)和强制类型转换(显式)

    自动转换是程序在执行过程中“悄然”进行的转换,不需要用户提前声明,一般是从位数低的类型向位数高的类型转换;强制类型转换则必须在代码中声明,转换顺序不受限制。

    自动类型装换(隐式)
    1.特点:代码不需要进行处理,自动完成
    2.规则;数据范围从小到大
    强制类型转换(显式)
    1.特点;代码需要进行特殊处理,不能自动完成
    2.格式:数值范围小的数据类型 数值范围小的变量名 = (数值范围小的变量类型) 原本数值范围大的数据类型;

    注意意事项;
    1.强制类型转换一般不推荐使用,因为有可能发生精度损失,数据溢出
    2.byte/short/char这三种数据类型都可以发生数学运算,例如加法”+“
    3.byte/short/char/这三种类型在运算的时候会首先提升为一个int类型,然后计算
    4.boolean不能发生数据类型转换

    基本数据类型范围大小比较

    double>float>long>int>short,byte,char。(注意这里的数据范围并不是指数据之大小,所以和数据类型所占的字节数没有必然联系

    /*
    当数据类型不一样是,将会发生数据类型转换
    自动类型装换(隐式)
    1.特点:代码不需要进行处理,自动完成
    2.规则;数据范围从小到大
    强制类型转换(显式)
    1.特点;代码需要进行特殊处理,不能自动完成
    2.格式:数值范围小的数据类型 数值范围小的变量名 = (数值范围小的变量类型) 原本数值范围大的数据类型;
    注意意事项;
    1.强制类型转换一般不推荐使用,因为有可能发生精度损失,数据溢出
    2.byte/short/char这三种数据类型都可以发生数学运算,例如加法”+“
    3.byte/short/char/这三种类型在运算的时候会首先提升为一个int类型,然后计算
    4.boolean不能发生数据类型转换
    */
    public class 数据类型转换 {
    public static void main(String[] args) {
    System.out.println(1024);//这是一个整数,默认为int
    System.out.println(3.14);//这是一个浮点数,默认就是double


    public class 数据类型转换 {
    public static void main(String[] args) {
    System.out.println(1024);//这是一个整数,默认为int
    System.out.println(3.14);//这是一个浮点数,默认就是double
    //左边是long类型,右边默认是int类型,左右数据类型不一样
    //一个等号代表赋值,将右侧int常量,交给左侧long变量进行存储
    //int --》 long 符合了数据范围从小到大的要求
    //这一行代码发生了自动类型转换
    long num1 = 100;
    System.out.println(num1);//100

        //左边是double类型,右边默认是float类型,左右数据类型不一样
        //一个等号代表赋值,将右侧float常量,交给左侧doble变量进行存储
        //float --》 double 符合了数据范围从小到大的要求
        //这一行代码发生了自动类型转换
        double num2 = 2.5F;
        System.out.println(num2);
    
    
        //左边是flaot类型,右边默认是long类型,左右数据类型不一样
        //一个等号代表赋值,将右侧long常量,交给左侧float变量进行存储
        //long --》 float 符合了数据范围从小到大的要求
        //这一行代码发生了自动类型转换
        float num3 = 100L;
        System.out.println(num3);
    
        //强制类型转换
    
        //等号左边是int类型,右边是long类型,不一样
        //long--》 int数据范围不是从小到大
        //不能发生自动转换
        //100L前加上(int)来强制类型转换
        int num = (int)100L;
        System.out.println(num);//100
    
        //注意事项
    
        //long强制转换为int类型
        int num10 = (int) 6000000000L;
        System.out.println(num10);//1705032704 发生数据溢出
    
        //double-->int 强制类型转换
        int num11 = (int) 3.5;
        System.out.println(num11);//3 发生了进度损失
    
        char zifu1 = 'A';//这是一个字符型变量,赋值为A
        System.out.println(zifu1 + 1);//66,也就是说大写字母A被当做65来处理了,
        //计算机的底层是用一个数字(二进制)来代表一个字符,就是65
        //一旦char类型发生数学运算,那么字符就会被当成一个数字来使用,就是自动转换为int类型,被翻译成一个数字
    
        byte num14 = 40;
        byte num15 = 50;
    
        //byte + byte--->int + int ---->int
        int result1 = num14 + num15;
        System.out.println(result1);//90
    
        short num16 = 60;
        //byte+short---->int + int ---->int
        //在转换过程中需要保证最终结果没有超过short数值范围
        short result2 = (short)( num16 +num14);
        }
       }
    

    2.4运算符

    ####2.4.1 赋值运算符

    赋值运算符
    基本赋值运算符:就是一个等号“=”,代表将右侧的数据交给左侧的变量
    int a = 30;

    复合赋值运算符
    += a += 1 相当于 a = a + 1 其余同理
    -=
    /=
    %=

    注意事项
    1.只有变量才可以使用赋值运算符,常量不能进行赋值
    2,复合赋值运算符其中隐含了一个强制类型转换

    示例代码

    public class 赋值运算符 {
        public static void main(String[] args) {
            int a = 10;
            //a = 10 + 5 =15
            a += 5;
            System.out.println(a);//15
    
            byte num = 30;
            //num = num + 5
            //num = byte+int
            //num = int + int
            //num = int
            //num = (byte)int
            num += 5;
        }
    }
    
    

    结果展示

    15
    
    
    Process finished with exit code 0
    
    

    2.4.1 比较运算符

    == 等于【两个等号才是相等,一个等号是赋值】
    “<” 小于

    “>” 大于

    "<= " 小于等于
    "= " 大于等于
    "!= " 不等于

    2.4.2自增自减运算符

    自增运算符:++
    自荐运算符:–

    基本含义:让一个变量涨一个数字1,或者让一个变量讲一个数字1
    使用格式:写在变量名称之前和之后,例如:++num,或者num++

    使用方法:
    1.单独使用;不和其他任何操作混合自己独立成为一个步骤
    2.混合使用:和其他操作混合,例如与赋值混合,或与打印操作混合
    A。如果是【前++】,那么变量马上+1,然后再拿结果计算
    B。如果是【后++】,那么先用原来了数值运算之后在+1
    注意事项:
    只有变量才可以使用自增自减运算符,常量不可以

    示例代码

    public class 自增自减运算符 {
        public static void main(String[] args) {
            int num1 = 10;
            System.out.println(num1);//10
            ++num1;//单独使用,前++
            System.out.println(num1);//11
            num1++;//单独使用。后++
            System.out.println(num1);//12
    
            //--------------
            //混合使用
            int num2 = 20;
            //前++,立马加1,在打印
            System.out.println(++num2);//21
            System.out.println(num2);//21
    
            int num3 = 30;
            //后++,先打印,在加1
            System.out.println(num3++);//30
            System.out.println(num3);//31
    
            //和赋值操作混合
            int num4 = 40;
            //前--,先减1,在赋值
            int result1 = --num4;
            System.out.println(result1);//39
            System.out.println(num4);//39
    
            //后--,先赋值,在减1
            int num5 = 50;
            int result2 = num5--;
            System.out.println(result2);//50
            System.out.println(num5);//49
    
            int x = 10;
            int y = 20;
            int result3 = ++x + y--;
            System.out.println(result3);//31
            System.out.println(x);//11
            System.out.println(y);//19
    
    
    
        }
    }
    
    

    结果展示

    10
    11
    12
    21
    21
    30
    31
    39
    39
    50
    49
    31
    11
    19
    
    Process finished with exit code 0
    
    
    

    2.4.4逻辑运算符

    与 (并且) && 全en都是true 才是true 否则是false
    或 (或者) || 有一个是true就是true 全都是false 才是false
    非 (去反) ! 本来是false变成true 本来是true 变成false

    && 和 || 具有短路效果,如果根据左边已经可以判断出最终结果,那么不再执行右边的代码
    注意事项:
    1,逻辑运算符只能用一个布尔值
    2与,或需要左右各自有一个布尔值,但是去反只要有唯一的一个布尔值即可

    示例代码

    public class 逻辑运算符 {
        public static void main(String[] args) {
            System.out.println(true && false);
            System.out.println(true && true);
            System.out.println(true || true);
            System.out.println(true || false);
            System.out.println(!true);
            System.out.println(!false);
            int a =10;
            int b = 10;
            if(a > 10 && b++ > 10){
    
            }
            System.out.println(a);
            System.out.println(b);
        }
    }
    

    结果展示

    false
    true
    true
    true
    false
    true
    10
    10
    
    Process finished with exit code 0
    

    一元运算符:只需要一个数据就可以进行操作运算符,例如,去反!,自增++,自减–
    二元运算符:需要两个数据才可以进行操作的运算符。例如:加法+,赋值=
    三元运算符:需要三个数据才可以进行操作。

    格式:
    数据类型 变量名称 = 条件判断 ? 表达式A:表达式B;

    流程:
    首先判断条件是否成立:
    如果成立为true,那么将表达式A的值赋值给变量
    如果不成立为false,那么将表达式b的值赋值给变量

    注意事项:
    1.必须同时保证表达式A和表达式B都符合左侧数据类型的要求
    2.三元运算符它的结果必须被使用

    示例代码

    /*
    一元运算符:只需要一个数据就可以进行操作运算符,例如,去反!,自增++,自减--
    二元运算符:需要两个数据才可以进行操作的运算符。例如:加法+,赋值=
    三元运算符:需要三个数据才可以进行操作。
    
    格式:
    数据类型 变量名称 = 条件判断 ? 表达式A:表达式B;
    
    流程:
    首先判断条件是否成立:
        如果成立为true,那么将表达式A的值赋值给变量
        如果不成立为false,那么将表达式b的值赋值给变量
    
    注意事项:
        1.必须同时保证表达式A和表达式B都符合左侧数据类型的要求
        2.三元运算符它的结果必须被使用
     */
    
    public class 三元运算符 {
        public static void main(String[] args) {
            int a = 10;
            int b = 20;
    
            //数据类型 变量名称 = 条件判断 ? 表达式A:表达式B;
            //判断a > b是否成立,成立则将A的值赋值给max,不成立,则将b的值赋值给变量max
            int max = a > b ? a : b;  //最大值的变量
            System.out.println(max);  //20
    
           // int result = 3 > 4 ? 2.5 : 10; //错误写法,其中一个结果不满足变量的是数据类型
    
           // a > b ? a :b'结果没有被使用
        }
    }
    
    

    第三章流程控制

    编译器的优化

    对于byte、short、char三中数据类型来说,如果右侧的赋值数据没有超过范围,那么javac编译器将自动隐含的为我们补上(byte),(short),(char)

    1. 如果没有超过左侧的数据类型的数范围,那么编译器不上强转
    2. 如果超过了左侧的数据类型的数据范围,那么编译器直接报错
    byte a = 30;//编译器自动在30加上(byte)
    byte b = 128;//超过byte数据范围,直接报错
    

    再给变量进行复制的时候,如果右侧的表达式当中全部是常量,没有任何变量,那么编译器javac会将直接将若干个常量表达式的结果计算。

    short result = 5 = 8;//等于右边全是常量,没有任何变量参与运算,编译之后得到的。class文件中相当于直接就是short result = 13;右侧的常量结果数值没有超过左侧的范围,所以正确
    这就是编译器的常量优化
    但是注意,一旦表达式中有变量参与,那么就不进行有这种优化了
    

    3.1流程控制

    按照从上到下循序执行语句

    3.2if语句

    if(布尔表达式){

    ​ 语句体;

    }

    执行流程图

    if语句格式1

    执行流程说明

    首先判断关系表达式看其结果是true还是false
    如果是true就执行语句体
    如果是false就不执行语句体

    if(布尔表达式){

    ​ 语句体;

    } else {

    ​ 语句体;

    }

    执行流程

    执行流程图

    if语句格式2

    执行流程说明

    首先判断关系表达式看其结果是true还是false
    如果是true就执行语句体1
    如果是false就执行语句体2

    if(布尔表达式){

    ​ 语句体;

    } else if(布尔表达式){

    ​ 语句体;

    }…

    执行流程图

    if语句格式3

    执行流程说明

    首先判断关系表达式1看其结果是true还是false
    如果是true就执行语句体1
    如果是false就继续判断关系表达式2看其结果是true还是false
    如果是true就执行语句体2
    如果是false就继续判断关系表达式…看其结果是true还是false

    如果没有任何关系表达式为true,就执行语句体n+1

    3.3while语句

    while(布尔表达式)({

    ​ 语句体

    }

    只要布尔表达式为 true,循环就会一直执行下去。

    do…while循环

    do{

    ​ 语句体

    }while(布尔表达式);

    1. 对于 while 语句而言,如果不满足条件,则不能进入循环。但有时候我们需要即使不满足条件,也至少执行一次。
    2. do…while 循环和 while 循环相似,不同的是,do…while 循环至少会执行一次。
    3. 布尔表达式在循环体的后面,所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为 true,则语句块一直执行,直到布尔表达式的值为 false。

    3.4for语句

    for(初始化语句;布尔表达式;步进语句){

    ​ 语句体

    }

    注意事项

    • 最先执行初始化步骤。可以声明一种类型,但可初始化一个或多个循环控制变量,也可以是空语句。
    • 然后,检测布尔表达式的值。如果为 true,循环体被执行。如果为false,循环终止,开始执行循环体后面的语句。
    • 执行一次循环后,更新循环控制变量。
    • 再次检测布尔表达式。循环执行上面的过程。
    • 步进语句在每次循环的最后执行

    3.5swich语句

    swich(表达式){

    case 常量值:

    ​ 语句体1:

    break;

    case 常量值:

    ​ 语句体2:

    break;

    default:

    ​ 语句体n+1;

    ​ break;

    }

    执行流程说明

    首先计算出表达式的值
    其次,和case依次比较,一旦有对应的值,就会执行相应的语句,在执行的过程中,遇到break就会结束。
    最后,如果所有的case都和表达式的值不匹配,就会执行default语句体部分,然后程序结束掉。

    执行流程图

    img

    注意事项

    1、swich(表达式)中表达式的返回值必须是以下几种类型之一:
      byte,short,char,int,枚举(jdk1.5),String字符串(jdk1.7)

    2、case子句中的值必须是常量,且所有case子句中的值应是不同的;

    3、default子句是可任选的,当没有匹配的case时,执行default;

    4、break语句用来在执行完一个case分支后使程序跳出swich语句块;如果没有break程序会顺序执行到swich结尾;

    5、 default语句的break可以省略,一般建议不要省略。

    if分支结构和switch分支结构区别

    if和swich语句很想,如果判断的具体数值不多,而且复合byte、short、int、char这四种类型。建议使用swich语句,因为效率稍高;

    其他情况:对区间进行判断,对结果为boolean类型进行判断,使用if,if的使用范围比较广泛。

    3.6braek,continue

    break,continue都是再循环中使用的关键字

    作用:

    break:结束本次循环或着说是跳出本次循环

    continue:结束当前循环,进行下一轮循环

    第四章数组

    4.1数组的定义

    数组是在程序设计中,为了处理方便, 把具有相同类型的若干变量按有序的形式组织起来的一种形式,这些按序排列的同类数据元素的集合称为数组。 组成数组的各个变量称为数组的分量,也称为数组的元素,有时也称为下标变量。

    在Java中数组只能存储相同类型的便利,而且数组的长度一旦确定就不可改变。

    数据的特点
    1.数组是一种引用数据类型
    2.数据当中的多个数据,他们的类型必须统一
    3.数的长度在程序运行期间不可改变

    4.2数组的初始化

    数组的初始化:在内存当中创建一个数组,并且向其中一个赋予一些默认值

    两种常见的初始化方式
    1,动态初始化(指定长度)
    2.静态初始化(指定内容)

    动态初始化(指定长度),在创建数组的时候,直接指定数组当中的元数个数
    静态初始化(指定内容),在创建数组的时候,不指定数据的长度,而是直接指定数组当中的元素内容

    4.2.1动态初始化

    动态初始化数组格式
    数据类型【】 数组名称 = new 数据类型【数组长度】;

    解析含义:
    左侧的数据类型,就是数组当中保存的数据,全部是统一的数据类型
    左侧的中括号,代表他是一个数组
    左侧的数据名称,给数组去一个名字
    右侧的new 代表创建一个数组的动作
    右侧的数据类型,必须和左右的数据类型相一致
    右侧的中括号的长度,也就是数据当中,可以保存多少个数据 是一个int 数字

    示例代码

    public class Demo01Array {
        public static void main(String[] args) {
            //创建一个数组,里面可以存放300int类型的数据
            //
            int [] arrayA = new int[300];
            //创建一个数组,里面可以存放10double类型的数据
            double [] arrayB = new double[10];
            //创建一个数组,里面可以存放5String类型的数据
            String[] arrayC = new String[5];
        }
    }
    

    使用动态初始化数组的时候,其中元素将会自动拥有一个默认值
    如果是整数类型,那么默认为0
    如果是浮点类型,那么默认为0.0
    如果是字符型,默认为‘、\u0000’
    如果是布尔值,默认false
    如果是引用类型,默认null

    注意事项:
    静态舒适化也有默认值的过程,只是系统马上将默认值改成了大括号里面的内容
    直接打印数组名称,得到的是数组对应的内存地址哈希值,十六进制

    4.2.2静态初始化

    静态初始化基本格式
    数据类型【】 数组名称 = new 数据类型【】{元素1,元素2,…}

    注意事项
    静态舒适化编译器可以直接算出数组长度,所以不需要指定长度

    示例代码

    public class Demo02Arrag {
        public static void main(String[] args) {
            //直接创建一个数组,里面装的是数字,具体是4,5,6
            int [] arrayA = new int[]{4,5,6};
    
            String[] arrayB = new String[]{"hello","world","hi"};
        }
    }
    

    注意事项:
    1.静态初始化没有指定数据长度,但是仍会自动推算出得到的长度
    2.静态初始化的标准格式可以拆分为两个步骤
    3.动态初始化也可以拆分为两个步骤
    4.静态初始化省略格式不能拆分为两个步骤

    4.3数组在内存内存中的变化

    4.3.1java内存

    java内存

    1. 栈(Stack):存放的都是方法中的局部变量。局部变量:方法的参数,或者说方法大括号里面的变量。作用域:一旦超出作用域,立即从栈内存当中消失.方法执行一定在栈当中
    2. 堆(Heap):凡是new出来的东西都在堆当中。堆内存里面的东西都有一个地址值:十六进制。堆内存里面的数据,都有默认值。整数默认0;浮点数默认0.0;字符默认‘\u0000’;布尔默认false,引用默认null
    3. 方法区(Mthod Ares):存储.class相关信息,包含方法的信息。
    4. 本地方法栈(Native Method Stack):
    5. 寄存器(pc Register):与cpu相关

    4.3.2数据在内存中的生命过程

    示例代码

    public class Demo01ArrayOne {
    
    
        public static void main(String[] args) {
            int[] array = new int[3]; //动态初始化
            System.out.println(array);//地址值
            System.out.println(array[0]);//0
            System.out.println(array[1]);//0
            System.out.println(array[2]);//0
    
            //改变数组当中的内容
            array[1] = 20;
            array[2] = 10;
            System.out.println(array);//地址值
            System.out.println(array[0]);//0
            System.out.println(array[1]);//20
            System.out.println(array[2]);//10
        }
    }
    

    结果展示

    [I@74a14482
    0
    0
    0
    [I@74a14482
    0
    20
    10
    

    内存分析图

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ByCTQjje-1596768223418)(/media/xys/9EE82615E825EC69/linux_xys/2020java%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/8.5/java%E5%86%85%E5%AD%98.png)]

    说明:程序执行后,java虚拟机先找到mian方法,然后将main方法存入方法区。接着程序继续从上到下执行初始化数组语句,int [] array 变量进入栈,后面的new int [3]进入堆并在对中开辟一个长度为3地址空间用来存放数据,并且将期地址值赋值给栈中的array变量,而且对中数组空间开辟的同时每个空间都被java虚拟机自动赋值一个默认值0,所以写下来执行输出语句的时候,输出的都是0;当给数组中的元素赋值是,先通过array变量找到(数组变量存储的其实是数组在堆内存中的地址),对中数组的地址,然后再通过索引值找到具体的数组中的那个具体的地址。之后将该地值的值(默认值或其他值)改为你想要赋予的值

    4.4数组常见的异常

    4.4.1越界异常

    数组的索引编号从零开始,

    如果访问数组元素的时候,索引编号并不存在,那么会发生
    数据索引越界异常
    ArrayIndexOutOfBoundsException

    原因索引编号写错了
    解决,修改成为存在的正确编号

    示例代码

    public class Demo01ArratIndex {
    
        public static void main(String[] args) {
            int [] array = {12,15,16};
    
            System.out.println(array[0]);//12
            System.out.println(array[1]);//15
            System.out.println(array[2]);//16
            System.out.println(array[3]);//数据索引越界异常
        }
    }
    

    结果展示

    12
    15
    16
    Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
    	at demo03数组越界异常.Demo01ArratIndex.main(Demo01ArratIndex.java:21)
    
    Process finished with exit code 1
    
    

    4.4.2空指针异常

    所有的引用类型变量,都可以赋值为一个null
    代表什么都没有1

    数组必须进行new初始化才可使用其中的元素
    如果只是赋值一个null,没有进行new创建
    那么会出现NullPointerException
    空指针异常

    原因:忘了new
    解决:补上new

    示例代码

    public class Demo02ArrayNull {
    
        public static void main(String[] args) {
            int [] array = null;
            //array = new ;
    
            System.out.println(array[0]);
        }
    }
    

    结果展示

    Exception in thread "main" java.lang.NullPointerException
    	at demo03数组越界异常.Demo02ArrayNull.main(Demo02ArrayNull.java:20)
    
    Process finished with exit code 1
    

    4.5数组常见的操作

    4.5.1数组的遍历

    遍历数组,说的就是对数组当中每一个元素进行逐一,挨个处理,默认梳理方式就是打印出来

    ublic class Demo04Array {
    
        public static void main(String[] args) {
            int [] array = {15,25,35,45};
    
            //原始方式
            System.out.println(array[0]);
            System.out.println(array[1]);
            System.out.println(array[2]);
            System.out.println(array[3]);
            System.out.println("==================");
            //使用循环
            for (int i = 0; i < array.length;i++){
                System.out.println(array[i]);
            }
        }
    }
    

    结果展示

    15
    25
    35
    45
    ==================
    15
    25
    35
    45
    
    Process finished with exit code 0
    

    4.5.2获取数组的长度,最大值

    如何获取数组的长度 ,格式
    数组名称.length()

    这将会得到一个int数字,代表数组的长度

    数组一旦创建,程序运行期间长度不可改变

    public class Demo03ArrgyLength {
    
        public static void main(String[] args) {
            int [] arryA = new int[3];
    
            int [] arryB = {10,20,30};
            System.out.println(arryB.length);
            System.out.println("==================");
    
            int [] arrayC = new int[3];
            System.out.println(arrayC.length);
            arrayC = new int[5];//arrayc重新new了一块内存
            System.out.println(arrayC.length);
        }
    }
    

    获取最大值

    public class Demo04ArrayMax {
    
        public static void main(String[] args) {
            int [] array = {5,15,25,20,1000};
    
            int max = array[0];
    
            for (int i = 1;i < array.length;i++){
                if (max < array[i]){
                    max = array[i];
                }
            }
            System.out.println(max);
        }
    }
    

    4.5.3将数组元素循序颠倒

    public class Demo07ArrayReverse {

    public static void main(String[] args) {
        int [] array = {1,2,3,4,5};
        int temp = 0;
        for (int i = 0; i < array.length/2 ;i ++){
            temp = array[i];
            array[i] = array[array.length-i-1];
            array[array.length-i-1] = temp;
        }
    
       printArray(array);
        int [] a = {10,20,30,40,50};
        printArray(a);
    
    }
    /*
    数组可以作为方法的参数
    当调用方法的时候,传递进去的其实就是数组的地址值
     */
    /*
    三要素
    返回值类型,只是进行打印不用返回,void
    方法名称:printArray
    参数列表:必须给我数组,我才能打印其中的元素
     */
    public static void printArray(int [] array){
        array[0] = 1000;
    
        for (int i = 0; i < array.length;i++){
            System.out.println(array[i]);
    
        }
    
    }
    

    }

    4.5.4数组作为参数传递

    一个方法可以有多个参数,但是只能有一个返回值,不能有多个返回值i
    如果希望一个方法返回产生的多个数据,怎么办
    解决方案:使用一个数组作为返回值类型即可

    数组作为方法的参数,传进去的是数组的地址值
    数组作为返回值时,返回的也是地址值

    public class Demo08ArrayRetuen {
    
        public static void main(String[] args) {
            int [] result = calculate(10 ,20,30);
    
            System.out.println(result[0]);
            System.out.println(result[1]);
            System.out.println(result);
        }
    
        public static int[] calculate(int a,int b,int c){
            int sum = a + b + c;
            int avg = sum / 3;
    
            int []array = {sum,avg};
            System.out.println(array);
            return array;
        }
    
    
    }
    

    第五章方法

    5.1方法的定义

    方法其实就是若干语句的功能集合。

    方法其实就是一个工厂
    例如:蒙牛工厂 原料,奶牛,饲料,水
    产出物 奶制品。
    参数(原料),就是方法进去的数值
    返回值(出产物),就是冲方法中出来的数据

    定义方法的完整格式
    修饰符 返回值类型 方法名称 (参数类型 参数名称,。。。){
    方法体;
    return 返回值;

    }

    函数设计三要素:

    (1)函数名:见名思议,也就是根据功能定名字,按照驼峰写法xxxYyyZzz

    (2)参数:调用者传递过来的数据的接收方式,参数可以有多个,也可以没有

    (3)返回值类型[void]:返回值类型就是函数执行后要给调用者的数据类型,如果指定了数据类型就必须要有return,如果是void就可以不指定return。

    return结果:就要看是否有返回值,如果有返回值的类型,就必须要有一个return被执行,return后面的代码不被执行

    5.1.1方法各个参数讲解

    修饰符,现阶段的固定写法 :public static

    返回值类型,也就是方法最终产生数据的结果是什么类型

    方法名称,方法的名字,命名规则和变量一样,小驼峰

    参数类型,进入方法的数据是什么类型

    参数名称,进入方法的数据对应的变量名称

    ps;参数如果有多个,使用逗号隔开

    方法体,方法需要做的事情,若干代码

    return,连个作用,第一停止当前方法,跌入将后面的值,返回给调用出

    返回值,方法执行后最终产生的数据结构,

    注意:return后面的返回值必须和方法前面的返回值类型保持一致

    定义一个两个int数字相加,三要素
    返回值类型,int
    方法名称,sum
    参数类别,int a, int b

    方法调用的三种格式
    1,单独调用 ,方法名(参数)
    2,打印调用 ,System。out。print(方法名(参数));
    3,赋值调研 ,数据类型 变量名称 = 方法名(参数)

    注意事项
    1.方法先后定义书顺序无所谓
    2.方法必须挨个定义,不能在方法内部定义
    3.方法不会自动执行,必须调用之后才会执行

    示例代码

    public class Demo02MethodDefine {
        public static void main(String[] args) {
           //单独调用
           sum(10,20);
           //打印调用
           System.out.println(sum(1,2));
           //赋值调用
           int sum = sum(10,20);
        }
    
        public static int sum(int a, int b){
            return a + b;
        }
    
    
    }
    

    5.2方法的参数

    有参数:小括号的内容,当一个方法需要一些数据条件才能完成任务的时候就是有参数
    例如两个数字相加必须知道两个数字各是多少,才能相加
    无参数:小口号中为空,一个方法不需要任何条件,自己就能独立完成任务是,就是无参数
    例如,打印固定的格式。10次Helloworld

    示例代码

    public class Demo03MethonParam {
        public static void main(String[] args) {
    
    
        }
    
        //两个数字相乘,
        public static void metod1(int a, int b){
            int resuly = a * b;
            System.out.println("result = "+ resuly);
        }
        //打印一句话
        public  static void mothod02(){
            System.out.println("你好");
        }
    }
    

    5.3方法的返回值

    一个方法可以有返回值,也可以没有,视情况而定

    没有返回值的方法用void修饰,return语句可以省去,不省去一定要写成“return ;”的形式。而且return语句之后的语句不会执行

    有返回值的方法,return后面返回的数据一定要与方法前面定义的参数类型一致。

      /*
    
    题目要求,定义一个方法,用来求出两个数字之和
    
    注意事项:
    
        对于有返回值的方法,
    
     */
    
    public class Demo04MethodReturn {
    
        public static void main(String[] args) {
    
      //我是mian方法,我来调用你
        //我调用你,你来帮我算,
        int num = getSum(10,20);
        System.out.println("返回值:"+num);
    
        printSum(10,20);
    }
    
    //我是一个方法,负责两个数字相加
    //我有返回值int,谁调用我,我就把计算结果告诉谁
    
    public static int getSum(int a, int b){
        int result = a + b;
        return result;
    }
    
    public static void printSum(int a, int b){
        int result = a + b;
        System.out.println(result);
    }
    }
    

    5.4方法的重载

    对于功能类似的方法来说,因为参数类表不一样,却需要记住多个调用方法

    方法的重载(Overload) ,多个方法的名称一样,但是参数类表却不一下
    好处,只要要一个方法名称,就可以实现多个不同的功能,提高代码的可读性和节省命名的词

    方法重载与下列因素相关
    1,参数个数不同
    2.参数类型不同
    3.参数的多类型顺序不同

    方法重载与下列因素无关
    1,参数名称无关
    2,与方法的返回值类型无关
    3,与参数返回值类型不同

    public class Demo01MethodOverload {
    
        public static void main(String[] args) {
    
            System.out.println(sun(1,2));
    
            System.out.println(sun(1,2,3));
    
            System.out.println(sun(1,2,3,4));
    
        }
    
        public static int sun(int a,int b){
    
            return a + b;
    
        }
    
        public static int sun(double a,int b){
    
            return (int)(a + b);
    
        }
    
        public static int sun(double a,double b){
    
            return (int)(a + b);
    
        }
    
    public static int sun(int a,int b,int c){
        return a + b + c;
    }
    
    public static int sun(int a,int b,int c ,int d){
        return a + b + c + d;
    }
    }
    

    第六章面向对象

    面向对象思想是一种更符合我们思考习惯的思想,它可以将复杂的事情简单化,并将偶们从执行者变成了指挥者

    面向对象的语言中,包含了三大基本特征,即封装,继承和多态

    面向对象:强调对象

    面向过程:强调步骤

    举例

    洗衣服:

    面向过程:把衣服脱下来–>找一个盆–>放点洗衣粉–>加点水–>浸泡10分钟起来

    面向对象:把衣服脱下来–>打开全自动洗衣机–>扔衣服–>按钮–>晾

    6,1类与对象的关系

    环境四周,你会发现很多对象,比如说桌子,椅子,同学,老师等

    6.1.1什么是类

    类:是一组相关属性和行为的集合,可以看成是一类事物的模板,使用事物的属性特征和行为特征来描述该类事物

    举例:小猫

    ​ 属性:名字,体重,年龄,颜色。

    ​ 行为:走,跑,叫。

    6.1.2什么是对象

    对象:是一类事物具体的体现。对象是类的一个实例,必然具备该类事物的属性和行为

    现实中,一类事物的一个实例:一只小猫

    举例:一只小猫

    6.2类的定义

    6.2.1事物于类的对比

    现实世界的一类事物:

    ​ 属性:事物的状态信息

    ​ 行为:事物能够做什么

    java中用class来描述事物也是这样的:

    ​ 成员变量:对应事物的属性

    ​ 成员方法:对应事物的行为

    类是对一类事物的描述,是抽象的。

    对象是一类事物的实例,是具体的。

    类是对象的模板,对象是类的实体。

    6.2.2类的定义格式

    public class ClassName {
        //成员变量
        //成员方法
        
    }
    

    例如定义一个学生类:

    定义一个类,用来模拟学生事物。其中就有两个组成部分

    属性(是什么)。
    姓名
    年龄
    行为(能做什么),
    吃饭
    学习
    睡觉

    对应到java的类当中

    成员变量(属性):
    String name;//姓名
    Strng age;//年龄
    成员方法(行为):
    public void eat(){} //吃饭
    public void sheep(){} //睡觉
    public void study(){} //学习

    注意事项:
    1.成员变量是定义在方法外边的
    2.成员方法不要写static关键字

    示例代码

    public class Student {
        //成员变量
        String name; //姓名
        int age; //年龄
        //成员方法
        public void eat(){
            System.out.println("吃饭!");
        }  //吃饭
        public void sheep(){
            System.out.println("睡觉啊!");
        }  //睡觉
        public void study(){
            System.out.println("学习!");
        }  //学习
    
    }
    

    6.2.3类的使用方式

    通常情况下,一个类并不能直接使用,需要根据类创建一个对象,才能使用

    1.导包,也就是指出需要使用的类在什么位置
    import 包名称。类名称
    import demo01.Student
    对于和当前类从属于同一个包,可以省略不导入

    2,创建,格式
    类名称 对象名 = new 类名称();
    Student stu = new Student();

    使用,分为两种情况
    使用成员变量:对象名.成员变量名
    使用成员方法:对象名.成员方法名

    示例代码

    public class Demo02Student {
        public static void main(String[] args) {
            //1.导包
            //在同一个包中,可以省略
    
            //2。创建,格式
            //类名称 对象名 = new 类名称();
            //Student stu = new Student();
            Student stu = new Student();
    
            //使用其中的成员变量,成员方法
            //对象名.成员变量名
    
            System.out.println(stu.age);
            System.out.println(stu.name);
    
            //改变对象当中的成员变量的数据值
            //将右侧的数据值赋值给成员变量
            stu.name = "赵丽颖";
            stu.age = 18;
            System.out.println(stu.name);
            System.out.println(stu.age);
            System.out.println("==============");
    
            //使用成员方法
            //对象名.成员方法名
            stu.eat();
            stu.sheep();
            stu.study();
    
    
        }
    }
    

    6.2.4成员变量默认值

    在类中的变量(成员变量),何在方法中的变量(局部变量)是不一样的。

    成员变量在初始化时使用有一个默认值的。而局部变量定制之后没有默认值,而且必须初始化之后才可以使用

    数据类型 默认值基本类型

    整数(byte,short,int,long) 0

    浮点数(float,double) 0.0

    字符(char) '\u0000’布尔(

    boolean) false

    引用类型 数组,类,接口 null

    6.3对象内存图

    对象在内存中的存在方式是与变量不一样的,下面我们通过一段代码的运行来讲解,对象在内存中是如何产生,消失,存储的。

    示例代码

    public class Demo01PhoneOne {
        //根据Phone类,创建一个名为one的对象
        //格式:类名 对象名 = new 类名称();
        public static void main(String[] args) {
            Phone one = new Phone();
    
            System.out.println(one.brand);//null
            System.out.println(one.color);//null
            System.out.println(one.price);//0.0
            System.out.println("==============");
    
            one.brand = "苹果";
            one.price = 8320.5;
            one.color = "红色";
            System.out.println(one.brand);//苹果
            System.out.println(one.color);//8320.5
            System.out.println(one.price);//红色
            System.out.println("==============");
    
            one.cell("乔布斯");//给乔布斯打电话
            one.sendMessage();//群发消息
    
        }
    
    }
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nQCF0kkB-1596768223420)(/media/xys/9EE82615E825EC69/linux_xys/2020java%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/8.6/%E7%B1%BB%E5%86%85%E5%AD%98%E7%9A%84%E6%B4%BB%E5%8A%A8.png)]

    1. 程序开始,从main方法开始执行。mian方法进入方法区(方法区是存在类信息的地方)
    2. 接着执行 Phone one = new Phone();语句 。有new 一个Phone对象,先将Phone类存入方法区,
      1. 执行Phone类中的代码,在堆中开辟一块内存存放Phone类的信息
      2. 成员变量进入堆,并根据类型赋予一个默认值
      3. 成员方法进入堆,并且讲成员方法在方法区的地址存入堆中对应的内存
    3. 接着将phone在堆中的地址付给one
    4. 打印one.brand信息,根据one中的地址,直接找到堆中brand变量所在位置,并获取他的值,目前只有默认值,null,输出null
    5. 打印one.color信息,根据one中的地址,直接找到堆中coloe变量所在位置,并获取他的值,目前只有默认值,null,输出null
    6. 打印one.price信息,根据one中的地址,直接找到堆中price变量所在位置,并获取他的值,目前只有默认值,null,输出null
    7. 输出====================
    8. 执行one.brand = “苹果”;根据one中的地址,直接找到堆中brand变量所在位置,将苹果数据赋值给brand
    9. 执行one.price = 8320.5;根据one中的地址,直接找到堆中price变量所在位置,将8320.5数据赋值给price
    10. 执行one.color = “红色”;根据one中的地址,直接找到堆中color变量所在位置,将红色数据赋值给color
    11. 打印one.brand信息,根据one中的地址,直接找到堆中brand变量所在位置,并获取他的值,现在的值是苹果,打印苹果
    12. 打印one.color信息,根据one中的地址,直接找到堆中coloe变量所在位置,并获取他的值,现在的值是红色,打印红色
    13. 打印one.price信息,根据one中的地址,直接找到堆中price变量所在位置,并获取他的值,现在的值是8320.5,打印8320.5
    14. 执行one.cell(“乔布斯”);//给乔布斯打电话 语句。根据one中的地址,直接找到堆中cell方法的地址,再找到cell在方法区的真实内容
    15. cell方法进栈,执行cell方法中的内容,
    16. cell方法执行完毕后,cell方法出现
    17. 执行one.sendMessage();//群发消息; 根据one中的地址,直接找到堆中sendMessage方法的地址,再找到sendMessage在方法区的真实内容
    18. sendMessage进栈,执行sendMessage方法中的内容
    19. sendMessage执行完毕,sendMessage出栈
    20. main方法执行完毕,main方法出栈

    运行结果

    null
    null
    0.0
    ==============
    苹果
    红色
    8320.5
    ==============
    要和乔布斯打电话
    群发消息
    
    Process finished with exit code 0
    

    6.4成员变量和局部变量的区别

    局部变量和成员不变量

    1.定义位置不一样【重点】
    局部变量,在方法内部
    成员变量,在方法外部,直接写在内当中

    2.作用范围【重点【
    局部变量:只有方法当中才可以使用,出了方法就不能在呀
    成员变量:整个类全部可以使用

    3.默认值不一样【重点】
    局部变量,没有默认值如有想要使用必须先进行赋值
    成员变量,如果没有赋值,会有默认值,规则和数组一样

    4内存中的位置不一样【了解】
    局部变量,位于栈内存
    成员变量,位于堆内存

    5。生命周期不一样【了解】
    局部变量,睡这方法进栈而诞生,随着方法出栈而消失
    成员变量,随着对象的创建而诞生,随着对象被垃圾回收而消失

    第七章封装

    7.1概述

    面向对象编程语言是对客观世界的模拟,客观世界里成员变量都是隐藏在对象内部的,外界无法直接操作和修改。封装可以被认为是一个保护屏障,防止该类的代码和数据被其他类随意访问。要访问该类的数据,必须通过指定的方式。适当的封装可以让代码更容易理解与维护,也加强了代码的安全

    封装性在java当中的体现
    1.方法就是一种封装
    2.关键字private也是一种封装

    封装就是将一些细节信息隐藏起来,对于外界不可见

    7.2private关键字

    private的含义

    1. private是一个权限修饰符,代表最小权限。
    2. 可以修饰成员变量和成员方法。
    3. 被private修饰后的成员变量和成员方法,只在本类中才能访

    private使用格式

    private 数据类型 变量名
    
      private String name; //姓名
        private int age; //年龄
        private boolean male; // 是不是男的
    
    

    提供 getXxx 方法 / setXxx 方法,可以访问成员变量,代码如下:

    public void setMale(boolean male){
        this.male = male;
    }
    
    public boolean isMale(){
        return male;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(Strin
    g name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    

    ^: 对于基本类型Boolean,他的get方法要写成isXxx ,set方法不变

    7.3使用方法进行封装

    求最大值,只需要给方法一个整型数组,方法就会返回给你一个最大的值,并不需要知道方法是如何执行操作的。对于方法中的内容,外部不可见

    public class Demo02Method {
    
        public static void main(String[] args) {
            int array[] = {5,10,15,20};
            int max = getMax(array);
            System.out.println(max);
    
        }
    
        //给我一个数组,给你的最大值
        public static int getMax(int[] array){
            int max = array[0];
            for (int i = 1 ; i < array.length;i++){
                if (max < array[i]){
                    max = array[i];
                }
            }
            return max;
        }
    }
    

    7.4this关键字

    当方法的局部变量和类的成员变量重名的时候,根据就近原则,方法会使用方法中的局部变量
    如果想要方法中使用本类的重名成员变量,需要使用格式
    this.成员变量名

    “this在哪个类中,this就只代谁

    this代表所在类的当前对象的引用(地址值)即对象自己的

    public class Demo01Person {
    
        public static void main(String[] args) {
            Person person = new Person();
            //设置自己的名字
            person.name = "王健林";
            person.sayHello("王思聪");
        }
    }
    
    public class Person {
    
        String name; //
    
        public void sayHello
                (String name){
            System.out.println(name + "你好,我是" + this.name);
        }
    }
    

    7.5构造方法

    构造方法就是专门用来创建对象的方法,当我们通过关键字new来创建对象时,调用的就是构造方法

    格式:
    public 类名称(参数类型 参数名称){
    方法体
    }
    注意事项:
    1.构造方法的名称必须和所在类的类名称相同,大小写也必须相同
    2.构造方法不需要返回值类型,连void也不需要要
    3.构造方法不能return一个具体的返回值
    4.如果没有编写构造方法,那么编译器默认会赠送一个构造方法,没有参数,方法体什么也不做
    public Studeng(){}
    5.一旦编写了至少一个构造方法,那么编译器将不会生成默认构造方法
    6.构造方法也是可以重载的,方法名称相同,参数不同

    示例代码

    public class Demo02Student {
    
        public static void main(String[] args) {
            Student student = new Student();
            Student student1 = new Student("xys",20);
    
        }
    }
    
    public class Student {
        //成员变量
        private String name;
        private int age;
    
        //无参构造方法
        public  Student (){
            System.out.println("我是无参构造方法");
        }
        //有参参构造方法
        public Student(String name,int age){
            this.age = age;
            this.name = name;
            System.out.println("我是有参构造方法");
        }
    //get ,set方法
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    

    运行结果

    我是无参构造方法
    我是有参构造方法
    
    Process finished with exit code 0
    

    展开全文
  • /** * 返回指定年度的所有。List中包含的String[2]对象 * string[0]本周的开始日期,string[1]本周的结束日期。 * 日期的格式yyyy-MM-... * 每年的第,必须包含星期完整的七天。 * 例
     
    	/**
    	 * 返回指定年度的所有周。List中包含的是String[2]对象<br>
    	 * string[0]本周的开始日期,string[1]是本周的结束日期。<br>
    	 * 日期的格式为yyyy-MM-dd。<br>
    	 * 每年的第一个周,必须包含星期一且是完整的七天。<br>
    	 * 例如:2009年的第一个周开始日期为2009-01-05,结束日期为2009-01-11。 <br>
    	 * 星期一在哪一年,那么包含这个星期的周就是哪一年的周。<br>
    	 * 例如:2008-12-29是星期一,2009-01-04是星期日,哪么这个周就是2008年度的最后一个周。<br>
    	 * 
    	 * @param year 格式 yyyy  ,必须大于1900年度 小于9999年 
    	 * @return 
    	 */
    	public static List<String[]> getWeeksByYear(final int year){
    		if(year<1900 || year >9999){
    			throw new NullPointerException("年度必须大于等于1900年小于等于9999年");
    		}
    		//实现思路,首先计算当年有多少个周,然后找到每个周的开始日期和结束日期
    		
    //		Calendar calendar = new GregorianCalendar();
    //		// 在具有默认语言环境的默认时区内使用当前时间构造一个默认的 GregorianCalendar。
    //		calendar.setFirstDayOfWeek(Calendar.MONDAY); //设置每周的第一天为星期一
    //		calendar.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY); //每周从周一开始		
    //      上面两句代码配合,才能实现,每年度的第一个周,是包含第一个星期一的那个周。		
    //		calendar.setMinimalDaysInFirstWeek(7);  //设置每周最少为7天
    //		calendar.set(Calendar.YEAR, year); // 设置年度为指定的年
    
    //		//首先计算当年有多少个周,每年都至少有52个周,个别年度有53个周
    
    		int weeks = getWeekNumByYear(year);
    //		System.out.println(year+"共有"+weeks+"个周");
    		List<String[]> result = new ArrayList<String[]>(weeks);
    		for(int i=1;i<=weeks;i++){
    			String[] tempWeek = new String[2];
    			tempWeek[0] = getYearWeekFirstDay(year,i);
    			tempWeek[1] = getYearWeekEndDay (year,i);
    //或者使用下面的代码,不过发现效率更低			
    //			tempWeek[0] = getDateAdd(firstWeekDay,(i-1)*7+0);
    //			tempWeek[1] = getDateAdd(firstWeekDay,(i-1)*7+6);			
    			result.add(tempWeek);
    //			System.out.println(i+"="+tempWeek[0]+"_"+tempWeek[1]);
    		}
    		return result;
    	}
    
    	/**
    	 * 计算指定年度共有多少个周。
    	 * @param year 格式 yyyy  ,必须大于1900年度 小于9999年 
    	 * @return 
    	 */
    	public static int getWeekNumByYear(final int year){
    		if(year<1900 || year >9999){
    			throw new NullPointerException("年度必须大于等于1900年小于等于9999年");
    		}
    		int result = 52;//每年至少有52个周 ,最多有53个周。
    		String date = getYearWeekFirstDay(year,53);
    		if(date.substring(0, 4).equals(year+"")){ //判断年度是否相符,如果相符说明有53个周。
    			result = 53;
    		}
    		return result;
    	}
    	
    
        /**
         * 计算某年某周的开始日期
         * @param yearNum 格式 yyyy  ,必须大于1900年度 小于9999年 
         * @param weekNum 1到52或者53
         * @return 日期,格式为yyyy-MM-dd
         */
        public static String getYearWeekFirstDay(int yearNum,int weekNum)  {
    		if(yearNum<1900 || yearNum >9999){
    			throw new NullPointerException("年度必须大于等于1900年小于等于9999年");
    		}
    	     Calendar cal = Calendar.getInstance();
    	     cal.setFirstDayOfWeek(Calendar.MONDAY); //设置每周的第一天为星期一
    	     cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);//每周从周一开始
    //	     上面两句代码配合,才能实现,每年度的第一个周,是包含第一个星期一的那个周。
    	     cal.setMinimalDaysInFirstWeek(7);  //设置每周最少为7天     
    	     cal.set(Calendar.YEAR, yearNum);
    	     cal.set(Calendar.WEEK_OF_YEAR, weekNum);
    	    
    	     //分别取得当前日期的年、月、日
    	     return getFormatDate(cal.getTime());
        }
    
        /**
         * 计算某年某周的结束日期
         * @param yearNum 格式 yyyy  ,必须大于1900年度 小于9999年 
         * @param weekNum 1到52或者53
         * @return 日期,格式为yyyy-MM-dd
         */
        public static String getYearWeekEndDay(int yearNum,int weekNum)  {
    		if(yearNum<1900 || yearNum >9999){
    			throw new NullPointerException("年度必须大于等于1900年小于等于9999年");
    		}    	
    	     Calendar cal = Calendar.getInstance();
    	     cal.setFirstDayOfWeek(Calendar.MONDAY); //设置每周的第一天为星期一
    	     cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);//每周从周一开始
    //	     上面两句代码配合,才能实现,每年度的第一个周,是包含第一个星期一的那个周。	     
    	     cal.setMinimalDaysInFirstWeek(7);  //设置每周最少为7天         
    	     cal.set(Calendar.YEAR, yearNum);
    	     cal.set(Calendar.WEEK_OF_YEAR, weekNum);
    	     
    	     return getFormatDate(cal.getTime());
        }

    展开全文
  • 七周七语言:Io Day 2

    2019-10-04 13:17:38
    今天做这些花了几乎个下午……主要原因要查iolanguage.org上的文档,而且那个文档不知道为什么不能搜索 :( 这“一天”的内容,关于Io的控制语句、文件IO、错误处理、列表都有涉及。 个人比较喜欢的Io的控制...

    第二天

    今天做这些花了几乎一个下午……主要原因是要查iolanguage.org上的文档,而且那个文档不知道为什么不能搜索 :(
    这“一天”的内容,关于Io的控制语句、文件IO、错误处理、列表都有涉及。

    个人比较喜欢的是Io的控制语句,写在一个()里,没有else,条件、语句都用一个comma隔开的感觉很不错;
    有点不理解的是关于Io的消息机制和反射,虽然书上的例子举的比较清楚,可是还是觉得将其称之为“反射”比较不习惯;再者,关于原型和对象的关系,感觉就是类的继承(?!)……好吧,学习一门语言的过程还是挺欢乐的~

    • 计算fibonacci数列

      #循环的方法
      array := List clone
      array := list(1, 1)
      #change the value of a to cal fib(a)
      a ::= 10
      for(i, 2, a, 1, array append(array at(i-1) + array at(i-2)) println)
      #Output
      list(1, 1, 2)
      list(1, 1, 2, 3)
      list(1, 1, 2, 3, 5)
      list(1, 1, 2, 3, 5, 8)
      list(1, 1, 2, 3, 5, 8, 13)
      list(1, 1, 2, 3, 5, 8, 13, 21)
      list(1, 1, 2, 3, 5, 8, 13, 21, 34)
      list(1, 1, 2, 3, 5, 8, 13, 21, 34, 55)
      list(1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89)
      ==> list(1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89)
      #递归的方法
      fib := method( n,
              if(((n == 1) or (n == 2)),return(1))
              #loop until n == i
              reFib := method( n, i, n1, n2,
                  if((n == i),return(n1 + n2))
                      return(reFib(n,(i+1),n2,(n2 + n1)))
              )
              #The first condition of reFib
              return(reFib( n, 3, 1, 1))
      )
      fib(1) println
      fib(2) println
      fib(10) println
      #Output
      1
      1
      55
              
    • 在分母为0的情况下,如何让运算符返回0?

        Number setSlot("division", Number getSlot("/"))
        
        Number setSlot("/",
           method( denominator,
                 if((denominator == 0),return (0))
                 return(self division( denominator))
              )
        )
        
        (1 / 0) println
        (2 / 1) println
        #Output
        0
        2
              
    • 对二维数组进行求和

      #Define a 2D array
      2d_array := list(
      		 list(1, 2, 3),
      		 list(4, 5, 6),
      		 list(7, 8, 9)
      )
      sum := 0
      #Nested foreach statement
      2d_array foreach(r, r foreach(v, (sum = sum + v)))
      "The sum of this 2D array is: " print
      sum println
      #Output
      The sum of this 2D array is: 45
              
    • 对列表增加一个名为myAverage的槽,以计算列表中所有数字的平均值。如果列表没有数字会发生什么?

      List myAverage := method(
      	 sum := 0 
      	 self foreach(k, 
      	 	  if((k type != "Number"),
      		  		Exception raise("There is a NaN-value in the list, please check your list." ),
      		  sum =( sum + k))
      	)
      	return (sum/(self size))
      )
      
      list(1, 2, 3) myAverage println
      list(1, "a", 3) myAverage println
      #Output
      2
        Exception: There is a NaN-value in the list, please check your list.
        ---------
        Exception raise                      myAverage.io 5
        List myAverage                       myAverage.io 13
        CLI doFile                           Z_CLI.io 140
        CLI run                              IoState_runCLI() 1
              
    • 对二维列表写一个原型。该原型的dim(x, y)方法可为一个包含y个列表的列表分配内存,其中每个列表都有x个元素,set(x, y)方法可以设置列表中的值,get(x, y)方法可返回列表中的值。

      2DList := List clone
      #This method should be considered later
      2DList dim := method(x, y,
      	   if( (self proto type == "List"),
      	   	   return 2DList clone dim(x, y)
      	   )
      	   self setSize(x)
      	   for(i, 0, (x-1), 1,
      	   		  self atPut(i, (list() setSize(y)))
      	   )
      	   return self
      )
      #set the value at(x) at(y)
      2DList set := method(x, y, value,
      	   self at(x) atPut(y, value)
      	   return self
      )
      #get the value 
      2DList get := method(x, y,
      	   return (self at(x) at(y))
      )
      
      matrix := 2DList clone dim(3, 3)
      for(i, 0, 2, 1, for(n, 0, 2, 1, matrix set(i, n, i+n))) println
      matrix get(1, 1) println
      #Output
      list(list(0, 1, 2), list(1, 2, 3), list(2, 3, 4))
      2 
              

     

    • 把矩阵写入文件,并从文件中读取矩阵。

      #Define a matrix
      matrix := list(
      	   list(1, 2, 3),
      	   list(4, 5, 6),
      	   list(7, 8, 9)
      )
      #Create a new file named test.txt
      data := File open("test.txt")
      #Transform the matrix into a sequence and write it into the file
      data File write(matrix serialized)
      data close
      #Read solution 1: use File open(still a serialized file)
      readData := File open("test.txt")
      readData readLine println
      readData close
      #Read solution 2: use doFile
      readData2 := doFile("test.txt")
      readData2 println
      readData2 close
      #Output
      list(list(1, 2, 3);, list(4, 5, 6);, list(7, 8, 9););
      list(list(1, 2, 3), list(4, 5, 6), list(7, 8, 9))
              
    • 写一个猜数字程序。

      #Guess number
      standardIO := File standardInput
      guess := nil
      counter := 0
      #Get a random number between 1~100
      answer := (Random value(99)+1) floor
      
      while( counter < 10,
      	   "Guess a number(1..100):" println
      	   guess := standardIO readLine() asNumber()
      	   if((guess == answer), 
      	   			 "You are right!" println;break,
      				 if((guess > answer), 
      				 		   "Too big" println, 
      				 		   "Too small" println)
      	   )
             counter = counter + 1
      )
      #Output
      Guess a number(1..100):
      50 
      Too small
      Guess a number(1..100):
      75
      Too small
      Guess a number(1..100):
      90
      Too small
      Guess a number(1..100):
      95
      Too big
      Guess a number(1..100):
      93
      Too big
      Guess a number(1..100):
      92
      You are right!
              

    转载于:https://www.cnblogs.com/iceCream/archive/2012/12/14/2855491.html

    展开全文
  • 没几个蛋疼的人下七个浏览器,一周七天每天一个。 1.游戏有时效性。很多游戏有关的。打通关了,这个游戏就没什么价值了,就空出来空间给下一个游戏了。应用不会因为版本更迭而让某个应用让位于另一个应用。 2....
  • 说的校招硕士的待遇哈。看到网上很多人对公司的加班情况有疑问,这么说吧,比不过互联网,但也别想天天5点半下班...平时不上线的话一般六点左右,忙的话可能一周要有一两去到八九点,看你工作进度,当然没什么...
  • 七天长假,你在“堵”还是在“宅”?你在景区“被挤”,还是在家里“被催”?你在“买买买”的路上,还是在参加“婚礼婚礼和婚礼”的路上? 今年国庆,中新网将你梳理有关“黄金”的服务资讯、长假“生存...
  • 为什么很多女性九个月就分娩了呢?其实,此十月非彼十月!医学上,1个孕月按照4个孕周来计算的,而不是30或者31。也就是说,所谓的“十月怀胎”其实只有40个孕周,前后一共280。而且这个孕周还是从末次月经...
  • 从阿里离职之后来到丰趣海淘的这一年,我加班最多的一年,一周连续通宵,每天3点才能睡觉,一周工作七天,这样的日子也许只有创业初期的那股激情才能让我坚持下来。当时的思维方式为什么要把自己大把的时间...
  • 为什么叫星期日

    2010-11-25 10:24:47
    我国古代历法把二十八宿按日、月、火、水、木、金、土的次序排列,一周,周而复始,称为“七曜”---七曜指太阳、月亮和水星、金星、火星、木星、土星这五个最亮的大行星。但袁嘉谷感到不顺口,使用起来不方便,...
  • 为什么会有周末?

    2010-05-29 00:03:03
    说法:(来自于神话传说)上帝创造世界用了6天时间终于完成了整个世界的创造,到了第七天他就可以休息了。后来,上帝的信徒为了纪念上帝创世,便将7天定为一个星期。这应该欧美的概念,“礼拜”乃是说神的儿子...
  • 比特币(BTC)本身就经历了疯狂的一周,上涨了10%,而以太坊则超过了市场领导者。按市值计算的第二大加密货币在过去七天中上涨了20%,几周来首次达到175美元。 虽然一些分析师怀疑这种反弹会持续下去,理由ETH在...
  • Date Range Picker 自定义时间 为什么不显示当前月呢,现在11月 但是怎么都显示12月 var locale = { "format": 'YYYY-MM-DD', "separator": " 至 ", "applyLabel": "确定", "cancelLabel": "取消", ...
  • 今天放假的第一天,这个好像并没有发生什么大的事情,也没有什么值得纪念的事。所以我打算写写本周总结和自己的独白吧!因为放假,这个我们只上了四课。 周一的政治讲到了第八章 建设中国特色社会主义...
  • 月反思--关于加班

    2016-07-25 10:55:00
    由于最近几本人总是加班,所以本月内反思了一下为什么总是加班? 提高工作效率 我加班的原因一般都因为事情比较琐碎,紧急的事情比较多,遇到问题总是卡住,重点的这些填满了我的大脑!使我大脑乱成团,每当...
  • 我们常见的进制有:二进制、八进制、十进制、十六进制、十二进制(一年有十二个月)、七进制(一周七天)。 首先我们逐个认识: 二进制: 0和1组成,逢二进一,书写方式:0b开头; 八进制: 01234567组成,逢...
  • 月的第一周尤其辛苦。每天有效工作时间往常两倍:一到座位什么都不想,就是干活。这让我体会到,为什么有些人能把事业进程提速,拼命干一个好办法。 7月4日中午,讨论问题时,G打来电话,问为什么昨晚微信没...
  • 1.最近自学Web前端,一周七天都在编程,时间长了感觉太累,所以找点别的事情调节一下。 2.一直以来就喜欢阅读,觉得这一件特开心,特放松的事儿。 为什么专注阅读思维类的书呢 1.大脑人体最复杂最重要的结构...
  • 本书详细分析了软件工程师求职过程中的常见问题,深入解析了各大it公司考查求职者的面试真题,告诉读者用人单位需要什么样的技术人才、考查什么样的技术知识以及如何甄别人才。全书分4篇,共17章。第1篇求职过程,...
  • c语言 枚举学习

    2020-11-04 10:07:25
    枚举学习1....比如一周七天,每年12个月份等等。枚举的出现就是为了结局此类问题时更方便。 原来处理一周七天: #define MON 1 #define TUE 2 #define WED 3 #define THU 4 #define FRI 5 #define SAT
  • 一周七天,无论程序进行到哪个步骤 七天,这个数据都不会变的 七这个数据,就适合使用常量保存 常量的特点 如果一个变量常量 那么在代码执行过程中,它就不应该被修改 常量的定义方式 const 数据类型 常量名称...
  • 一周两篇持续更新中,文章首发公众号 ☕ 原创电子书 下面的文章都有对应的原创精美PDF,在持续更新中,可以来找我催更~ 47页的SpringMVC 92页的Mybatis 129页的多线程 141页的Servlet 158页的JSP 76页的集合 64...
  • 例如:一周七天,只有七种可能 public enum Weekday{ Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday } 为什么要用枚举 第一枚举作为返回类型来讲比较容易操作 第二个就是判断时会更高效...
  • 21学习SQL V1.0

    2012-11-09 14:36:17
    21学习SQL V1.0.pdf 66 SQL 21 日自学通(V1.0) 翻译人笨猪 EMAIL wyhsillypig@163.com 2 日期/时间函数.........................................................................................................
  • 例如我想定义一个能够表示一周七天的变量,但是这个变量的取值只能在0~6这七个整数常量中,同时为了使这七个数有意义,我们给他们七个分别命名。这就是枚举类型。 枚举相对于普通的常量类型,可以声明的变量提供...

空空如也

空空如也

1 2 3 4
收藏数 75
精华内容 30
关键字:

为什么一周是七天