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.１面向对象

面向对象（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.2ＪＤＫ安装与配置

为了建立起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.3ｊａｖａ运行和编译

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所示。

字节码文件是一种和任何具体机器环境及操作系统环境无关的中间代码，它是一种二进制文件，是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说明。

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命名规则

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

命名方式

大驼峰
小驼峰

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

创建一个变量的格式；

数据类型变量名；
数据类型变量名 = 数据值；
数据类型变量名，变量名，… ；
数据类型变量名 = 数据值，变量名 = 数据值，… ；

使用变量时的注意事项
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';//这是一个字符型变量，赋值为ASystem.out.println(zifu1 + 1);//66,也就是说大写字母A被当做65来处理了，//计算机的底层是用一个数字（二进制）来代表一个字符，就是65//一旦char类型发生数学运算，那么字符就会被当成一个数字来使用，就是自动转换为int类型，被翻译成一个数字byte num14 = 40;byte num15 = 50;//byte + byte--->int + int ---->intint result1 = num14 + num15;System.out.println(result1);//90short 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 =15a += 5;System.out.println(a);//15byte num = 30;//num = num + 5//num = byte+int//num = int + int//num = int//num = (byte)intnum += 5;}
}

结果展示

15Process 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);//11num1++;//单独使用。后++System.out.println(num1);//12//--------------//混合使用int num2 = 20;//前++,立马加1，在打印System.out.println(++num2);//21System.out.println(num2);//21int num3 = 30;//后++，先打印，在加1System.out.println(num3++);//30System.out.println(num3);//31//和赋值操作混合int num4 = 40;//前--，先减1，在赋值int result1 = --num4;System.out.println(result1);//39System.out.println(num4);//39//后--，先赋值，在减1int num5 = 50;int result2 = num5--;System.out.println(result2);//50System.out.println(num5);//49int x = 10;int y = 20;int result3 = ++x + y--;System.out.println(result3);//31System.out.println(x);//11System.out.println(y);//19}
}

结果展示

10
11
12
21
21
30
31
39
39
50
49
31
11
19Process 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
10Process 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的值赋值给变量maxint 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）

如果没有超过左侧的数据类型的数范围，那么编译器不上强转
如果超过了左侧的数据类型的数据范围，那么编译器直接报错

byte a = 30;//编译器自动在30加上（byte）
byte b = 128;//超过byte数据范围，直接报错

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

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

3.1流程控制

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

3.2if语句

if（布尔表达式）{

语句体；

}

执行流程图

执行流程说明

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

if（布尔表达式）{

语句体；

} else {

语句体；

}

执行流程

执行流程图

执行流程说明

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

if（布尔表达式）{

语句体；

} else if（布尔表达式）{

语句体；

}…

执行流程图

执行流程说明

首先判断关系表达式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（布尔表达式）；

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

3.4for语句

for（初始化语句；布尔表达式；步进语句）{

语句体

}

注意事项

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

3.5swich语句

swich（表达式）{

case 常量值：

语句体1：

break；

case 常量值：

语句体2：

break；

…

default:

语句体n+1;

break;

}

执行流程说明

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

执行流程图

注意事项

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

ｂｒｅａｋ，ｃｏｎｔｉｎｕｅ都是再循环中使用的关键字

作用：

ｂｒｅａｋ：结束本次循环或着说是跳出本次循环

ｃｏｎｔｉｎｕｅ：结束当前循环，进行下一轮循环

第四章数组

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,6int [] arrayA = new int[]{4,5,6};String[] arrayB = new String[]{"hello","world","hi"};}
}

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

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

4.3.1java内存

java内存

栈(Stack)：存放的都是方法中的局部变量。局部变量：方法的参数，或者说方法大括号里面的变量。作用域：一旦超出作用域，立即从栈内存当中消失.方法执行一定在栈当中
堆（Heap）：凡是new出来的东西都在堆当中。堆内存里面的东西都有一个地址值：十六进制。堆内存里面的数据，都有默认值。整数默认0；浮点数默认0.0；字符默认‘\u0000’；布尔默认false，引用默认null
方法区（Mthod Ares)：存储.class相关信息，包含方法的信息。
本地方法栈(Native Method Stack):
寄存器(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]);//0System.out.println(array[1]);//0System.out.println(array[2]);//0//改变数组当中的内容array[1] = 20;array[2] = 10;System.out.println(array);//地址值System.out.println(array[0]);//0System.out.println(array[1]);//20System.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]);//12System.out.println(array[1]);//15System.out.println(array[2]);//16System.out.println(array[3]);//数据索引越界异常}
}

结果展示

12
15
16
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3at 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.NullPointerExceptionat 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
45Process 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);//nullSystem.out.println(one.color);//nullSystem.out.println(one.price);//0.0System.out.println("==============");one.brand = "苹果";one.price = 8320.5;one.color = "红色";System.out.println(one.brand);//苹果System.out.println(one.color);//8320.5System.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)]

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

private是一个权限修饰符，代表最小权限。
可以修饰成员变量和成员方法。
被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