java基础解析

第一章Java的介绍与配置
1.1java的介绍
1.简介
Java是由sun公司推出的Java面向对象程序设计语言（以下简称Java语言）和Java平台的总称。

由James Gosling和同事们共同研发，并在1995年正式推出。

Java最初被称为Oak，是1991年为消费类电子产品的嵌入式芯片而设计的。

1995年更名为Java，并重新设计用于开发Internet应用程序。

从此，Java被广泛接受并推动了Web的迅速发展，常用的浏览器均支持Javaapplet。

另一方面，Java技术也不断更新。

Java自面世后就非常流行，发展迅速，对C++语言形成有力冲击。

在全球云计算和移动互联网的产业环境下，Java更具备了显著优势和广阔前景。

2010年Oracle公司收购Sun Microsystems。

2.几个java的名词
JDK
JDK(Java Development Kit) 是Java 语言的软件开发工具包。

（可以理解为程序员专用）
SE(J2SE)，standard edition，标准版，是我们通常用的一个版本，从JDK 5.0开始，改名为Java SE。

EE(J2EE)，enterprise edition，企业版，使用这种JDK开发J2EE应用程序，从JDK 5.0开始，改名为Java EE。

ME(J2ME)，micro edition，主要用于移动设备、嵌入式设备上的java应用程序，从JDK 5.0开始，改名为Java ME。

没有JDK的话，无法编译Java程序，如果想只运行Java程序，要确保已安装相应的JRE。

JRE
JRE（Java Runtime Environment，Java运行环境），运行JAVA程序所必须的环境的集合，包含JVM标准实现及Java核心类库。

当你只是想要运行java而不进行开发时，只有一个jre就可以。

1.2为什么要选择java
1.选择余地广泛。

许多开源的项目会实现一些高级功能，而这些项目都是选择java来实现的。

2.一次编译到处执行。

即跨平台。

Java之所以能够跨平台，就是因为虚拟机跨平台。

java的源代码，进行编译之后才能友虚拟机运行。

编译完成的字节码文件在不同的系统的虚拟机上执行的结果相同
3.垃圾回收机制GC (Garbbage collection)
在c++等语言中，你使用的一些对象等都会占用一定的内存，如和你果长时间不进行释放内存，最总会导致内存溢出，而java不用，会对一些没有用的对象进行回收。

1.3 jdk的安装
JAVA_HOME java的安装目录
CLASSPATH .(一个点)
PATH java安装目录\bin
详见ppt
1.4Hell oWorld程序
新建txt，重命名HelloWorld.java
public class HelloWorld{ //这一行的HelloWorld必须和文件名相同public static void main(String[] args){ //main函数
System.out.println("Hello,World");
}
}
.java : java的源文件
.class : java的编译文件
先对源文件进行编译，之后虚拟机再运行。

1．编译：javac HelloWorld.java
2．运行：java HelloWorld
第二章java的数据类型和运算符
2.1Java的编写工具
Java的编写工具众多，jdeveloper、jbuilder、idea、netbeans、Eclipse等
我们主要使用Eclipse或MyEclipse
新建一个java项目
1.我们的java程序都是要依附在一个项目上来实现。

在MyEclipse中，左侧的Package
Explore空白处，右键→new→java project,将项目命名。

（项目名首字母小写即可，
命名规范我们会讲到）。

2.在src上单击右键→new→class,将类命名（首字母大写）。

3.此时进入编写页面，观察，一些基本的代码都已经写好了。

常用的快捷键
Alt+/ 快速提示
Ctrl+D 删除一行
Ctrl+Shift+F 格式化代码，让代码更具可读性。

Ctrl+Shift+O 快速导包（这个功能后面会讲到）
Ctrl+S 快速保存
Ctrl+Z 撤销上一步操作
Ctrl+/ 快速注释
2.2 注释
➢单行注释：Java语言中使用双斜杠（//）放在要注释的内容之前。

➢多行注释：使用“/*”和“*/”将程序中需要注释的内容包括起来。

➢文档注释：文档注释是已“/**”开始，以星号紧跟一个斜杠（*/）结尾。

Ex：
package com.handson.test;
/**
* 文档注释
* @author 李冠霖
* 这个类实现了**功能
* 等
* */
public class HelloWorld {
//单行注释，放在要注释的代码之前，定义了一个int类型的i
int i = 0;
/*
* 多行注释
*也可以注释掉一大段的代码
* */
public void f1(){
}
}
2.3 标识符
标识符：程序员定义的变量，方法(函数)，类即程序员给程序起的名字。

定义规则：1.不能是关键字和保留字。

2.只能包含字母，下划线，数字和美元符号。

3.不能以数字开头。

关键字：语言定义好的一些单词，在单词本身中起到一定的作用。

保留字：用作后期使用，使版本向后兼容。

goto
Class continue default do double else enum extends Final finally float for if implements import int Interface instanceof long native new package private protected Public return short static strictfp super switch synchronized This throw throws transient try void volatile while
2.4 数据类型
Java语言支持的数据类型分为两类：基本数据类型和引用类型
1、基本数据类型共8中，分为布尔类型（boolean）和数值类型，数值类型又分为整数类型和浮点类型。

整数类型包括byte（8位）、short（16位）、int（32位）、long（64位）、char（16位），浮点类型包括float（单精度浮点32位）和double（双精度浮点64位）
2、引用类型包括类、接口、和数组类型，还有一种特殊null类型。

引用数据类型就是对一个对象的引用，对象包括实例和数组两种。

空类型（null）就是null值类型，这种类型没有名称，所以不能声明一个null类型的变量或者转换到null类型。

2.4.1整数型
byte：byte（字节）类型的整数在内存里占8位，表示的范围是：-128（-2的7次方）~ 127 （2的7次方-1）
byte类型最大为1111 1111 按照二进制算法表面上为255，实际上在java中第一位当做了系统的符号位。

short：short（2个字节长度）类型整数在内存里占16位，表示范围-32768 ~ 32767
int：int（4个字节长度）类型在内存中32位，表示范围-2147483648 ~ 2147483647
long：long（8个字节长度）类型在内存中64位，表示范围-9223372036854775808 ~ 9223372036854775807
int类型是常用的整数类型，Java整数常量默认的就是int类型。

使用byte或者short类型时，整数的范围不能超过类型的范围，Java直接将整数常量当成byte或者short类型。

例如：
byte a = 24; short b = 1255;
但是使用几个巨大的整数常量时，Java不会自动把整个整数常量当成long类型，所以需要在整数常量后面加上L作为后缀，例如
long a = 99999999999999999L;
Java中整数常量有4种表示方式：十进制，二进制（0b或者0B开头），八进制（以0开头），十六进制（以0x或者0X开头）。

举例：int I = 9/10; //结果为0
int octalValue = 013; //八进制转换成十进制表示11
int hexValue1 = 0X13; //十六进制转换成十进制表示19
int hexValue2 = 0XAF; //十六进制转换成十进制表示175
int binValue1 = 0B11011; //二进制转换成十进制表示27（JDK1.7中新增特性）
特例：计算一天有多少微秒。

public class Test {
public static void main(String[] args) {
long micros = 24*60*60*1000*1000L;
long millions = 24*60*60*1000L;
System.out.println(micros/millions);
}
}
2.4.2 源码、反码、补码
原码：直接将一个数值换算成二进制数。

反码：正数的反码是本身，负数是对原码按位取反，只是最高符号位保持不变。

补码：正数的补码和原码完全相同，负数的补码是其反码加1。

Ex：求数字7的源码，反码，补码
源码：0000 0111
反码：0000 0111
补码：0000 0111
求数字-7的源码，反码，补码
源码：1000 0111
反码：1111 1000
补码：1111 1001
2.4.3 字符型
字符型常用于表示单个字符，字符常量必须使用单引号括起来，例如：char a = ‘a’; char 类型的值也可以直接作为整数类型的值来使用，是一个16位的无符号整数，范围是0 ~ 65535 表示方式如下：
➢直接通过单个字符来指定字符常量，例如’A’‘a’‘0’
➢通过转义字符表示特殊字符型常量，例如：’\n’‘\t’
➢直接使用Unicode值来表示字符常量，例如：’\uXXXX’，XXXX表示一个十六进制的整数。

举例：
char aChar = 'a';
char enterChar = '\t';
char ch = '\u2660';
System.out.println(aChar);
System.out.println(enterChar);
System.out.println(ch);
3.5.4 浮点型
Java浮点类型：float和double。

float占4个字节（byte）32位，double占8个字节（byte）64个长度。

float类型的常量后面必须以f或者F结尾，例如：float a = 12.55f; double类型的常量后面可以d或者D结尾，但是不强制追加，不写也没有问题。

float’精确到小数点后七位，double精确到十六位。

特殊情况：正无穷大、负无穷大、非数分别用基本数据类型对应的封装类来表示，
浮点数的表示方式分为两种：
1、十进制方式float a = 12.55f;
2、科学计数法形式：float a = 12.5e2f;
举例：
float a = 12.555f;
double b = 12.55;
float a = 12.55e5f;
float c = Float.NaN; //不是一个数
float d = Float.NEGATIVE_INFINITY; //负无穷大
int e = Integer.MIN_VALUE; //最大值
3.5.5 布尔型
布尔型只有一个boolean类型，用于表示逻辑上的“真”或者“假”，数值只能是true或者
false
举例：
boolean a = true; boolean b = false;
常用在逻辑判断上，例如：
if(a){
System.out.println(“条件为真”);
}else{
System.out.println(“条件为假”);
}
2.5基本数据类型转换
2.5.1自动类型转换
将一种基本数据类型的值直接赋给另一种基本数据类型，则这种方式被称为自动类型转换。

前提是把一个范围小的数值或变量直接赋值给另一个数据范围大的变量时，系统可以进行自动类型转换。

举例：
byte a = 25;
short b = a;
long c = a;
float d = a;
System.out.println(d);
注意：不能将数据范围大的变量或数值赋值给范围小的变量，例如：int a = 25; byte b = a; 会直接报错。

转换顺序：byte->short->int->long->float->double
char->
2.5.2 强制类型转换
将大范围的数据向小范围的数据进行转换则需要进行强制转换，语法格式为：（targetType）value；
例如：
public class Test {
public static void main(String[] args) {
int i = 300;
byte b = (byte)i;
System.out.println(b);
}
}
结果为：44。

结果分析：(300)10 → (100101100)2
byte只能存放8位，截取8位（00101100）转换为十进制位44.
2.6 运算符
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

Java语言使用运算符将一个或多个操作数据连接成执行性语句，用以实现特定功能。

➢算术运算符
➢赋值运算符
➢比较运算符
➢逻辑运算符
➢位运算符
➢类型相关运算符
2.6.1算数运算符
加法运算（+）、减法运算（-）、乘法运算（*）、除法运算（/）、取余（取模）运算（%）、自加运算（++）、自减运算（--）、（+）还可以做为字符串的连接符。

Ex：取出一个数的个百十千位
int i = 3256;
System.out.println(i%10);
System.out.println(i%100/10);
System.out.println(i%1000/100);
System.out.println(i%10000/1000);
自加和自减运算
int j = 3;
j++;
System.out.println(j);
j--;
System.out.println(j);
2.6.2 赋值运算符
Java使用“=”作为赋值运算符，为变量指定变量值。

举例：
int a = 5; String b = “abc”;
2.6.3 位运算符
Java支持的运算符有7个：按位与（&）、按位或（|）、按位非（~）（符号位变！！）、按位异
或（^）、左移运算符（<<）、右移运算符（>>）、无符号右移运算符（>>>）
基本运算法则：
&（与）两个全部为1结果才为1
| （或）两个有一个为1结果即为1
异或（^）两个相同位0两个不同位1
Ex：
int a = 3;
int b = 9;
System.out.println(a&b);
System.out.println(a|b);
System.out.println(a^b);
结果为：1,11,10
结果分析： 3→ 0000 0011
9→ 0000 1001
&→ 0000 0001 → 1
|→ 0000 1011 → 11
^→ 0000 1001 → 10
非，左移和右移运算法则
非：按位取反，包括符号位。

Ps:在没有溢出的前提下：左移n位等于乘以2的n次方。

右移n位等于整除2的n次方
int i = 2;
System.out.println(~i);
System.out.println(i<<2);
int j = -7;
System.out.println(j>>2);
结果为：-3，8，-2
结果分析：取非：
在内存中：2使用二进制存贮补码： 000…… 0010（共32位）
取非 111…… 1101（共32位）此时还是补码
减1 111……1 1100（反码）
取反 1000……0 0011 → -3
左移两位：
2的补码：0000 0……0 0010
左移两位：最后填两个0最前面两位去掉
00……0 1000 → 8
右移两位：
-7的源码：1000 …… 0000 0111
-7的反码：1111 …… 1111 1000
-7的补码：1111 …… 1111 1001
右移两位：1111 …… 1111 1110
2.6.4 拓展后的复制运算符
赋值运算符可以与算术运算符、位移运算符结合，扩展成功能更加强大的运算符。

➢+=：对于x += y，表示x = x + y；
➢-=：对于x-= y，表示x = x-y；
➢*=：x*= y，表示x = x * y；
➢/= ; %=; &=; |=; ^=; <<= ; >>=; >>>=;
2.6.5 比较运算符
比较运算符用于判断两个变量或者常量的大小，比较运算的结果是一个boolean值（true或者false）
➢>：大于，只支持左右两边操作数是数值类型。

➢>=：同上
➢<：同上
➢<=：同上
➢==：同上，即使他们数据类型不相同，只要它们的值相同，也返回true，例如：97==’a’，返回true
➢!=：不等于，如果进行比较的两个操作数都是数值类型，只要值不同就返回true。

Ex：
int a = 1;
int b = 2;
System.out.println(a>b);
System.out.println(a<b);
System.out.println(a==b);
System.out.println(a!=b);
结果: false true false true.
2.6.6逻辑运算符
逻辑运算符用于操作两个布尔型的变量或常量，逻辑返回的值为boolean类型，主要有6个，➢&&（短路与）：前后两个操作数都为true时，返回true，否则返回false，例如：32>24
&&“abc”==”abc”，返回true
➢||（短路或）：前后两个操作数，有个为true就返回true，举例：32>24 || “abc”!=”abc”，返回true
➢&（不短路与），|（不短路或），!（非），^（异或）
短路与和不短路与的区别：与操作只要有一个为真结果即为真。

短路与当第一个条件为真时，第二个条件变不会判断。

短路或和不短路或的区别：或操作只要有一个为假时就为假。

短路或当第一个条件为假时第二个条件便不会判断。

2.6.7 三目运算符
三目运算符只有一个：（？：），举例：int a = 5>3 ? 6 : 7；
2.6.8运算符的优先级
第三章流程控制和数组
任何一门编程语言都会提供两种基本的流程控制结构：分支结构和循环结构。

其中分支结构根据条件来选择性地执行某段代码，循环结构则用于实现根据循环条件重复执行某段代码。

Java中的分支结构语句为：if、switch
Java中的循环结构语句为：while、do while、for、foreach
Java中提供了break、continue来控制程序的循环结构
3.1顺序结构
顺序结构就是程序从上到下逐行的执行，中间没有任何判断和跳转。

举例1：
public class TestCar {
public static void main(String[] args) {
int a = 3;
int b = 5;
int c = a+b;
System.out.println("输出结果："+c);
}
}
3.2分支结构
Java语言使用if语句和switch语句来进行分支控制，其中if语句使用boolean表达式或boolean值来作为分支条件进行分支控制；switch语句则用于对多个整型值进行匹配，从而实现分支。

3.2.1 if条件语句
结构：if(条件){ 满足条件执行的代码}
public class Test {
public static void main(String[] args) {
int a = 1;
int b = 2;
//普通的if语句
if(a<b){
System.out.println("a<b");
}
//if--else语句
if(a>b){
System.out.println("a>b");
}else{
System.out.println("a<=b");
}
//if语句的嵌套
if(a<b){
if(a>0){
System.out.println("a<b且a>0");
}
}
//上条等价的语句
if(a<b && a>0){
System.out.println("a<b且a>0");
}
//else if语句
int grade = 58;
if(grade>80){
System.out.println("优秀");
}else if(grade>70){
System.out.println("良好");
}else if(grade>60){
System.out.println("合格");
}else{
System.out.println("不及格");
}
}
}
3.2.2switch语句
Switch语句由一个控制表达式和多个case标签组成，表达式的数据类型只能是byte、short、int、char四个整数类型和枚举类型（jdk1.7以后，可以是字符串）。

Ex:
int i = 2;
switch (i) {
case 1:
System.out.println("这个数字是1");
break;
case 2:
System.out.println("这个数字是2");
break;
case 3:
System.out.println("这个数字是3");
break;
default:
System.out.println("其他数字");
}
练习：给定一个年月日。

利用switch/case语句计算一年的第几天。

循环语句可以在满足循环条件的情况下，反复执行某一段代码，被重复执行的代码段称为循环体，在反复执行循环体的时候，需要在合适的情况下将条件改为假，否则循环将一直执行下去，形成可怕的死循环。

3.3.1 while循环
当while条件为真（true）时，执行循环体中的代码
举例：
Public class Test {
public static void main(String[] args) {
int count = 1;
while(count<10){
System.out.println("当前值为："+count);
count++;
}
}
}
死循环：
While(1 == 1){
System.out.println(“这是死循环”);
}
3.3.2 do while循环
do代码段中为循环体，先执行循环体中的代码，然后再去判断条件是否为真（true），如果为真再执行do代码段中的循环体。

（不管怎样，do中的代码至少执行了一次）。

举例2：
public class TestCar {
public static void main(String[] args) {
int count = 1;
do {
System.out.println("当前的数值为："+count);
count++;
} while (count<10);
}
}
For循环体是更加简洁的循环语句，在大部分情况下for循环可以代替while循环、do while 循环。

for(定义变量; 条件；循环结束进行的代码){
循环体
}
ex：
public class Test {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
System.out.println("执行第"+i+"次执行循环");
}
}
}
ex:循环的嵌套
打印如下图形
*
**
***
****
*****
public class Test {
public static void main(String[] args) {
for (int i = 1; i < 6; i++) {
for (int j = 0; j < i; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
3.3.4循环控制的三个关键字
3.3.
4.1 break关键字
break关键字的作用是结束当前循环，执行循环体下面的代码。

Ex：
public class Test {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
if(i == 4){
System.out.println("循环结束");
break;
}
System.out.println("执行第"+i+"次循环");
}
System.out.println("循环结束后的代码");
}
}
3.3.
4.2 continue关键字
continue关键字的作用：结束本次循环，立即进行下一次循环。

public class Test {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
if(i == 4){
System.out.println("这次循环结束");
continue;
}
System.out.println("执行第"+i+"次循环");
}
System.out.println("循环结束后的代码");
}
}
3.3.
4.3 return 关键字
return关键字的作用：跳出当前方法，return后面的语句全部不执行！public class Test {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
if(i == 4){
System.out.println("这次循环结束");
return;
}
System.out.println("执行第"+i+"次循环");
}
System.out.println("循环结束后的代码");
}
}
3.4数组类型
数组是编程语言中最常见的一种数据结构，可以存储多个数据，每个数组元素存放一个数据，通过数组元素的索引（或者称为下标index）来访问数组元素。

数组也是一种类型，它是引用类型。

3.4.1数组的写法
（1）int [] i = { }; //公司代码规范
ex：int[] I = {1,2,3,4}; //数据之间用逗号隔开，只能装int类型的数。

（2）int [] i = new int [] {1,2,3,4};
（3）int [] i = new int [9]; //9代表数组的长度
3.4.2 数组的使用
访问数组中的某个元素要使用下标(下标的起始数字为0),.ex: i[0];访问数组的第一个数ex: 打印一个数组的所有元素
public class Test {
public static void main(String[] args) {
int [] array = {1,2,3,4,5,6,7,8,9};
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
3.4.3多维数组
二维数组
int [] i = { {1,2}, {3,4}, {5,6}};
想要获取4，i[1][1];
ex：使用两层for循环生成一个，30X30的二维数组，使得每一位上都是1.
public class Test {
public static void main(String[] args) {
//定义一个二维数组
int [][] array = new int[30][30];
//第一层数组
for (int i = 0; i < 30; i++) {
//第二层数组
for (int j = 0; j < 30; j++) {
array[i][j] = 1;
}
}
//取出每个数
for (int i = 0; i < 30; i++) {
for (int j = 0; j < 30; j++) {
System.out.print(array[i][j]);
}
System.out.println();
}
}
}
第四章：面向对象（Object Oriented）
面向对象：一切都是对象。

面向对象也可以说是从宏观方面思考问题，而面向过程可以说是从细节处思考问题。

在面向对象中，也存在面向过程。

举个例子，盖一座大楼，你想到的是楼怎么盖，哪里要有柱子，哪里要有梁，哪里楼梯等等（这就是面向对象），至于柱子该怎么建，用什么建，方的圆的，等等，这就是面向过程。

用面向对象思考问题更符合我们人的思考方式。

面向对象的三大特征：封装、继承、多态。

使用了这三种设计方法的语言称之为面向对象语言。

JAVA是面向对象的程序设计语言，Java语言提供了定义类（class）、属性（Field）、方法（method）等最基本的功能。

类是之中自定义类型的数据类型。

所有使用类定义的变量都是引用变量，变量都指向一个具体的类的对象。

4.1类（class）和对象（一类东西具体的表现）
面向对象的程序设计过程中有两个重要概念：类（class）和对象（object），其中类是某一批对象的抽象，可以把类理解成某种概念。

比如：车跟宝马就是类与对象的关系，车是类，宝马是具体的对象。

'
4.1.1 类
类的定义：类是对具有形同属性和相同行为的对象的抽象。

例：张三、李四、王五三个人，他们三个人都是学生，这样学生就可以作为一个类，而具体的每一个人都是类衍生出来的。

简单粗暴理解：代码编写的地方，即java的代码组织单元。

类名首字母大写。

类里面能写什么？
1.属性Field（全局变量，成员变量，成员）int a = 0；这里a即为属性
2.方法method public void f1(){} 即为一个方法
3.代码块{ }之内的
4.内部类class B{} 在一个class中继续写另一个class
ex：定义了一个类Person（人），人有手，能吃饭。

public class Person {
//属性手
String hand;
//方法能吃饭
public void eat(){
//代码块
System.out.println("我是方法eat");
}
//内部类
class child{
}
}
4.1.2对象
对象的定义：一个类的实例化。

如果想要调用一个类中的方法、属性，必须要有这个类的对象，然后对象名.方法名或对象名.属性名。

要想产生一个类的对象，使用new操作符，Test test = new Test();
ps: java中的抽象数据类型其实就是一个类。

public class Person {
//属性手
char hand = '手';
//方法能吃饭
public void eat(){
//代码块
System.out.println("我是方法eat");
}
public static void main(String[] args) {
//要想调用eat方法，必须有一个这个类的对象
Person person = new Person();
//方法的调用
person.eat();
//属性的调用
System.out.println(person.hand);
}
}
4.2方法
4.2.1 方法的格式
修饰符public (可以没有，但是最好有)
返回值这个方法运行完返回的结果的类型。

没有写void
ps：如果一个方法有返回值，方法中必须有return关键字
方法名(形参) f1（形参）形参没有可以不写。

形参：调用这个方法需要传递一些值给这个方法，这个方法才能够使用。

传递过来的值就叫做形式类型参数。

简称形参。

ps：如果一个方法有形参，调用这个方法，一定要传递相应的参数。

ex：//没有返回值，没有形参
public void f1(){
}
//有返回值和形参的方法的定义和调用
public class Test {
// 方法有返回值，有形参。

public int add(int a, int b) {
return a + b;
}
public static void main(String[] args) {
// Test类的对象
Test test = new Test();
//调用add方法
int result = test.add(3, 4);
System.out.println("结果为"+result);
}
}
特殊：在同一个类中两个方法的互调。

public class Test {
public void f1(){
System.out.println("方法f1");
f2();
}
public void f2(){
System.out.println("方法f2");
f1();
}
public static void main(String[] args) {
Test test = new Test();
test.f1();
}
}
执行一段时间后会抛出异常。

Exception in thread "main" ng.StackOverflowError main线程栈溢出错误，进行避免这种形式。

4.2.2方法的重载
定义：方法名形同，形式参数列表不同。

1.个数不同。

2位置不同。

3类型不同。

ex：方法的重载。

public class Test {
public void f1(){
System.out.println("无参数的f1");
}
public void f1(int i){
System.out.println("一个int类型的f1");
}
public void f1(int i,int j){
System.out.println("两个int类型的f1");
}
public void f1(double d){
System.out.println("double类型的f1");
}
public void f1(int i,double d){
System.out.println("int double 的f1");
}
public void f1(double d,int i){
System.out.println("double int 的f1");
}
public static void main(String[] args) {
Test test = new Test();
test.f1(1,2);
}
}
在main方法中调用f1方法，传递不同的参数，自动调用不同的代码。

ps：方法的重载只与形参有关，和返回值无关。

4.2.3 static关键字
如果一个方法或属性被static修饰了，那么这个方法就属于类，而不属于对象，可以类名点方法名直接调用。

4.2.4 方法调用举例。

（String类）
我们前面学过8种基本数据类型，抽象数据类型中，有一个String类。

用法：String s = “Hello,World”;
String s1 = new String(“”);
常用方法：
1.charAt（）；
pareTo（）；
pareToIgnoreCase（）；
4.concat（）；
5.contains（）；
6.endsWith（）；
7.indexOf（）；
stIndexOf（）；//判读一个字符串中是否只出现了一次
9.replace（）
10.toUpperCase（）/ toLowerCase（）；
11.subString（）；
12.trim（）；
13.split（）；
14.equals（）；
ex:前十三个方法都比较简单，这里着重讲一下equals方法！
public class Test {
public static void main(String[] args) {
String s1 = "abc";
String s2 = "abc";
String s3 = new String("abc");
String s4 = new String("abc");
System.out.println(s1 == s2);
System.out.println(s1 == s3);
System.out.println(s3 == s4 );
System.out.println(s1.equals(s2));
System.out.println(s1.equals(s3));
System.out.println(s1.equals(s4));
}
}
堆栈的概念：
堆：存放程序所使用的数据
栈：存放程序的操作，变量，对象，常量。

String s1 = “abc”; //abc字符串放到常量池中，s1放到栈中，引用abc String s2 = “abc”; //发现常量池中已经才能在“abc”，直接引用
String s3 = new String(“abc”); //创建一个对象
String s4 = new String(“abc”); //重新创建一个对象
ps：1.只要碰到new关键字，就会在堆内存中开辟新的空间，不会出现复用。

2.基本数据类型使用==判断是字面值是否相同，而抽象数据类型使用==判断的是引用是否相同。

4.3变量
1. 全局变量：直接写到类中。

2. 局部变量：写在方法中。

ex：全局变量
public class Test {
int i;
public void f1(){
System.out.println(i);
}
}
ex：局部变量
public class Test {
public void f1(){
int i;
System.out
}
}
报错：The local vaviable i may not have been initialized
i可能没有被初始化。

成员变量可以不赋初值，局部变量不赋初值不报错，但是一用就报错。

4.4封装和隐藏
4.4.1 理解封装
封装是面向对象的三大特征之一，它指的是将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象的内部信息，而是通过该类所提供的方法来实现对内部信息的操作和访问。

封装可以实现以下目的：
1、隐藏类的实现细节
2、使用者只能通过提供的方法来访问数据，从而可以在方法中加入控制逻辑，限制对变量的不
合理的访问。

3、可进行数据检查，从而有利于保证对象信息的完整性。

4、便于修改，提高代码的可维护性。

封装的实际含义就是该隐藏的隐藏，该暴漏的暴漏。

4.4.2 package import
Oracle公司提供的JDK、各种软件厂商、众多的开发商，会提供成千上万、具有各种用途的类，那么类名肯定会出现同名的这种情况，为了处理重名问题，Java引入了包（package）机制，提供了类的多层命名空间，用于解决类的命名冲突、类文件管理问题。

Java源文件中使用了pageckage语句，就意味着该源文件里定义的所有类属于这个包下。

位于包中的每个类的完整类名都应该是包名和类名的组合。

java中定义的规范：
类名：首字母大写
方法/变量：首字母小写
如果遇到多个单词，无论类名还是方法名和变量名，一律使用驼峰命名法。

包名：域名后缀.公司名.项目名.模块名.类名
com.baidu.video.play 百度的视频项目的play模块
为了简化编程，Java引入了import关键字，import可以向某个Java文件中导入指定包层次下的某个类或全部类，import语句出现在package语句之后，类定义之前。

ex：java中的Scanner类
package com.handson.test;
//我们在main方法中使用的Scanner类，java公司给我们提供，存放在util这个包中
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
System.out.println(n*n);
}
}
ps:使用import语句后，new一个类的对象时，产生的对象是，导入包中的类。

要想在同一个类中调用不同包中的同名类怎么办？使用类的全名称。

例：下图是不同包中的两个同名类和一个测试类。

包com.baidu.test1中的代码
package com.baidu.test1;
public class A {
public void f1(){
System.out.println("1包中的f1方法");
}
}
包com.baidu.test2 中的代码
package com.baidu.test2;
public class A {
public void f1(){
System.out.println("2包中的f1方法");
}
}
测试类Go的代码。

package com.baidu.go;
//导入了包1中的类A
import com.baidu.test1.A;
public class Go {
public static void main(String[] args) {
A a = new A();
a.f1();
com.baidu.test2.A b = new com.baidu.test2.A();
b.f1();
}
}
ps: 1.有包的类看不到没包的类，即default package中的类，无法被调用。

2.所有的java类，默认导入了ng 这个包
技巧：1.在敲类名的时候，按下快捷键（ctrl+shift+o），选择需要的类，可以快速导包。

在这里规定一下各种名词的写法。

a．类名：首字母大写
b．变量名：首字母小写
c．如果遇到多个单词，无论类名方法名还是变量名，都要一律使用驼峰命名法：即多个单词，单词字母大写。

4.4.3 访问控制
一共四种修饰符：
（1）public 任何类都可见
（2）protected 当前包中可见
（3）不写（缺省）当前包中可见
（4）private 当前类中可见
访问修饰符能够修饰：类，方法，属性
验证例子：
//这个类存放所有的变量
package com.baidu.test3;
public class Test {
public int i = 3;
int a = 10;
protected int c= 20;
private int d = 40;
}
//这个类用来验证，可以在不同的包下来进行验证
package com.baidu.test3;
public class Go {
public static void main(String[] args) {
Test test = new Test();
System.out.println(test.a);
System.out.println(test.c);
System.out.println(test.i);
}
}。