java基础
Java平台应用
Java简洁：
Java归属于Orcale公司
Java SE：基础和核心版本版本-->
Java EE
Java ME
核心概念：JVM、JDK、JRE
JVM:Java虚拟机；跨平台通过JVM实现的
源代码：xx.java-->编译器（相当于菜刀）-->字节码文件.class-->解释器-->执行
买回来的鱼-->杀鱼-->得到处理后的鱼-->红烧-->可以吃的鱼
JDK：Java Development Kit（Java开发工具包）
JRE：Java Runtime Envionment(Java运行时环境）
JDK包含JRE，JRE包含JVM
搭建Java开发环境
(1) 第一步：安装JDK（下载并安装JDK文件）
bin目录下是一些可执行文件（包含了java和javac）
lib目录下是库文件
(2) 第二步：配置环境变量
JAVA_HOME ：配置JDK安装路径
PATH ：配置JDK命令文件的位置(bin目录）
CLASSPATH ：配置类库文件的位置（lib目录）
配置JAVA_HOME：右击计算机-->属性-->高级系统设置-->高级-->环境变量-->系统变量-->新建(名称：JAVA_HOME，路径：安装路径）
配置PATH：右击计算机-->属性-->高级系统设置-->高级-->环境变量-->系统变量-->在PATH路径中添加bin路径
配置CLASSPATH：右击计算机-->属性-->高级系统设置-->高级-->环境变量-->系统变量-->新建(名称：CLASSPATH，路径：安装路径）
验证是否安装成功：CMD-->输入java-->输入javac（若给出java提示，则说明已经配置成功）
使用工具开发Java程序
创建一个java文件：新建一个txt，修改文件名为HelloWorld.java
编辑java源代码文件:
public class HelloWorld {//类名必须与文件名相同
public static void main(String[] args){
System.out.println("Welcome to imooc.")
}
}
public 类的修饰符
main 程序的入口
HelloWorld必须与文件名相同
编译器编译：CMD打开命令行-->切换到HelloWorld.java文件所在目录-->javac HelloWorld.java
解释器执行：java HelloWorld（不需要后缀名）
经验技巧分享
Eclipse开发Java程序
集成开发环境（IDE）是一类软件，将程序开发环境和程序调试环境集合咋一起，提高开发效率
使用Eclipse开发Java程序
1、创建Java项目
为什么创建工程：一个工程会包含多个文件
文件-->new–>Java Project
文件包含在工程的src文件中
2、创建程序包
右键src-->new-->package包名（如com.imooc）
3、编写Java源程序
在包名下新建文件名
new-->class-->输入文件名–>编写代码
System.out.println(注意System第一个字母大写)
4、运行Java程序(IDE工具自动完成了编译)
run as–>java ...
程序的移植（程序的导出和导入）
将文件拷贝出来
右键-->import-->已存在的项目-->browse查找到对应的文件-->点击打开
经验技巧分享
多练；多问；自己动手调试错误；复习和总结
2.1 Java中的关键字
2.2 认识Java标识符
标识符就是用于给Java程序中变量、类、方法等命名的符号
使用标识符的时候，需要遵守几条规则：
标识符可以由字母、数字、下划线(_)、美元符号($)组成，单不能包含@、%、空格等其他特殊字符，不能以数字开通
标识符不能是Java关键字和保留字（Java预留的关键字，以后的升级版本中有可能做为关键字），单可以使用以包含关键字的保留字。
标识符是严格区分大小写的
标识符的命名最好能反映出其作用，做到见名知意
2.3 变量是什么
简单的说，我们可以把变量看作是个盒子，可以将钥匙、手机、饮料等物品存放到这个盒子中，页可以在需要的时候换成我们想存放的新物品。
在Java中，我们通过三个元素描述变量：变量类型、变量名和变量值
如果我们把变量比作是酒店的房间，要存储的数据就好比要住宿的客人，我们可以根据客人的要求安排其入住“标准间”或者“总统套房”，并且可以根据房间名字快速查找到入住客人的信息。同理，在Java程序中，我们也可以根据所需要保存的数据的格式，将其保存在指定类型的便年来那个空间中，并且通过变量名快速定位。
2.4 如何命名Java变量
如同酒店会给每个房间起个性化的名字一样，程序中的变量也需要用合理的名字进行管理–变量名。需要注意，给酒店房间起名字的时候可以使用数字如“802”，也可以使用有趣的名字，如“牡丹”等，但给变量起名字时，必须符合一定的规则，如下
变量名由多单词组成时，第一个单词的首字母小写，其后单词的首字母大写，俗称骆驼式命名法，如myAge
变量命名时，尽量间断且能清楚的表达变量的作用，做到见名知意
Java变量名的长度没有限制，但Java语言是区分大小写的，所以price和Price是两个完全不同的变量
2.5 Java中的数据类型
通常情况下，为了方便物品的存储，我们会规定每个盒子可以存放的物品种类，就好比在“放臭袜子的盒子”里我们是不会放“面包”的。同理，变量的存储也将就“分门别类”。
Java语言是一种强类型语言，通俗点说就是，在Java中存储的数据都是有类型的，而且必须在编译时就确定其类型，Java中有两类数据类型
数据类型：基本数据类型（数值型：整数类型/浮点类型 + 字符型 + 布尔型） + 引用数据类型（类 + 接口 + 数组）
在Java的领域里，基本数据类型变量存的是数据本身，而引用类型变量存的是保存数据的空间地址。说明了，基本数据类型变量里存储的是直接放在抽屉里的东西，而引用数据类型变量里存储的是这个抽屉的钥匙，钥匙和抽屉一一对应。
关于float型和double型的区别，以及char型和String型的不同，在wiki中有相关的总结，小伙伴们可以取查看。
String是一种常见的引用数据类型，用来表示字符串。在程序开发中，很多操作都要使用字符串来完成，例如系统中的用户名、密码、电子邮箱等。
package com.pajk.l1;
public class HelloWorld {
public static void main(String[] args){
String name = "爱慕课";
String sex = "男";
int num = 18;
float price = 120.5f;
boolean isOK = true;
System.out.println(name);
System.out.println(sex);
System.out.println(num);
System.out.println(price);
System.out.println(isOK);
}
}
2.6 Java中变量的使用规则
1、Java中的变量需要先声明后使用
2、变量使用时，可以生命变量的同时进行初始化
3、变量中每次只能赋一个值，单可以修改多次
4、main方法中定义的变量必须先赋值，然后才能输出
5、虽然语法中没有提示错误，但在实际开发中，变量名不建议使用中文，容易产生安全隐患，譬如后期跨平台操作时出现乱码等
2.7 Java中的自动类型转换
在Java程序中，不同的基本数据类型的数据之间经常进行想换转换，例如
int score1 = 82
double score2 = score1
System.out.println(score2)
代码中int型变量score1可以直接为double型变量score2完成赋值操作，运行结果为82.0
这种转换称为自动类型转换
当然自动类型转换是需要满足特定条件的：
1、目标类型能与源类型兼容，如double型兼容int型，但是char型不能兼容int型
2、目标类型大于源类型，如double类型长度为8字节，int类型为4字节，因此double类型的变量里直接可以存放int类型的数据，但反过来就不可以了。
2.8 Java中的强制类型转换
相信小伙伴们也发现了，尽管自动类型转换是很方便的，但并不能满足所有的编程需要。例如当程序中需要将double型变量赋值给一个int型变量，该如何实现呢？显然这种类型是不会自动进行的，因为int型的存储范围比double型的小，此时就需要通过强制类型转换来实现了。
语法：(数据类型)数值，如
double avg1 = 78.5
int avg2 = (int) avg1
可以看到，通过强制类型转换将78.5赋值给int型变量后，结果为78，数值熵并未进行四舍五入，而是直接将小数位阶段。强制类型转换会造成数据的丢失。
2.9 Java常量的应用
所谓常量，可以理解为是一种特殊的量，它的值被设定后，在程序运行过程中不允许改变。语法：final 常量名 = 值，如final double PI = 3.14
程序中使用常量可以提高代码的可维护性。例如在项目开发时，我们需要指定用户的性别，此时可以定义一个常量Sex，赋值为“男”，在需要指定用户性别的地方直接调用此常量即可，避免了由于用户的不规范赋值导致程序出错的情况。
注意：常量名一般使用大写字符
2.10 如何在Java中使用注释
在编写程序时，经常需要添加一些注释，用以描述某段代码的作用。一般来说，对于一份规范的程序源代码而言，注释应该占到源代码的1/3以上。因此，注释是程序源代码的重要组成部分，一定要加以重视。Java中注释有三种类型：单行注释、多行注释、文档注释。
使用文档注释时还可以使用javadoc标记，生成更详细的文档信息：
@author 表明开发该类模块的作者
@version 表明该类模块的版本
@see 参考转向，也就是相关主题
@param 对方法中某参数的说明
@return 对方法返回值的说明
@exception 对方法可能抛出的异常进行说明
3.1 什么是运算符
运算符是一种“功能”符号，用以通知Java进行相关的运算。譬如，我们需要将变量age的值设置为20，这是就需要一个“=”，告诉程序需要进行赋值操作。
Java语言中常用的运算符可分为如下几种：
算术运算符
赋值运算符
比较运算符
逻辑运算符
条件运算符
3.2 Java中的算术运算符
算数运算符主要用于进行基本的算术运算，如加法、减法、乘法、除法等。
Java中常用的算术运算符有：
-
-
- / % ++ --
-
其中，++和–可以出现在操作数的左边，页可以出现在右边，单结果是不同的。例如：
int a = 5;
int b = ++a; 让a先进行自增，然后再赋给b
int c = a++; 将a先赋给c，然后再自增
注意：自增和自减运算符只能用于操作变量，不能直接用于操作数值或常量。例如5++、8–等写法都是错误的。
%用于求余，页成为“取模运算符”
3.3 Java中的赋值运算符
赋值运算符是指为变量或常量指定数值的符号。如可以使用“=”将右边的表达式结果赋给左边的操作数。
Java支持的常用赋值运算符，有：
=
+=
-=
*=
/=
%= ： c%=a等价于c=c%a
3.4比较运算符
比较运算符用于判断两个数据的大小，例如：大于、等于、不等于。比较结果是一个布尔值（true或false）
Java常用的比较运算符如下所示：
< >= <= ：只支持左右两边操作数是数值类型
== !=：两边操作数既可以是数值类型，页可以是引用类型。
3.5逻辑运算符（逻辑运算符的短路处理）
逻辑运算符主要用于进行逻辑运算。Java中常用的逻辑运算符如下表所示：
&& 与操作 a&&b a与b都为true，则返回true
|| 或操作 a||b a与b任一true，则返回true
！ 非操作 !a 如果a为false，则返回true
^ 异或操作 a&&b a与b仅有一个为true，则返回true
当使用逻辑运算符时，会遇到一个“短路”现象，如(one>two) && (one<three)中，如果能确定左边one>two运行结果为false，则系统就认为已经没有必要执行右侧的one<three。
同理，在(one>two) || (one<three)中，如果已经能确定左边表达式的运行结果为true，则系统也同样认为已经没有必要再进行右侧的one<three的执行。
3.6 Java中的条件运算符
条件运算符(?:)也称为“三元运算符”。
语法表达式：布尔表达式?表达式1:表达式2
例如：
String str = (8>5) ? "8大于5" : "8不大于5"
System.out.println(str);
3.7 Java中运算符的优先级
Think in Java中有说明名，不需要去死记硬背，若无法准确判断优先级，则可以使用括号进行辅助。
4.1 Java条件语句之if
生活中，我们经常需要先做判断，然后才决定是否要做某件事情。例如，如果考试成绩大于90分，则奖励一个Iphone。对于这种“需要先判断条件，条件满足后才执行的情况”，就可以使用if条件语句实现。
注意：如果条件成立时的执行语句只有一条，是可以省略大括号的；如果执行语句有多条，则大括号是不可或缺的。
4.2 Java条件语句之if...else
if...else语句的操作比if语句多了一步：当条件成立时，则执行if部分的代码块；条件不成立时，则进入else部分。例如，如果考试成绩大于90分，则奖励一个Iphone，否则做500个俯卧撑。
4.3 Java条件语句之多重if
在条件1不满足的情况下，才会进行条件2的判断；当前面的条件均不成立时，才会执行else块内的代码。例如，如果考试成绩大于90分，则奖励一个Iphone；如果成绩介于70分到90分之间，则奖励一个小米，否则乘法做500个俯卧撑。
4.4 Java条件语句之嵌套if
嵌套的if，只有当外层if的条件成立时，才会判断内层if的条件。例如，活动计划的安排，如果今天是工作日，则去上班，如果今天是周末，则外出游玩；同事，如果周末天气晴朗，则取室外游乐场玩，否则去室内游乐场玩。
4.4 Java条件语句之switch
当需要对选项进行等值判断时，使用switch语句更加简洁明了。例如：根据考试的名次，给与前4名不同的奖品。第一名奖励一台笔记本，第二名建立一个ipad，第三名奖励一个移动电源，第四名奖励一个u盘。
switch(表达式){
case 值1:
执行代码块1
break;
case 值2:
执行代码块2
break;
default:
模型执行的代码
}
注意：
1、switch后面的小括号中表达式的值必须是整形或者字符型
2、case后面的值可以是常量数值，如1、2；也可以是一个表达式，如2+2；但不能是变量或带有变量的表达式，如a+2
3、case匹配后，执行匹配块里的程序代码，如果没有遇见break，会继续执行下个case块的内容，直到遇到braak语句或者switch语句块结束。
4、可以把功能相同的case语句合并起来，如：
case 1:
case 2: System.out.println(“奖励ipad一个”)
5、default块可以出现在任一位置，也可以省略。
注意：Java中双引号和单引号是有区别的
String a = "天" a是字符串类型
char a = '天' a是字符类型
4.6 Java循环语句之while
生活中，有些时候为了完成任务，需要重复的进行某些动作。如参加10000米长跑，需要绕40米的赛道反复的跑25圈。在Java中实现功能时，也经常需要重复执行某些代码，例如，我们为了表示“浓烈的爱”，希望输出1000行“我爱慕课网”。显然，此时重复敲1000遍输出语句是不靠谱的，这时候便可以使用循环语句来完成。Java常用的3中循环语句有while、do...while、for，本节主要介绍while。
语法：
while(判断条件){
循环操作
}
执行过程：
1、判断while后面的条件是否成立（true/false）
2、当条件成立时，执行循环内的操作代码；重复执行判断和循环操作，到循环条件不成立为止。
特点：先判断，后执行
4.7 Java循环语句之do...while
do...while循环与while循环语法有些类似，但执行过程差别比较大。
语法：
do {
循环操作
} while(判断条件)；
1、先执行一遍循环操作，然后判断循环条件是否成立
2、如果循环条件成立，继续执行循环操作，然后执行判断条件，直到循环条件不成立为止。
特点：先执行，后判断。
由此可见，do...while语句保证循环至少被执行一次。
4.8 Java循环语句之for
Java的循环结构中除了while和do...while外，还有for循环，三种循环可以相互替换。
语法:
for(循环变量初始化;循环条件; 循环变量变换){
循环操作
}
执行过程：
1、执行循环变量初始化部分，设置循环的初始状态，此部分在整个循环中只执行一次
2、进入循环条件的判断，如果条件为true，则执行循环体内代码；如果为false，则直接退出循环
3、执行循环变量变化部分，改变循环变量的值，以便进行下一次条件判断
4、一次重新执行2、3、4，直到推出循环
特点：相比while和do...while语句结构更加简洁易懂
需要留意的几个小细节：
1、for关键字后面括号中的三个表达式必须用";"隔开，三个表达式都可以省略，但";"不能省略
2、for循环变量初始化和循环变量变化部分，可以使用","同时初始化或改变多个循环变量的值，如：
for(int i = 1, j = 5; i<=5; i++, j–){循环语句}
3、循环条件部分可以使用逻辑运算符组合的表达式，表示复杂判断条件，但一定要注意运算的优先级，如
for(int i = 1, j = 5; i<=5 && j>=2; i++, j–){循环语句}
4.9 Java循环跳转语句之break
生活中我们经常会因为某些原因中断既定的任务安排。如在参加10000米长跑时，才跑了500米就由于体力不支，需要退出比赛。在Java中，我们可以使用break语句退出指定的循环，直接执行循环后面的代码。
例如，使用循环输出1–10的数值，其中如果数值大于2，并且为3的倍数，则停止输出。
4.10 Java循环跳转语句之continue
continue的作用是跳过循环体中剩余的语句执行下一次循环。
例如，打印1–10之间所有的偶数，使用continue语句实现代码为：
for (int i = 1; i<=10; i++){
if(i % 2 != 0) continue; // 通过continue结束本次循环，直接进行下一次循环。
System.out.println(i);
}
4.11 Java循环语句之多重循环
循环体中包含循环语句的结构称为多重循环。三种循环语句可以自身嵌套，页可以相互嵌套，最常见的就是二重嵌套。在二重嵌套中，外层循环每执行一次，内存循环要执行一圈。
package com.****.l1;
public class HelloWorld {
public static void main(String[] args){
String name = "爱慕课";
String sex = "男";
int num = 18;
float price = 120.5f;
boolean isOK = true;
System.out.println(name);
System.out.println(sex);
System.out.println(num);
System.out.println(price);
System.out.println(isOK);
double avg1 = 78.5;
int rise = 5;
double avg2 = avg1 + rise;
System.out.println("调整后的平均分为: "+ avg2);
int avg3 = (int)avg1 + rise;
System.out.println("调整后的平均分为: "+ avg3);
int a = 12;
int b = 24;
int sum1 = a + b;
System.out.println("两数之和: "+ sum1);
int age1 = 24;
int age2 = 18;
int age3 = 36;
int age4 = 27;
int sum2 = age1 + age2 + age3 + age4;
float avg4 = sum2 / 4;
int minus1 = age1 - age2;
int newage = --age1;
System.out.println("年龄总和" + sum2);
System.out.println("平均年龄" + avg4);
System.out.println("年龄差值" + minus1);
System.out.println("自减后的年龄" + newage);
int score = 68;
String mark = (score>=60)? "及格":"不及格";
System.out.println(mark);
System.out.println(35/4);
int age = 25;
if (age>60) System.out.println("老年");
else if (age<=60 && age>40) System.out.println("中年");
else if (age<=40 && age>18) System.out.println("少年");
else System.out.println("童年");
int score1 = 94;
String sex1 = "女";
if(score1 > 80){
if (sex1 == "女") System.out.println("进入女子决赛组");
else System.out.println("进入男子决赛组");
}
else System.out.print("未进入决赛组");
char today = '日';
switch(today){
case '二':
case '四':
case '六': {
System.out.println("吃油条");
break;
}
case '一':
case '三':
case '五':{
System.out.println("吃包子");
break;
}
default:
System.out.println("吃总统套餐");
}
// 4.7 do...while
int sum7 = 0;
int num7 = 2;
do{
sum7 += num7;
num7 += 2;
}while(num7<=50);
System.out.println("50以内的偶数之和为:" + sum7);
//4.8 for 语句
int sum8 = 0;
for (int i=1; i<=100; i++) {
if(i%3>0) sum8 += i;
}
System.out.println("1到100之间不能被3整除的数之和为:" + sum8);
//4.9
int sum9 = 0;
for(int i = 1; i<=10; i++) {
sum9 += i;
if (sum9 > 20) break;
}
System.out.println("当前的累加值为："+ sum9);
//4.11 嵌套循环
System.out.println("打印直角三角形");
for(int i = 1; i <=4; i++){
for(int j = 1; j<=i; j++){
System.out.print("*");
}
System.out.println(" ");
}
//4.12 判断一个数的位数
int num12 = 1;
int count = 0;
for (; num12>10; num12/=10) {
count = count + 1;
}
System.out.printf("它是个%d位的数", (count+1));
}
}
### 5.1 使用简单的循环语句
package com.pajk.l1;
public class l11 {
/*
*功能：为指定的成绩进行加分，直接分数大于60分为止
* 输出加分前的成绩和加分后的成绩，并且统计加分的次数
*/
public static void main(String[] args){
int score = 53;
int count = 0;
System.out.println("加分前的成绩:" + score);
while(score<60){
score ++;
count ++;
}
System.out.println("加分后的成绩"+score);
System.out.printf("共加分%d次",count);
}
}
### 5.2 使用Scanner类接收用户输入信息
package com.pajk.l1;
import java.util.Scanner;
public class l12 {
/*
*功能：为指定的成绩进行加分，直接分数大于60分为止
* 输出加分前的成绩和加分后的成绩，并且统计加分的次数
* 使用Scanner工具类来获取用户输入的成绩信息
* 步骤：
* 1、导入java.util.Scanner类
* 2、创建Scanner对象
* 3、接收并保存用户输入的值
*/
public static void main(String[] args){
Scanner input = new Scanner(System.in); //创建Scanner对象
System.out.print("请输入考试成绩信息:");
int score = input.nextInt(); //获取到成绩信息
int count = 0;
System.out.println("加分前的成绩:" + score);
while(score<60){
score ++;
count ++;
}
System.out.println("加分后的成绩"+score);
System.out.printf("共加分%d次",count);
}
}
### 5.3 断点执行
加入断点，执行debug，运行到断点后停止；
使用Step out（或者F8）单步执行
### 5.4 main函数自动补齐
Eclipse中为alt + \
IDEA中为“输入：psvm”
### 5.5 多重循环
package com.pajk.l1;
import java.util.Scanner;
public class l13 {
/*
*功能：实现接收三个班级的各四名学员的成绩信息，然后计算每个班级学院的平均分
* 知识点：二重循环，外层循环控制班级的数量，内层循环控制每个班级的学员数量
*/
public static void main(String[] args) {
int classNum = 3;
int stuNum = 4;
Scanner input = new Scanner(System.in);
for(int i = 1; i<=classNum; i ++){ //外层循环控制班级数量
double sum = 0;
double avg = 0; //成绩平均分
System.out.printf("******请输入第%d个班级的成绩******\n",i);
for(int j = 1; j<=stuNum; j++){
System.out.print("请输入第"+j+"个学生的成绩:");
int score = input.nextInt();
sum = sum + score;
}
avg = sum/stuNum;
System.out.println("第"+i+"个班级学生的平均分为:" +avg);
}
}
}
第二季
面向对象
1、对象的概念
2、什么是面向对象
3、类
4、什么是对象的属性
5、类和对象的关系/区别
什么是类和对象
买电话的过程可以理解为面向对象；电话就是对象；售货员让我描述电话的过程成为类；对类的描述（如大屏、双核等）称为类的属性。
类是对象的类型，具有相同属性和方法的一组对象的集合
对象的属性：对象有什么（如屏幕是5寸的，双核的）；对象能干什么（如打电话、发短信等）称为方法
类是抽象的概念，仅仅是模版；对象是一个你能够看得到、摸得着的具体实体。
如何定义Java中的类
类的组成：属性和方法
定义一个类的步骤：a. 定义类名（public class 类名{}）; b.编写类的属性；c.编写类的方法
public class Telphone{ //定义一个类
//属性（成员变量）有什么
float screen;
float cpu;
float mem;
//方法（干什么）
void call(){
System.out.println("Telphone有打电话的功能");
}
void sendMessage(){
System.out.println("Telphone可以发短信")
}
}
如何使用Java中的对象
使用对象的步骤：1.创建对象（类名 对象名 = new 类名（）； 将类实例化；类是以代码的形式放在文件中，将文件中的信息放入内存中，称为实例化）； 2.使用对象（对象名.属性()//属性也经常被称为实例变量; 对象名.方法()）
public class InitialTelphone{
public statia void main(String[] args){
Telphone phone = new Telphone();
phone.sendMessage();
phone.screen = 5.0f;
phone.cpu = 1.4f;
phone.mem = 2.0f;
phone.sendMessage();
}
}
1.5 成员变量和局部变量
作用域不同：
成员变量：在类中定义，用来描述对象将要有什么；成员变量的作用域在整个类内部都是可见的。
局部变量：在类的方法中定义，在方法中临时保存数据，定义在方法内部；只能在当前方法使用。局部变量的作用域仅限于定义它的方法
初始值不同：
局部变量要进行赋值，成员变量会默认初始化
在同一个方法中，不允许有同名局部变量；在不同方法中，可以定义相同的局部变量；
两类变量重名时，优先调用局部变量
1.6 构造方法
1、使用new+构造方法，创建一个新的对象
2、构造方法是定义在Java类中的一个用来初始化对象的方法
3、名称和类名相同，且无返回值
构造方法方法的语句格式： public 构造方法名(){//初始化代码}
无参的构造方法：当没有指定构造方法时，系统会自动添加无参的构造方法
有参的构造方法：给成员变量赋初值
当有指定的构造方法时，系统便不会再自动生成无参的构造方法
构造方法的重载：方法名相同，参数不同
构造方法不单可以给对象的属性赋值，还可以保证给对象的属性赋一个合理的值
1.7Java中的static使用之静态变量
大家都知道，我们可以基于一个类创建多个该类的对象，每个对象都拥有自己的成员，互相独立。然而在某些时候，我们更希望该类所有的对象共享同一个成员。此时就是static大显身手的时候了。
Java中被static修饰的成员变量称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。当然，鉴于它作用的特殊性更推荐用类名访问。
1.8Java中static使用之静态方法
与静态变量一样，我们页可以使用static修饰方法，称为静态方法或类方法。其实之前我们一直写的main方法就是静态方法。
注意：
1、静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员；如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。
2、在普通成员方法中，则可以直接访问同类的非静态变量和静态变量
3、静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法
1.9 Java中的static使用之静态初始化块
Java中可以通过初始化块进行数据赋值，如
public class HelloWorld{
String name;
{
name = "爱慕课";
}
}
在类的声明中，可以包含多个初始化块，当创建类的实例时，就会依次执行这些代码块。如果使用static修饰初始化块，就称为静态初始化块。
需要特别注意：静态初始化块只在类加载时执行，且只会执行一次，同事静态初始化块只能给静态变量赋值，不能初始化普通的成员变来那个。
封装
2.1 什么是Java中的封装
面向对象的三大特性：封装、继承和多态
封装就是将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
好处：只能通过规定的方法访问数据；隐藏类的实例细节，方便修改和实现（只关注类怎么使用，不关注类时怎么实现的）
3、封装的实现步骤：
修改属性的可见性（设为private）-->创建getter/setter方法（用于属性的读写）-->在getter/setter方法中加入属性控制语句（对属性的合法性进行判断）
2.2 使用包管理Java中的类
包的作用：管理Java文件；解决同名文件冲突
定义包：package包名（注：必须放在Java源程序的第一行；包名间可以使用“.”号隔开，如com.imooc.MyClass）
2.3 Java中的访问修饰符
2.4 Java中的this关键字
2.5 什么时Java中的内部类
内部类：定义在另外一个类里面的类。与之对应的时包含内部类的类被称为外部类。
为什么要将一个类定义在另一个类里面？或者说内部类的作用时什么？
1、内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中其他类访问该类
2、内部类的方法可以直接访问外部类的所有数据，包括私有的数据
3、内部类所实现的功能使用外部类哦他那个样可以实现，只是有时使用内部类更方便
内部类有几种？
1、成员内部类
2、静态内部类
3、方法内部类
4、匿名内部类
//外部类HelloWorld
public class HelloWorld {
// 内部类Inner，类Inner在类HelloWorld的内部
public class Inner {
// 内部类的方法
public void show() {
System.out.println("welcome to imooc!");
}
}
public static void main(String[] args) {
// 创建外部类对象
HelloWorld hello = new HelloWorld();
// 创建内部类对象
Inner i = hello.new Inner();
// 调用内部类对象的方法
i.show();
}
}
2.6 Java中的成员内部类
内部类中最常见的就是成员内部类，也被称为普通内部类。我们来看如下代码：
public class Outer {
private int a = 99; //外部类的私有属性
public class Inner { //定义内部类
int b = 2; //内部类中的成员属性
public void test(){
System.out.println("访问外部类中的a：" + a);
System.out.println("访问内部类中的b：" + b);
}
}
//测试成员内部类
public static void main(String[] args) {
Outer o = new Outer();
Inner i = o.new Inner();
i.test();
}
}
/*
1、Inner类定义在Outer类的内部，相当于Outer类的一个成员变量的位置，Inner类可以使用任意访问控制符，如public、protected、private等。
2、Inner类中定义的test()方法可以直接访问Outer类中的数据，而不受访问控制符的影响，如直接访问Outer类中的私有属性a
3、定义了成员内部类后，必须使用外部类对象类创建内部类对象，而不能直接去new一个内部类对象，即内部类 对象名=外部类对象.new 内部类();
4、编译上面的程序后，会产生两个.class文件，分别时外部类.class和外部类&内部类.class
*/
注意：
1、外部类不能直接使用内部类的成员和方法
2、如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用this关键字。如：
System.out.println("访问外部类中的b：" + Outer.this.b);
2.7 Java中的静态内部类
静态内部类static修饰的内部类，这种内部类的特点是：
1、静态内部类不能直接访问外部类的非静态成员，单可以通过 new 外部类().成员的方式访问
2、如果外部类的静态成员与内部类的成员名称相同，可以通过"类名.静态成员"访问外部类的静态成员；如果外部类的静态成员与内部类的成员明晨各不相同，则可通过"成员名"直接调用外部类的静态成员
3、创建静态内部类的对象时，不需要外部类的对象，可以直接创建 "内部类 对象名 = new 内部类();"
2.8 Java中的方法内部类
方法内部类就是内部类定义外外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用
一定要注意，由于方法内部类不能在外部类的方法意外的地方使用，因此方法内部类不能使用访问控制符和static修饰
集成
3.1 继成的概念
继成时类与类的一种关系，是一种“is a”的关系
java中的继承是单继承
继承的好处：子类拥有父类的所有属性和方法；实现代码复用
语法：class Dog extends Animal{...}
3.2 方法的重写
如果子类对继承父类的方法不满意，时可以重写父类继承的方法的，当调用方法时会优先调用子类的方法。
语法规则：a.返回值类型；b.方法名;c.参数类型及个数 都要与父类继承的方法先沟通那个，才叫方法的重写。
3.3Java中的继承初始化顺序
1、初始化父类再初始化子类
2、先执行初始化对象中的属性，再执行构造方法中的的初始化
父类对象-->父类属性初始化-->父类构造方法-->子类对象-->子类属性初始化-->子类构造方法
3.4 final关键字
使用final关键字做标识有“最终的”含义；可以修饰类、方法、属性和变量
final类：该类不允许被继承，此时该类就是最终的类
final方法：该方法不允许被覆盖（重写）
final属性：该属性不会进行隐式的初始化（类的初始化属性必须有值）或在构造方法中赋值（但只能选其一）
final变量：该变量的值只能赋一次值，即为常量
属性和变量的区别：属性：类中定义的，类需要有哪些属性；变量：方法中定义的，普通变量
如 public int age; //属性，表示类需要有age这个属性
int i; //方法中的变量，如for(int i = 0; i<100; i++)
3.5 super关键字
在对象的内部使用，可以代表父类对象。
1、访问父类的属性，如super.age
2、访问父类的方法，如super.eat()
super的应用：
1、子类构造的过程当中必须调用其父类的构造方法（隐式的使用了super关键字）
2、如果子类的构造方法中没有显示调用父类的构造方法，则系统默认调用父类无参的构造方法
3、如果显示的调用构造方法，必须在子类的构造方法的第一行
4、如果子类构造方法中既没有显示调用父类的构造方法，而父类又没有无参的构造方法，则编译报错
3.6 Object类
Object类时所有类的父类，如果一个类没有使用extends关键字明确标识继承另外一个类，那么这个类默认继承Object类。
Object类的方法，适合所有子类
1、toString()方法：在Object类里面定义toString()方法的时候返回对象的哈希code码（对象地址字符串）；可以通过重写toString方法表示出对象的属性
2、equals()方法：比较的时对象的引用是否指向同一块内存地址
Dog dog = new Dog() //对象在内存中的地址，操作地址的时候，相当于间接的操作了对象；比如操作遥控器（内存），相当于间接的操作了电视（对象）
equals比较的时两个对象指向的是否是同一个东西（你拿的这个手机是我的手机；对比的是对象的内存空间是否相同）
一般情况下比较两个对象是比较它们的值是否一致（你的手机和我的手机型号是一样的），所以要对equals进行重写
多态
4.1 Java中的多态
多态指的时对象的多种形态，包括引用多态和方法多态。
引用多态：父类的引用可以执行本类的对象；父类的引用可以指向子类的对象
方法多态：创建本类对象时，调用的方法为本类方法；创建子类对象时，调用的方法为子类重写的方法或者继承的方法
子类独有的方法，不能使用父类进行引用
4.2 引用类型转换
1、向上类型转换（隐式/自动类型转换），将小类型转换到大类型
2、向下类型转换（强制类型转换），将大类型转换到小类型（存在风险，可能会发生溢出）
3、instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题。
4.3 Java中的抽象类
语法定义：抽象类前使用abstract关键字修饰，则该类为抽象类
应用场景：
a、在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法；用于约束子类必须要有哪些方法，但不关注子类是怎么实现的
b、从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类做为子类的模版，从而避免了子类设计的随意性
作用：限制规定子类必须实现某些方法，单不关注实现细节
使用规则：
a、abstract定义抽象类
b、abstract定义抽象方法，只有声明，不需要实现
c、包含抽象方法的类是抽象类
d、抽象类中可以包含普通的方法，也可以没有抽象方法
e、抽象类不能直接创建，可以定义引用变量
Telphone tel1 = new CellPhone(); //抽象类的父类引用，指向一个子类对象
Telphone tel2 = new SmartPhone();
tel1.call();
tel1.message();
4.4 接口
接口的概念：接口可以理解为一种特殊的类，由全局变量和公共的抽象方法所组成
类是一种具体实现体，而接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。
接口定义：和类定义不同，定义接口不再使用class关键字，而是试用了interface关键字
接口定义的基本语法：
[修饰符] abstract interface 接口名[extends 父接口1, 父接口2, ...]{
零个到多个常量定义...
零个到多个抽象方法定义...
}
接口就是用来被继承、被实现的，修饰符一般建议用public，不能使用private和protected修饰接口
接口可以继承多个父接口[extends ...]时可选的
常量：接口中的属性时常量，即使定义时不添加public static final修饰符，系统也会自动加上。
方法：接口中的方法都是抽象方法；不能有方法体
使用接口：一个类可以实现一个或多个接口，实现接口使用implements关键字。Java中一个类只能继承一个父类，是不够灵活的，通过实现多个接口可以做补充
继承父类实现接口的语法为：
[修饰符] class 类名 extends 父类 implements 接口1，接口2...
{
类体部分//如果继承了抽象类，需要实现抽象类的方法；要实现接口中的抽象方法
}
如果要继承父类，继承父类必须在实现接口之前（extends和implements是不能调换的）
接口在使用过程当中，还经常与匿名内部类配合使用。
匿名内部类：没有名字的内部类，多用于关注实现而不关注实现类的名称。
匿名类的语法格式：
Interface i = new Interface(){
public void method(){
System.out.println("匿名内部类实现接口的方式")
}
}
4.6 UML简洁
1、UML概念：Unified Modeling Language又称统一建模语言或标准建模语言
是一个支持模型化和软件系统开发的图像化语言；为软件开发的所有阶段提供模型化和可视化支持
2、UML2.2 中一共定义了14中图示（diagrams）
3、常用那个UML图
用例图（The Use Case Diagram）：用例图能够以可视化的方式，表达系统如何满足所收集的业务规则，以及特定的用户需求等信息。
如在餐馆里面，用户可以吃东西（吃什么东西）；厨师可以做出吃的，中间是功能
序列图（The Sequence Diagram）：序列图用于按照交互发生的一系列顺序，显示对象之间的这些交互。
Java入门第三季
2、认识Java中的字符串
2.1 什么是Java中的字符串
在程序开发中字符串无处不再，如用户登陆时输入的用户名、密码等使用的就是字符串。其实，在前面的章节中我们就已经使用了字符串，例如我们在控制台中输出的“Hello World”、“imooc”、“爱慕课”等。
在Java中，字符串被做为String类型的对象处理。String类位于java.lang包中。默认情况下，该包被自动导入所有的程序。
创建String对象的方法：
String s1 = "imooc"
String s2 = new String;
String s3 = new String("imooc")
2.2 Java中字符串的不变性
String对象创建后则不能被修改，时不可变的，所谓的修改其实时创建了新的对象，所指向的内存空间不同。如下所示：
String s1 = "爱慕课"
String s2 = "爱慕课"
String s3 = new String("爱慕课")
String s4 = new String("爱慕课")
System.out.println(s1 == s2)
System.out.println(s1 == s3)
System.out.println(s3 == s4)
s1 = "欢迎来到：" + s1
注意：
1、通过String s1 = "爱慕课"声明了一个字符串对象，s1存放了到字符串的对象的引用，内存中的存放引用关系如下所示：
然后通过s1="欢迎来到："+s1，改变了字符串s1，其实质时创建了新的字符串对象，变量s1指向了新创建的字符串对象，如下图所示：
2、一旦一个字符串在内存中创建，则这个字符串将不可改变。如果需要一个可以改变的字符串，我们可以使用StringBuffer或者StringBuilder（后面章节中会讲到）
3、每次new一个字符串就是产生一个新的对象，即便两个字符串的内容相同，使用“==”比较时也为false，如果只需要比较内容是否相同，应使用equals()方法
2.3 Java中String类的常用方法I
String类提供了许多用来处理字符串的方法，例如，获取字符串的长度、对字符串进行截取、将字符串转换为大小写、字符串分割等。
| 方法 | 说明 |
|---|---|
| int length() | 返回当前字符串的长度 |
| int indexOf(char ch) | 查找ch字符在该字符串中第一次出现的位置 |
| int indexOf(string str) | 查找str字符串在该字符串中第一次出现的位置 |
| int lastIndexOf(char ch) | 查找ch字符在该字符串最后一次出现的位置 |
| int lastIndexOf(String str) | 查找str字符串在该字符串最后一次出现的位置 |
| String substring(int beginIndex) | 获取从BeginIndex位置开始到结束的子字符串 |
| String substring(int beginIndex, int endIndex) | 获取从biginIndex位置到endIndex位置的子字符串 |
| String trim() | 返回去除了前后空格的字符串 |
| boolean equals(Object obj) | 将该字符串与指定对象进行比较，返回true或false |
| String toLowerCase() | 将字符串转为小写 |
| String toUpperCase() | 将字符串转为大写 |
| char charAt(int index) | 获取字符串指定位置的字符 |
| String[] split(String regex, int limit) | 将字符串分割为子字符串，返回字符串数组 |
| byte getBytes() | 将字符串转换为byte数组 |
注意：
1、字符串str中的索引从0开始，范围为0到str.length()-1
2、使用indexOf进行字符或字符串查找时，如果匹配返回位置索引；如果没有匹配结果，返回-1
3、使用substring(beginIndex, endIndex)进行字符串截取时，包括beginIndex位置的字符，不包括endIndex位置的字符
2.4 Java中String常用方法II
1、“==”和equals()的区别
==判断两个字符串在内存中首地址是否相同，即判断是否时同一个字符串对象
equals()比较存储在两个字符串对象中的内容是否一致。
2、字节时计算机存储信息的基本单位，1个字节等于8位，gbk编码中1个汉字字符存储需要2个字节，1个英文字符存储需要1个字节。每个字节时8位，最大值不能超过127，如果超过就会溢出，以负数形式存在。
2.5 认识Java中的StringBuilder类
在Java中，除了可以使用String类来存储字符串，还可以使用StringBuilder类或StringBuffer类存储字符串，它们之间有什么区别呢？
String类具有不可变性，如
String str = "hello"
System.out.println(str + "world")
System.out.println(str)
程序运营时会额外创建一个对象，保存“helloworld”，当频繁操作字符串时，会额外产生很多临时变量。使用StringBuilder或StringBuffer就可以避免这个问题。至于StringBuilder和StringBuffer，它们基本相似，不同之处是StringBuffer时线程安全的，而StringBuilder则没有实现线程安全功能，所以性能略高。因此一般情况下，如果需要创建一个内容可变的字符串对象，应有限考虑使用StringBuilder类。
StringBuilder str1 = new StringBuilder();
StringBuilder str2 = new StringBuilder("imooc")
2.6 Java中的StringBuilder类的常用方法
StringBuilder类提供了很多方法来操作字符串：
| 方法 | 说明 |
|---|---|
| StringBuilder append(参数) | 追加内容到当前StringBuilder对象的末尾 |
| StringBuilder insert(位置,参数) | 将内容插入到StringBuilder对象的指定位置 |
| String toString() | 将StringBuilder对象转换为String对象 |
| int length() | 获取字符串的长度 |
例如在下面的实例代码中，创建了StringBuilder对象，用来存储字符串，并对其做了追加和插入操作。这些操作修改了str对象的值，而没有创建新的对象，这就是StringBuilder和String的最大区别。
StringBuilder str = new StringBuilder("hello");
str.append(" imooc");
str.append(520);
System.out.println("字符串长度："+str.length());
System.out.println("插入前：" + str);
str.insert(11, "！");
String str2 = str.toString();
System.out.println("插入后：" + str2);
Java中必须了解的常用类
3.1 Java中的包装类
相信各位小伙伴们对基本数据类型都非常熟悉，例如int、float、double、boolean、char等。基本数据类型时不具备对象的特性的，比如基本类型不能调用方法、功能简单...，为了让基本数据类型页具备对象的特性，Java为每个基本数据类型都提供了一个包装类，这样我们就可以像操作对象那样来操作基本数据类型。
基本类型和包装类之间的对应关系：
| 基本类型 | 对应的包装类 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
包装类主要提供了两大类方法：
1、将本类型和其他基本类型进行转换的方法
2、将字符串和本类及包装类互相转换的方法
我们以Integer包装类为例，来看下包装类的特性。Integer包装类的构造方法：
| Integer(int value) | 创建一个Integer对象，表示指定的int值 |
|---|---|
| Integer(String s) | 创建一个Integer对象，表示String参数所知识的int值 |
int i = 2; //定义int类型变量，表示指定的int值
Integer m = new Integer(5); //定义Integer包装类对象，值为5
Integer n = new Integer("8"); //定义Integer包装类对象，值为8
Integer包装类的常用方法
| 方法名 | 返回值 | 解释 |
|---|---|---|
| byteValue() | byte | 将该Integer转为byte类型 |
| doubleValue() | double | 转为double |
| floatValue() | float | 转为float类型 |
| intValue() | int | 转为int类型 |
| longValue() | long | 转为long类型 |
| parseInt(String s) | static int | 将字符串转为int类型 |
| toString() | String | 转为字符串类型 |
| valueOf(String s) | static Integer | 将字符串转换为Integer类型 |
3.2 Java中基本类型和包装类之间的转换
基本类型和包装类之间经常需要互相转换，已Integer为例（其他基本包装类的操作雷同）
Integer a = new Integer(3); //定义Integer包装类对象，值为3
int b = a + 5; //将对象和基本类型进行运算
在JDK1.5引入自动装箱和拆箱的机制后，包装类和基本类型之间的转换就更加轻松便利了。
装箱：把基本数据类型转换成包装类，使其具有对象的性质，又可以分为手动装箱和自动装箱。
int i = 10; //定义一个int基本类型值
Integer x = new Integer(i); //手动装箱
Integer y = i; //自动装箱
拆箱：和装箱相反，把包装类对象转换成基本类型的值，又可分为手动拆箱和自动拆箱。
Integer j = new Integer(8); //定义一个Integer包装类对象，值为8
int m = j.intValue();//手动拆箱
int n = j;//自动拆箱
3.3 Java中基本类型和字符串之间的转换
在程序开发中，我们经常需要在基本数据类型和字符串之间进行转换。其中，基本数据类型转换为字符串有三种方法：
1、使用包装类的toString()方法
2、使用String类的valueOf()方法
3、用一个空字符串加上基本类型，得到的就是基本类型数据对应的字符串。
//将基本类型转换为字符串
int c = 10;
String str1 = Integer.toString(c); //方法一
String str2 = String.valueOf(c); //方法二
String str3 = c + ""; //方法三
将字符串转换成基本类型有两种方法：
1、调用包装类的parseXXX静态方法
2、调用包装类的valueOf()方法转换为基本类型的包装类，会自动拆箱
//将字符串转换为基本类型
String str = "8";
int d = Integer.parseInt(str); //方法一
int e = Integer.valueOf(str); //方法二
其他基本类型与字符串的相互转化这里不再一一列出，方法都类似
3.5 使用Date和SImpleDateFormat类表示时间
在程序开发中，经常需要处理日期和时间的相关数据，此时我们可以使用java.util包中的Date类。这个类最主要的作用就是获取当前事件，我们来看下Date类的使用
Date d = new Date(); //使用默认的构造方法创建Date对象
System.out.println(d);
使用Date类的默认无参构造方法创建出的对象就代表当前时间，我们可以直接输出Date对象显示当前的事件，显示结果如下：
Wed Jun 11 09：22：30 CST 2014
其中Wed代表Wednesday，Jun代表June，11代表11号，CST代表China Standard Time（中国标准事件，也就是背景事件，东八区）。
从上面的输出结果中，我们发现，默认的事件格式不是很友好，与我们日常看到的日期格式不太一样，如果想要按指定格式进行显示，如2014-06-11 09:22:30，那该怎么办呢？
此时就到了java.text包中的SimpleDateFromat类大显身手的时候了！可以使用SimpleDateFormat来对日期时间进行格式化，如可以将日期转换为指定格式的文本，也可将文本转换为日期。
1、使用format()方法将日期转换为指定格式的文本
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyy-MM-dd HH:mm:ss);//创建SimpleDateFormat对象，指定目标格式
String today = sdf.format(d); //调用format()方法，格式化事件，转换为指定格式字符串
2、使用parse()方法将文本转换为日期
String day = "2014年02月14日 10:30:25"
SimpleDateFormat df = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss")
Date date = df.parse(day)
注意：
1、调用SimpleDateFormat对象的parse()方法时可能会出现转换异常，即ParseException，因此需要进行异常处理
2、使用Date类时需要导入java.util包，使用SimpleDateFormat时需要导入java.text包
3.6 Calendar类的应用
Data最主要的作用就是获取当前事件，同时这个类里面页就有设置事件以及一些其他的功能，但是由于本身设计的问题，这些方法却遭到众多批评，不建议使用，更推荐使用Calendar类进行事件和日期的处理。
java.util.Calendar类是一个抽象类，可以通过调用getlnstance()静态方法获取一个Calendar对象，此对象已由当前
