JAVA 基础——学习

常用的DOS命令

• dir : 列出当前目录下的文件以及文件夹
• md : 创建目录
• rd : 删除目录
• cd : 进入指定目录
• cd… : 退回到上一级目录
• cd: 退回到根目录
• del : 删除文件
• exit : 退出 dos 命令行
• 补充：echo javase>1.doc

一.Java语言概述

1.Java语言的特点

特点一：面向对象
两个基本概念：类、对象
三大特性：封装、继承、多态

特点二：健壮性
吸收了C/C++语言的优点，但去掉了其影响程序健壮性的部分（如指针、内存的申请与释放等），提供了一个相对安全的内存管理和访问机制

特点三：跨平台性
跨平台性：通过Java语言编写的应用程序在不同的系统平台上都可以运行。“Write once , Run Anywhere” 原理：只要在需要运行 java 应用程序的操作系统上，先安装一个Java虚拟机 (JVM Java Virtual Machine) 即可。由JVM来负责Java程序在该系统中的运行。

因为有了JVM，同一个Java 程序在三个不同的操作系统中都可以执行。这样就实现了Java 程序的跨平台性。

2.Java两种核心机制

1)Java虚拟机 (Java Virtal Machine)

2)垃圾收集机制 (Garbage Collection)

• 不再使用的内存空间应回收—— 垃圾回收。

  • 在C/C++等语言中，由程序员负责回收无用内存。
  • Java 语言消除了程序员回收无用内存空间的责任：它提供一种系统级线程跟踪存储空间的分配情况。并在JVM空闲时，检查并释放那些可被释放的存储空间。

• 垃圾回收在Java程序运行过程中自动进行，程序员无法精确控制和干预。

3. Java语言的环境搭建

1)什么是JDK，JRE

• JDK(Java Development Kit Java开发工具包)
  JDK是提供给Java开发人员使用的，其中包含了java的开发工具，也包括了JRE。所以安装了JDK，就不用在单独安装JRE了。

• JRE(Java Runtime Environment Java运行环境)
  包括Java虚拟机(JVM Java Virtual Machine)和Java程序所需的核心类库等，如果想要运行一个开发好的Java程序，计算机中只需要安装JRE即可。

简单而言，使用JDK的开发工具完成的java程序，交给JRE去运行。

2)JDK、JRE、JVM关系

3)下载并安装JDK

下载并安装JDK

4.注 释

Java中的注释类型：

1)单行注释

格式： //注释文字

2)多行注释

格式： /* 注释文字 */

注：

• 对于单行和多行注释，被注释的文字，不会被JVM（java虚拟机）解释执行。
• 多行注释里面不允许有多行注释嵌套。

3)文档注释 (java特有)

格式：/**
@author 指定java程序的作者
@version 指定源文件的版本
*/

注释内容可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。

二.Java基本语法

1.关键字与保留字

1）关键字：
定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
特点：关键字中所有字母都为小写

2）Java保留字：
现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字
goto 、const

2.标识符

1）定义：Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
2）技巧：凡是自己可以起名字的地方都叫标识符
3）规则：

• 由26个英文字母大小写，0-9 ，_或 $ 组成
• 数字不可以开头。
• 不可以使用关键字和保留字，但能包含关键字和保留字。
• Java中严格区分大小写，长度无限制。
• 标识符不能包含空格。

4）名称命名规范：

• 包名：多单词组成时所有字母都小写：xxxyyyzzz
• 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
• 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
• 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

5）注意：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
注意2：java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。

3.变量

1）注意：

• Java中每个变量必须先声明，后使用
• 使用变量名来访问这块区域的数据
• 变量的作用域：其定义所在的一对{ }内
• 变量只有在其作用域内才有效
• 同一个作用域内，不能定义重名的变量

声明变量： int num;
变量的赋值 ：num = 10;
声明和赋值变量 ：int num = 10;

2）分类

第一种分类方式：按数据类型
对于每一种数据都定义了明确的具体数据类型（强类型语言），在内存中分配了不同大小的内存空间。

第二种分类方式：按在类中声明的位置
成员位置 vs 局部位置（这个暂时了解下，后面在第四章会详细讲）

3）基础数据类型

整数类型：

byte（1字节 = 8bit）、short（2字节）、int（4字节）、long（8字节）

①byte 范围：-128 ~ 127
②声明long型变量，必须以“1”或“L”结尾
③通常，定义整型变量时，使用int型

浮点类型：

float、double
①浮点型，表示带小数点的数值
②float表示数值的范围比long还大
③定义float类型变量时，变量要以“f”或"F”结尾
④通常，定义浮点型变量时，通常使用float型

字符型：

char（1字符 = 2字节）

①定义char型变量，通过使用一对单引号’'，内部只能写一个字符
②表示方式：1.声明一个字符；②转义字符；③直接使用Unicode值来表示字符型常量

ASCII 码在后面第11章 IO流 会详解

布尔类型：

boolean

• boolean 类型用来判断逻辑条件，一般用于程序流程控制：
  • if条件控制语句；
  • while循环控制语句；
  • do-while循环控制语句；
  • for循环控制语句；
• boolean类型数据只允许取值true和false，无null。

4）基本数据类型转换

前提：只讨论7中基本数据类型变量间的运算，不包含Boolean类型
说明：此时的容量大小，表示的数的范围的大小，比如：float容量要大于long的容量。

自动类型提升：

容量小的数据类型的变量与容量大的数据类型做运算时，结果自动提升为容量大的数据类型。
byte，chart，short ——>int ——>long ——>float——>double

注意：
	①有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
	②byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型
	③boolean类型不能与其它数据类型运算。
	④当把任何基本数据类型的值和字符串(String)进行连接运算时(+)，基本数据类型的值将自动转化为字符串(String)类型

强制类型转换：

自动类型转换提升原酸的逆运算
1.需要使用强转符：()
2.强制类型转换，可能导致精度损失

变量运算规则的两个特殊情况：

1.long类型如果后面不写L是可以的，会转换为Init类型；但float类型后面不加F就不行
2.整型常量，默认类型为Init型；浮点型常量，默认类型为double型

5）String类型变量

1.String属于引用数据类型，翻译为字符串
2.声明String类型变量时，使用一堆双引号“”
3.String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+
4.运算的结果仍然是String类型

4.变量之进制

1）对于整数，有四种表示方式：

• 二进制(binary)：0,1 ，满2进1.以0b或0B开头。
• 十进制(decimal)：0-9 ，满10进1。 八进制(octal)：0-7 ，满8进1. 以数字0开头表示。
• 十六进制(hex)：0-9及A-F，满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。如：0x21AF +1= 0X21B0

2）原码、反码、补码

• 最高位是符号位，0是正数，1是负数
• 对于正数来讲：原码、反码、补码是相同的：三码合一。
• 计算机底层都是使用二进制表示的数值
• 计算机底层都是使用的数值的补码保存数据的。

示例：原码 ——> 补码


示例：补码——>原码

3）十进制转二进制

除2取余的逆

4）二进制转八进制，十六进制

5.运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。 算术运算符

• 赋值运算符
• 比较运算符（关系运算符）
• 逻辑运算符
• 位运算符
• 三元运算符

1）算术运算符

前++ 和 后++ 除非涉及到赋值给一个新的变量，否则对他自己没有任何影响，都会+1
但赋值给一个新的变量就会存在是否+1的问题：前++（先加后用，就会+1），后++(先用后加，就不会+1)

2）赋值运算符

符号：=
当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
支持连续赋值。

扩展赋值运算符：
+=, -=, *=, /=, %=

3）比较运算符

比较运算符的结果都是boolean型，也就是要么是true，要么是false

== ，!= ，< ，> ，>= ，<=

4）逻辑运算符

• “&”和“&&”的区别：

  • &时，左边无论真假，右边都进行运算；
  • &&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。

• “|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。

• &&和||是截断，根据左边的真假判断后面是否继续走

5）位运算符

结论：
1.位运算符操作的都是整型的数据
2.<< ：在一定范围内，每向左移1位，相当于 *2
>> ：在一定范围内，每向右移1位，相当于 /2

面试题：最高效方式的计算：2 * 8?
答：2 << 3 或 8 << 1

6）三元运算符

• 表达式1和表达式2为同种类型
• 三元运算符与if-else的联系与区别：
  1）三元运算符可简化if-else语句
  2）三元运算符要求必须返回一个结果。
  3）if后的代码块可有多个语句

6.程序流程控制

1）顺序结构

程序从上到下逐行地执行，中间没有任何判断和跳转。

2）分支结构

根据条件，选择性地执行某段代码。
有if…else和switch-case两种分支语句。

switch-case结构：

switch(表达式){
	case 常量1:
	语句1;
	// break;
	case 常量2:
	语句2;
	// break; … …
	case 常量N:
	语句N;
	// break;
	default:
	语句;
	// break;
}

switch语句有关规则：
① switch(表达式)中表达式的值必须是下述几种类型之一：byte，short，char，int，枚举 (jdk 5.0)，String (jdk 7.0)；
② case子句中的值必须是常量，不能是变量名或不确定的表达式值；
③ 同一个switch语句，所有case子句中的常量值互不相同；
④ break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有break，程序会顺序执行到switch结尾
⑤ default子句是可任选的。同时，位置也是灵活的。当没有匹配的case时，执行default

3）循环结构

根据循环条件，重复性的执行某段代码。
有while、do…while、for三种循环语句。
注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。

①for循环

②while循环

• 语法格式：

①初始化部分
while(②循环条件部分)｛ 
	③循环体部分; 
	④迭代部分; 
}

示例：

• 执行过程：
  ①-②-③-④-②-③-④-②-③-④-…-②

• 注意：
  不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。
  for循环和while循环可以相互转换。他俩惟一的区别就是初始化条件i 的作用域范围不同（for循环：出了for不能调；while循环：出了while还能调）

③do-while循环

• 语法格式

①初始化部分;
do{
	③循环体部分
	④迭代部分
}while(②循环条件部分); 

• 执行过程：
  ①-③-④-②-③-④-②-③-④-…②

• 说明：
  do-while循环至少执行一次循环体;
  开发中使用for和while的情况多些，使用do-while的情况比较少

7.特殊关键字的使用：break、continue

区别：
使用范围：break 用于switch-case和循环结构中；continue用于循环结构中
循环中使用的作用：break 用于结束当前循环；continue用于结束当次循环

**相同点：**关键字后面不能声明和执行语句

示例 ：只能作用于最接近的内层for循环

如果跳出最近的一层循环，可以通过标签指明要跳过的是哪一层循环，如下：label后面的那个for就是指定的循环

区分于return的使用
return：并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束。
与break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环之内

总结：

• break只能用于switch语句和循环语句中。
• continue 只能用于循环语句中。
• 二者功能类似，但continue是终止本次循环，break是终止本层循环。break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。

三.eclipse的配置

eclipse的初始化配置

四.Helloworld的编写和程序的运行

1.新建一个Java工程，也就是项目

2.现在创建的是Java的项目，但用的是javaE的透视图，要不要把这个关联到java中透视图中？
勾选上，选择no

3.选中文件夹，新建一个package包

4.起个包名，记得用小写

5.选中包，新建文件class类，class类名起名首字母大写

6.生成了

7.写入代码：

package com.atguigu.concat;

public class Helloworld {
	public static void main(String[] args) {
		System.out.println("helloworld");
	}
}

8.运行

五.数组

1.概念

• 数组名
• 下标(或索引)
• 元素
• 数组的长度

2.特点

1）有序排列的
2）数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型
3）创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
4）数组的长度一旦确定，就不能修改。

3.分类

1）按照维数：一维数组，二维数组。。。
2）按照数组元素的类型：基本数据类型元素的数组，引用数据类型元素的数组

4.一维数组

1）初始化

• 动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行
  

• 静态初始化：在定义数组的同时就为数组元素分配空间并赋值。
  

2）默认初始化值

3）内存解析

5.多维数组

1）初始化

• 动态初始化：

格式1：
如：int[][] arr = new int[3][2]; 定义了 二维数组中有3个一维数组每一个一维数组中有2个元素
格式2：
如：int[][] arr = new int[3][]; 定义了二维数组中有3个一维数组。每个一维数组都是默认初始化值null (注意：区别于格式1）

• 静态初始化：

如：int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}}; 每一个一维数组中具体元素也都已初始化

2）默认初始化值

针对初始化方式一：比如：int[][] arr = new int[4][3]
外层元素的初始化值为：地址值
内层元素的初始化值为：与一维数组初始化情况相同

针对初始化方式二：比如：int [][] arr = new int[4][]
外层元素的初始化值为：null
内层元素的初始化值为：不能调用，否则报错

3）内存解析

6.Arrays工具类的使用

java.utils.Arrays类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法

• boolean equals(int[] a,int[] b) 判断两个数组是否相等
• String toString(int[] a) 输出数组信息
• void fill(int[] a,int val) 将指定值填充到数组之中
• void sort(int[] a) 对数组进行排序
• int binary Search(int[] a,int key) 对排序后的数组进行二分法检索指定的值

示例：

package com.atguigu.java;
import java.util.Arrays;

public class arrayTest {
	public static void main(String[] args) {
		int[] arr1 = new int[] {1,2,3,4};
		int[] arr2 = new int[] {1,3,2,4};
		boolean isEqueals = Arrays.equals(arr1,arr2);
		//对比数组
		System.out.println(isEqueals);
		
		//输出数组信息
		System.out.println(Arrays.toString(arr1));
		
		//将指定值填充到数组中
		Arrays.fill(arr1, 10);
		System.out.println(Arrays.toString(arr1));
		
		//排序
		Arrays.sort(arr2);
		System.out.println(Arrays.toString(arr2));
		
		//二分法查找
		int[] arr3 = new int[] {1,2,3,4,5,6,7};
		int index = Arrays.binarySearch(arr3, 5);
		System.out.println(index);
	}
}

7.数组中的常见异常

1）数组角标越界的异常 ArrayIndexOutOfBoundsException

示例：

public class arrayTest {
	public static void main(String[] args) {
		int[] arr = new int[] {1,2,3,4,5};
		System.out.println(arr[5]);
		System.out.println("hello");//上一行报错，后面的都不执行
		
	}
}

报错：

2）空指针异常：NullPointerException

示例：

public class arrayTest {
	public static void main(String[] args) {
		//情况一：
		int[] arr1 = new int[] {1,2,3};
		arr1 = null;
		System.out.println(arr1[0]);
		
		//情况二：
		int[][] arr2 = new int[4][];
		System.out.println(arr2[0][0]);
		
		
		//情况三：
		String[] arr3 = new String[] {"AAA","BBB","CCC"};
		arr3 = null;
		System.out.println(arr3[0].toString());
	}
}

报错：

六.面向过程与面向对象

1.面向过程(POP) 与 面向对象(OOP)的区别

二者都是一种思想，面向对象是相对于面向过程而言的。

• 面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。
• 面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

例子：人把大象装进冰箱

2.面向对象的三大特征

• 封装 (Encapsulation)
• 继承 (Inheritance)
• 多态 (Polymorphism)

3.类的语法格式

4.创建Java自定义类

步骤：

1. 定义类（考虑修饰符、类名）
2. 编写类的属性（考虑修饰符、属性类型、属性名、初始化值）
3. 编写类的方法（考虑修饰符、返回值类型、方法名、形参等）

5.对象的创建和使用

1）基础步骤

1.创建对象
2.调用属性：“对象.属性.”
3.调用方法：“对象.方法”

package com.atguigu.java;
import java.util.Arrays;

public class arrayTest {
	public static void main(String[] args) {
		//1.创建对象
		Person p1 = new Person();
		
		//2.调用属性：“属性.方法”
		p1.name = "Tom";
		p1.isMale = true;
		System.out.println(p1.name);
		
		//3.调用方法：“对象.方法”
		p1.eat();
		p1.sleep();
		p1.talk("中文");
		
	}
}
class Person{
	//属性
	String name;
	int age = 1;
	boolean isMale;
	
	//方法
	public void eat() {		
		System.out.println("人可以吃饭");
	}
	public void sleep() {
		System.out.println("人可以睡觉");
	}
	public void talk(String language) {
		System.out.println("人可以说话，使用的是：" + language);
	}
}

2）类的多个对象的关系

如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性（非static的）。
意味着，如果我们需改一个对象的属性a，则不影响另外一个对象属性a的值。

public class arrayTest {
	public static void main(String[] args) {
		//1.创建对象
		Person p1 = new Person();
		
		//2.调用属性：“属性.方法”
		p1.name = "Tom";
		p1.isMale = true;
		System.out.println(p1.name);
		
		//3.调用方法：“对象.方法”
		p1.eat();
		p1.sleep();
		p1.talk("中文");
		
		//****************
		Person p2 = new Person();
		System.out.println(p2.name);//null
		System.out.print(p2.isMale);//false
		
		//****************
		//将p1变量保存的对象地址赋值给p3，导致p1和P3指向了堆空间中的同一对象实体
		Person p3 = p1;
		System.out.println(p3.name);//Tom
		
		p3.age = 10;
		System.out.print(p1.age);//10
		
		
	}
}

3）内存解析

引用类型的变量，只可能存储两类值：null 或 地址值（含变量的类型）

• 堆（Heap），此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。

• 通常所说的栈（Stack），是指虚拟机栈。虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型（boolean、byte、char 、 short 、 int 、 float 、 long 、double）、对象引用（reference类型，它不等同于对象本身，是对象在堆内
  存的首地址）。 方法执行完，自动释放。

• 方法区（Method Area），用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据

根据代码，画出内存图

6.类的成员之一：属性(field)

1）属性

语法格式：修饰符 数据类型 属性名 = 初始化值 ;

• 说明1: 修饰符
  常用的权限修饰符有：private、缺省、protected、public
  其他修饰符：static、final (暂不考虑)

• 说明2：数据类型
  任何基本数据类型(如int、Boolean) 或 任何引用数据类型。

• 说明3：属性名
  属于标识符，符合命名规则和规范即可。

示例：

public class Person{
private int age; //声明private变量 age
public String name = “Lila”; //声明public变量 name
}

2）成员变量与局部变量

对象属性的默认初始化赋值
当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值。除了基本数据类型之外的变量类型都是引用类型，如上面的Person及前面讲过的数组。

(1)相同点：

①定义变量的格式：数据类型 变量名 = 变量值
②先声明，后使用
③变量都有其对应的作用域

(2)不同点：

①在类中声明的位置不同
属性：直接定义在诶的一对{ }内
局部变量：声明在方法内，方法形参，代码块内，构造器形参，构造器内部的变量

②关于权限修饰符的不同
属性：可以在声明属性时，指明其权限，使用权限修饰符
常用的权限修饰符：private,public,缺省,protected ---->封装性
目前，大家声明属性时，都使用缺省就可以了
局部变量：不可以使用权限修饰符

③默认初始化的情况
属性：类的属性，根据其类型，都有默认初始化
整型（int,short,int.long）：0
浮点型（float,double）：0.0
字符型（char）：0（或 ’ \u0000 ’ ）
布尔型（boolean）：false

	引用数据类型（类，数组，接口）：null

局部变量：没有默认初始化值
意味着，我们在调用局部变量之前，一定要显示赋值
特别地，形参在调用时。我们赋值即可。

④在内存中加载的位置
属性：加载到对空间中（非static）
局部变量：加载到栈空间

package com.atguigu.java;
import java.util.Arrays;


public class arrayTest {
	public static void main(String[] args) {
		User u1 = new User();
		System.out.println(u1.name);//null
		System.out.println(u1.age);//0
		System.out.println(u1.isMale);//false
		
		u1.talk("中文");//我们使用中文进行交流
		u1.eat();//北方人喜欢吃烙饼
		
		
	}
}
class User{
	//属性（或成员变量）
	String name;
	public int age;
	boolean isMale;
	
	//下面方法里面的变量就是局部变量
	public void talk(String language) {
		//language 形参，也是局部变量
		System.out.println("我们使用" + language +"进行交流");
	}
	
	public void eat() {
		//food 是局部变量
		String food = "烙饼";
		System.out.println("北方人喜欢吃" +food);
	}
}

7.类中方法的声明和使用

1）举例

public void eat() {}
public void sleep(int hour) {}
public void getNation(String nation) {}

2）方法的声明：

权限修饰符 返回值类型 方法名(形参列表){
	方法体
}

注意：static，final，abstract来修饰的方法，后面再讲

3）说明

(1)关于权限修饰符：默认方法的权限修饰符先都使用public
java规定的四种权限修饰符：private，public，缺省，protect ----->封装性在细说

(2)返回值类型：有返回值 vs 没有返回值
如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要用return 关键字来返回指定类型的变量或常量：return 数据；如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要使用``return，但是，如果使用的话只能return ;表示结束此方法的意思。

(3)方法名：
属于标识符，遵循标识符的规则和规范，”见名知意“

(4)形参列表
方法可以声明0个，1个，或多个形参
格式：数据类型1 形参1，数据类型2 形参2

(5)方法体
方法功能的体现

4）return 关键字的使用

(1)使用范围：使用在方法体中
(2)作用：①结束方法
②针对有返回值类型的方法，使用return 数据方法返回所要的数据
(3)注意：return 关键字后面不可以执行语句

5）方法的使用中，可以调用当前类的属性或方法

特殊的：方法A中有调用了方法A：递归方法
方法中，不可以定义新方法

package com.atguigu.java;
import java.util.Arrays;


public class arrayTest {
	public static void main(String[] args) {
		Customer cust1 = new Customer();
		cust1.eat();
		cust1.name = "小王";
		System.out.println(cust1.getName());
		
	}
}
class Customer{
	//属性
	String name;
	int age;
	boolean isMale;
	
	//方法
	//void 不需要返回值
	public void eat() {
		System.out.println("客户吃饭");
	}
	
	//返回String 类型的返回值
	public String getName() {
		return name;
	}
}

8.匿名对象的使用

1）定义

我们创建的对象，没有显式的赋给一个变量名，即为匿名对象

2）特征

匿名对象只能调用一次

3）使用

package com.atguigu.java;
import java.util.Arrays;


public class arrayTest {
	public static void main(String[] args) {
		//普通对象
//		Phone p = new Phone();
//		p.sendEmail();
//		p.playgame();
		
		//匿名对象
		//下面两个匿名对象不是同一个对象，所以上面赋值了，下面的为0.0
		new Phone().price = 1999;
		new Phone().showPrice();//0.0
		
		//如果给匿名对象 调用两个方法->PhoneMall()
		PhoneMall mall = new PhoneMall();
		mall.show(new Phone());
		
		
	}
}
class PhoneMall{
	public void show(Phone phone) {
		phone.sendEmail();
		phone.playgame();
	}
}
class Phone{
	double price;
	public void sendEmail() {
		System.out.println("发送邮件");
	}
	public void playgame() {
		System.out.println("玩游戏");
	}
	public void showPrice() {
		System.out.println("手机价格为：" + price);
	}
}

9.方法的重载

1）概念

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

特点：
与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。

“两同一不同”：
两同指的是 同一个类，相同方法名
参数列表不同指的是 参数个数不同，参数类型不同

2）举例

Arrays类中重载的sort() / binarySearch()

3）判断是否重载

跟方法的权限修饰符，返回值类型，形参变量名，方法体都没有关系！

4）在通过对象调用方法时，如何确定某一个指定的方法

方法名——>参数列表

5）示例

class OverLoadText{
	//如下构成了重载
	public void getSum(int i,int j) {
		
	}
	
	public void getSum(double d1,double d2) {
			
	}
	
	public void getSum(String s,int j) {
		
	}
	
	//这个和第一个就重复了，会报错
//	public int getSum(int i,int j) {
//		
//	}
}

10.可变个数的形参

1）jdk 5.0 新增的内容

两种写法都可以，但不能都写上，都写上就重复了，会报错

//JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量
public static void test(int a ,String[] books);
//JDK5.0：采用可变个数形参来定义方法，传入多个同一类型变量
public static void test(int a ,String…books);

2）具体使用

1. 声明格式：方法名(参数的类型名 ...参数名)
2. 可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个
3. 可变个数形参的方法 与 同名的方法之间，彼此构成重载
4. 可变参数方法的使用 与 方法参数部分使用数组 是一致的，也就是说二者不能共存
5. 方法的参数部分有可变形参，必须放在形参声明的末尾
6. 在一个方法的形参位置，最多只能声明一个可变个数形参

3）使用

package com.atguigu.java;

public class MethodArgsTest {
	public static void main(String[] args) {
		MethodArgsTest test = new MethodArgsTest();
		test.show("hello","hi");
	}
	
	//下面两种方法表示一个意思，不能同时写
	//JDK5.0
	public void show(String ... str) {
		System.out.println("show(String ... str)");
		//如果要遍历参数，可以当数组去遍历
		for (int i = 0; i < str.length; i++) {
			System.out.println(str[i]);
		}
	}
	//JDK 5.0以前
//	public void show(String[] str) {
//		
//	}
}

11.理解变量的赋值

• 如果变量是基本数据类型，此时赋值的是变量所保存的数据值
• 如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值

package com.atguigu.java;

public class MethodArgsTest {
	public static void main(String[] args) {
		System.out.println("*****基本数据类型*******");
		int m = 10;
		int n = m;
		System.out.println("m = " + m + ",n = " + n);//m = 10,n = 10
		
		n = 20;
		System.out.println("m = " + m + ",n = " + n);//m = 10,n = 20
		
		System.out.println("*****引用数据类型*******");
		
		Order o1 = new Order();
		o1.orderId = 1001;
		
		//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体
		Order o2 = o1;
		System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " + o2.orderId);
		//o1.orderId = 1001,o2.orderId = 1001
		
		o2.orderId = 1002;
		System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " + o2.orderId);
		//o1.orderId = 1002,o2.orderId = 1002
	}
	

}
class Order{
	int orderId;
}

12.方法的形参的传递机制：值传递

1）形参：方法定义时。声明的小括号内的参数
实参：方法调用时，实际传递给形参的数据

Java的实参值如何传入方法呢？
Java里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

• 形参是基本数据类型：将实参 基本数据类型 变量的“数据值”传递给形参
  - 形参是引用数据类型：将实参 引用数据类型 变量的“地址值”传递给形参

2）值传递机制
如果参数是基本数据类型，此时实参给形参的是实参真实存储的数据值
如果参数是引用数据类型，此时实参给形参的是实参存储数据的地址值

3）示例
基本数据类型的参数传递：

引用数据类型的参数传递：