JAVA SE 基础版本
JAVA EE 企业版本
JAVA ME 移动设备

学习JAVA的课程
https://www.imooc.com/video/1416

Eclipse 是IDE（集成开发环境）工具
将程序开发环境和程序调试环境结合在一起，提高开发效率

JVM(JAVA VIRTUAL MACHINE)JAVA虚拟机
1.先编写源代码文件 文件是以.java结尾的
2.用编译器编译源代码文件
3.生成字节码文件，文件以.class结尾（与平台无关）
4.字节码文件通过解释器进行翻译，就能执行该程序

JVM就包含了解释器，所以JAVA跨平台就是通过JVM来实现的

JDK（JAVA DEVELOPMENT KIT）JAVA开发工具包
JRE （JAVA RUNTIME ENVIRONMENT）JAVA运行时间环境

2.使用记事本编写JAVA程序步骤

先用记事本编写一个.java文本文件

（无法查看文件扩展名时：点击计算机>工具>文件夹选项）

编写源代码文件内容的时候，必须要注意该文件类名必须与源代码文件名相同
内容：
public class HelloWorld{
public static void main(String[] args){
System.out.println(“Welcome to imooc!”);
}
}
保存到E盘
然后搜索CMD
先输入cd回车
再输入e：回车
输入dir可查看文件

编译该源文件
输入javac HelloWorld.java回车
则生成了HelloWorld.class字节码文件

解释字节码文件时，不能跟文件的后缀名
输入java HelloWorld

用Eclipse开发java的四个步骤：

打开Eclipse
选择 new > java project （也可在左侧空白处，右键new > java project）

src用来放置源代码文件

然后创建包（作用是便于程序的管理，相当于目录）
右键点击src>new>package
然后起名字（一般包名为域名的反向）

然后编写java的源代码，在指定的包下创建一个Class
名字取为HelloWorld

然后在中括号中输入

再ctrl+s
运行java程序
在程序空白处，右键选择Run As > Java application
也可以直接在工具栏中点Run按钮

public : 类的一个修饰符，定义为公有的
class : 关键字
类名一定要与源代码文件名一致

也可以直接在项目里添加源代码文件，则该源代码文件会分配进入默认的包中

程序的移植（项目的导入和导出）：
将一个电脑的项目移植到另一个电脑项目中去
右击该项目

选择最下面的属性

打开后

Location显示了该项目当前所在的位置

打开该路径所在的位置

直接右键复制
设定假如拷贝到E盘的根目录下
直接到该目录下粘贴

为避免重名，影响观察结果
删掉原有的项目delete

勾加上，把文件一并删掉
导入操作：

选择General > Existing Projects into Workspace

选择Browse去寻找项目

java区分大小写
标识符就是给变量、方法、类命名的变量
标识符可以由字母、数字、下划线、美元符$组成，且标识符不能以数字开头

java中定义一个字符串变量
String love = “mooc”;
如果要更改可以直接更改
love = “i love mooc”;
输出
System.out.println(“love的内容是：” + love);
使用+对字符串和变量进行拼接

java变量名首字母只能是字母、下划线或者$符号

变量名由多个单词组成时，第一个单词小写，其余后面每个单词首字母大写
变量名由多单词组成时，第一个单词的首字母小写，其后单词的首字母大写，俗称骆驼式命名法（也称驼峰命名法），如 myAge

java语言是一种强类型语言：在java中存储的数据都是有类型的，并且在编译时就确定了其类型。

java中有两类数据类型，一类是基本数据类型：数值型（浮点型，整数型），字符型，布尔型
一类是引用数据类型：数组、类、接口。

基本数据类型变量存的是数据本身
引用数据类型变量存的是数据的空间地址

float类型声明时，后面加f
float a = 12.5f;否则会报错

String是一种常用的引用数据类型

Java中自动类型转换
例子：
int a = 82;
double b = a;
System.out.println(b);//输出结果是82.0

自动类型转换满足的条件：
1.目标类型能与原类型兼容，如double>int,但是char 和 int就不行
2.目标类型范围大于原类型范围

而强制类型转换（一般用于目标类型范围小于原类型范围）

输出结果：

强制类型转换可能造成数据丢失。

boolean类型只能写true或者false，否则会报错

常量在程序运行过程中不可改变。
语法： final 常量类型 常量名 = 值；
程序中使用常量可以提高代码的可维护性
（在项目开发时，制定用户性别为男）

常量名一般用大写字符表示。

Java单行注释//
多行注释：/* /
文档注释/* */

生成API帮助文档的步骤
进入cmd，然后移动到源文件所在的路径（右键单击源文件property）cd 回车

e:回车E:\imooc\src\com\immoc

然后输入javadoc HelloWorld.java回车

然后就可以在与源文件同目录下找到index.html
打开，即可看到生成的API文档

自增和自减运算符只能用于操作变量，不能用于操作数值或常数

求一个数自减后的值
int b = --a;

、<、 >=、<=只支持左右两边操作数都是数值类型
!=、==两边的操作数既可以是数值类型，也可以是引用类型

逻辑运算符

主要是记^
a和b有且仅有一个为true，才返回true

当使用逻辑运算符时，可能会遇到短路现象
如(one>two)&&(two>three)
如果one>two为false，则系统就不会再执行后面的
同理(one>two)||(two>three)
如果one>two为true,系统也不会再执行后面的

每次输入System.out.println():比较繁琐
所以可以通过先输入
Syso 再按住alt+/就可以打出——内容提示的快捷键

用Scanner工具类来获取用户输入的信息，
Scanner类位于java.util包中，使用时，需要导入此包
步骤：1.导入java.util.Scanner工具类
2.创建scanner对象
3.接收并保存用户的值

导入包的操作是在包声明的下面package下面导入
输入import java.util.Scanner;
在main()方法中创建Scanner对象
Scanner input = new Scanner(System.in);
再提醒用户输入
System.out.println(“请输入考试成绩信息：”);
int score = input.nextint();//获取用户输入的信息，并保存在变量中

具体实例：
package com.imooc;
import java.util.Scanner; //引入java.util.Scanner的包

public class HelloWorld{
public static void main(String[] args){
Scanner input = new Scanner(System.in); //创建一个Scanner对象
System.out.print(“请输入考试成绩信息：”);
//.next能接收不带空格的字符串,遇到空格和回车自动截取完了
//.nextLine能接收带空格的字符串，只有遇到回车时才会截取完
int score = input.nextInt();
int count = 0;
System.out.println(“加分前的成绩：” +score);
while(score<60) {
score++;
count++;
}
System.out.println(“加分后的成绩：”+ score);
System.out.println(“共加了” + count+“次！”);
}
}

程序调试：
在最前面的地方去双击，添加断点（断点是小圆点）。

如果未出现小圆点，可能是跳过了断点，打开

然后开始调试

程序仅仅执行到断点的前面

按 Step Over或者按F6，进行单步的执行

如果窗口未显示变量，可能是不小心将变量窗口关闭了
windows > show view >variables

main（）方法也可以使用快捷键的方法进行创建
输入main 按住alt+/

alt+/自动补齐
alt+enter 尝试进行错误的修复

重新打开项目用Open直接打开有小黑点的项目
类名称首字母大写

项目结构

所有代码都要写在src里面！！否则就不是源代码了

方法必须定义在类中

定义数组
数据类型 [] 数组名称 = new 数据类型[长度];

类的定义格式
public class ClassMate{
//成员变量
//成员方法
}

方法的重载，方法名称一样，参数列表不一样
参数列表不一样：参数个数不一样、参数类型不同、参数多类型顺序不同

在整个class里面声明方法，无论该方法是在main（）函数前面还是后面，都可以直接调用，不用声明

！！方法的重载与返回值类型无关

java中System.out.println()是方法的重载

数组是一种引用数据类型。
基本数据类型和引用数据类型的区别主要在存储方式上：
基本数据类型创建时，在栈上分配一块内存，数值直接存在栈上。
引用数据类型创建时，首先在栈上给其引用（句柄）分配一块内存，而对象的具体信息都存在堆内存上，然后用栈上的引用指向堆上的地址。

数组的长度在程序运行期间不可修改。

数组的初始化：
动态初始化：（指定长度）
静态初始化 ：（指定内容）

动态初始化：
数据类型【】数组名称 = new 数据类型【数组长度】；

不管是基本类型还是引用类型，都可以作为数组中的类型。
例如： String【】 arrayC = new String【5】；

静态初始化数组：
数据类型[] 数组名称 = new 数据类型[] {};
String[] arrayA = new String[] {“hello”,“world”,“java”};
静态初始化省略格式
数据类型[] 数据名称 = {}；

静态初始化标准格式还可以拆分为两个格式：
int[] a;
a = new int[] {};
动态初始化标准格式也可以拆为两个格式：
int[] a;
a = new int[3];

但是静态初始化省略步骤不能拆分为两个步骤

直接打印数组名称，得到的是数组对应的，内存地址哈希值

使用动态初始化数组的时候，整数类型将每个元素默认为0；
浮点类型每个元素默认为0.0
如果是字符类型，默认值为‘\u0000’（不可见字符，如果答应是看不见的）
如果是布尔类型，默认值为FALSE
如果是引用类型，默认值为null

静态初始化也有默认值，只不过立刻将默认值立刻替换为默认值

java的内存划分为5个部分：
1.栈（Stack）：存放方法中的局部变量（有作用域，一旦超出作用域，直接从栈内存中消失）
但是方法运行一定是在栈中。
2.堆 (Heap) : 凡是new出来的东西，都在堆内存中。
堆内存中的东西都有一个地址值，该地址值为16进制的
3.方法区（Method Area）:存储.class相关信息，包含方法的信息。
4.本地方法栈：与操作系统相关
5.寄存器（pc Register）：与CPU相关

int[] arrayA = {1,2,3};
int[] arrayB = arrayA;//虽然是两个引用名称，但是是同一个数组，因为存放的是同一个地址

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

所有的引用类型都可以赋值为一个null值，代表其中什么都没有。

数组必须经过new才能使用其中的元素
如果只赋值了一个null,那么使用元素的时候将会发生空指针异常
NullPointerException

静态初始化时，获取数组长度。
数组名称.length

数组运行期间，程序运行期间，长度不可改变

真正的数组是右边new出来的值，左边只是名称

int[] array = new int[3]; //把右边的地址赋值给左边的名称
System.out.println(array.length);
array = new int[5]; //相当于创建了一个新的数组
System.out.println(array.length);

遍历数组：
array.fori

数组元素的反转：（额外要求：不能使用新数组）
其实就是对称元素的交换
表示对称元素一般用两个索引。
int min = 0;
int max = array.length-1;
当min>=max的时候停止交换

所以交换的条件就是min<max
for(int min=0,max=array.length-1)

public static void ArrayPrint(int[] array){

}
调用时ArrayPrint(array);
当方法调用时，向方法的小括号里面传参，传递进去的实际是数组的地址。

当希望一个方法可以有多个结果返回时，可以用一个数组作为返回值类型
public static void main(String[] args) {
int[] result = calculate(10,20,30);
for (int i = 0; i < result.length; i++) {
System.out.println(result[i]);
}
}
public static int[] calculate(int a,int b,int c){
int sum = a + b + c;
int avg = sum / 3;
int[] array = {sum,avg};
return array;
}

使用面向对象，找一个JDK为我们提供好的类，再找这个类所对应的方法

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

类：是一类属性和行为的相关集合，可以看成是一类事物的模板。
类是对一类事物的描述，是抽象化的。
对象是一类事物的实例，是具体的。
类是对象的模板，对象是类的实体

普通方法有static关键字。
但是建的类的方法没有static

在Java中定义一个学生的类
不加main（）方法
直接定义在类中的变量，且定义在方法外，叫做成员变量，。
直接定义在类中的方法，叫成员方法，且成员方法不用static。

通常情况下，一个类不能直接使用，需要根据类创建一个对象才能使用。
步骤：
1.导包 import 包名称.类名称；（对于和当前类属于同一个包的，可以省略导包语句）
这个导包语句就可以省略，因为在同一个…day05包下

2.创建
类名称 对象名 = new 类名称（）；
3.使用

如果成员变量没有赋值，则会有一个默认值

按shift+f6可以把所有这个变量名名字改变

局部变量和成员变量的区别：
1.定义的位置不同：
局部变量：定义的位置在方法的内部（方法的参数也是局部变量）
成员变量：在方法的外部，直接写在内中
2.作用范围不一样
局部变量：只有方法中才能使用，出了方法就不能使用
成员变量：整个类全都可以通用。
3.默认值不一样
局部变量：无默认值，如果要使用，必须手动进行赋值。
成员变量：如果没有赋值，会有默认值，规则与数组一样。
4.内存位置不一样
局部变量：位于栈内存
成员变量：位于堆内存
5.生命周期不一样
局部变量：随着方法进栈而诞生，随着方法出栈而消失
成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失

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

封装的体现：
1.方法就是一种封装
2.关键字private也是一种封装
封装就是将一些细节信息隐藏起来，对于外界不可见

问题描述，在创建Person的类的年龄时，无法阻止不合理的数值被设置进来。
解决方法：用private关键字将需要保护的成员变量进行修饰
一旦使用private进行修饰，那么在本类中还是可以随意访问，
但超出本类就不能直接访问了(就不能直接使用Person.age了)，但可以间接使用
在public class Person{
private int age;
public void setAge(int num){
if(num<100 && num>=0){//对age进行修饰限制，只能在方法中，所以用private，可以在setAge里面进行限制修饰
age = num;//这样就可以将num赋值给age了，同时也没有直接访问age。
}
else{
System.out.println(“数据不合理”);
}
}
public int getAge(){
return age;//获取age
}
}
间接访问成员变量，就是定义一对getter、setter方法
Person person = new Person();
person.setAge(18);
System.out.println(person.getAge());

一般用private修饰用getter、satter定义方法获取、设置值，但存在一种特殊情况，布尔值。
private boolean male;
public void setMale(boolean b){
male = b;
}
public boolean isMale(){
return male;
}
对于基本类型中的boolean值，它的getter方法，一定要写为isXXX，而setter方法不变。

不一样的包下，可以有同名的类。

当方法的局部变量和成员变量重名的时候，根据就近原则，优先选择局部变量，
如果需要访问本类中的成员变量，需要使用格式this.成员变量名

所以使用this关键字，可以解决方法中局部变量参数与成员变量分不开的情况
通过谁调用的方法，谁就是this。

构造方法就是专门用来创建对象的方法，
当我们通过new关键字创建对象的时候，其实就是在调用构造方法（并不是.加方法）
构造
格式：
public 类名称（参数类型，参数名称）{
方法体;
}
1.构造方法的名称必须与所在的类名称完全一样，就连大小写也要一样
2.构造方法不要写返回值类型，连void都不写
3.构造方法不能return一个具体的返回值
4.如果没有编写构造方法，那么编译器将会赠送一个构造方法，没有参数，方法体不做任何事情
例如：
package cn.itcast.day06.demo04;

public class Student {

public Student(){
}

}
5.一旦编写了至少一个构造方法（构造方法也可以进行重载），那么编译器将不再赠送
构造方法
package cn.itcast.day06.demo04;

public class Student {

public Student(){
    System.out.println("构造方法执行啦");
}

}
构造方法使用：
package cn.itcast.day06.demo04;

public class demo02Student {
public static void main(String[] args){
Student stu = new Student();
}
}
运行结果：

可以通过全参数的构造方法直接对类中的private成员变量进行赋值。
public Student(String name,int age){
this.name = name;
this.age = age;
}

一个标准的类通常要满足四个组成部分：
1.所有成员变量都需要进行private关键字修饰
2.为每一个成员变量编写一对setter和getter
3.编写一个无参数的构造方法
4.编写一个全参数的构造方法

这样标准的类也叫做 Java Bean

自动生成getter、setter方法
点击

再点击Generate 选择Getter and Setter
将名字和年龄都选择 用shift一共选

生成无参数的构造方法
code > generate > constructor > none select（无参数）