public class HelloWorld{
public static void main(String[] args){ //固定不变
System.out.println("Hello,World"); //打印
}
}
关键字特征：完全小写 有颜色（不能自己定义）
标识符：自己定义的内容（类，变量等）
1.英文字母 0-9 $ _
2.不能数字开头
3.标识符不能是关键字
//4.类规范：首字母大写 (HelloWorld等)
//5.变量名 方法名：首字母小写（helloWorld)
常量分类：（程序运行期间固定不变的）
1.字符串常量： “asd” “hello” “123”
2.整数常量：100 200 0 -23
3.浮点数常量：2.1 -3.14
4.字符常量：‘a’ ‘1’ ‘中’
5.布尔常量：两种true false
6.空常量：null 代表没有任何数据
常量打印：
public class Demo0Const{
public static void main (String[] args){
//字符串常量
System.out.println("asd");
System.out.println("");//字符串两个双引号之间的内容可以不写
//整数常量
System.out.println(30);
System.out.println(-2);
//浮点数
System.out.println('A');
System.out.println('6');
System.out.println('');//错误，两个单引号之间有且只有一个
System.out.println('as');//错误，两个单引号之间有且只有一个
//布尔常量
System.out.println(true);
System.out.println(false);
//空常量
System.out.println(null);//错误，空常量不能直接来打印输出
基本数据类型:
整数型 byte short int long 1 2 4 8 字节
浮点型 flout double 4 8 字节
字符型 char 2 字节
布尔型: boolean 1 字节
引用数据类型：
字符串、接口、类、数组、Lamdba
注意事项：
1.字符串不是基本类型
2.浮点型只是近似值
3.数据范围与字节数不一定相关。float数据范围比long更广泛，float 4字节。long 8字节
4.浮点数 默认double 。 一定用float时 接一个后缀F。 3.14F
整数 默认int类型 ， 一定要使用long时 接一个L 4L
float num7=2.5F;
double num2=2.3;
long num3=30000000000L //数值太大，不加L可能报错
boolean var1=true;
System.out.println(var1); //true
数据类型装换
自动类型转换（隐式）
1.特点：代码不需要进行特殊处理，自动完成
2.规则：数据范围从小到大
强制类型转换（显式 [int num = (int)199L]//大数据向小数据转换
System.out.println(1024);//这就是一个整数。默认就是int类型
System.out.println(3.14);//默认double；
long num1=100;//左边是long类型，右边是int类型，左右不一样
//将右侧的int类型常量，交给long变量储存
//int–>long ,符合从小到大规则
//发生了自动类型转换
double num2 = 2.5F;//左侧是。。。
float num3 = 30L;//左侧是float，右侧是long。 float大于long，可以自动转化
System.out.println(num3);//30.0
数据转换注意事项
1.byte/short/char进行运算时会首先提升为int
2.boolean类型不能发生数据类型转换
long 强制转换成 int
int num = 199L; //错误，左边小于右边时，不能自动转换
int num = (int)1999L; //正确，强制类型转换
int num = (int)999999999999999L;// 虽然强制转化了，但是会溢出，输出结果错误
double–> int
int num = (int)3.99;//输出3，精度丢失
char类型运算 用ASCLL码
运算中有不同类型数据，结果是大的那个类型。
比如 int 类型与double类型相加，结果double类型；
double num3 = 10 + 2.5 ；结果为10.5、、double类型；
字符串String，加号代表连接操作。任何数据和字符串连接的时候，结果都会变成字符串
Systerm.out.println(“hello”+“world”);// 输出helloworld
System.out.println(“hello”+20);// 输出hello20
System.out.println(“hello”+20+30);//输出hello2030
System.out.println(“hello”+(20+30));输出hello50
复合运算符
byte num = 10;
byte num +=5；
byte+int ; 一开始 byte类型，加上int类型，自动强制转化成byte；
System.out.println(10>9);// 输出true；
方法：
public class Demo11Method{
public static void main(string[],args){
famer();//调用，相当于函数调用
seller();//调用
}
public static void famer(){
System.out.println("播种");
}
public static void seller(){
System.out.println("卖");
}
}
char/short/byte
byte num=19;//右边是int类型；int–>byte形式，是从大向小转换，又没有强制类型转换，
对于char/short/byte直接赋值。
1、系统自动加上（char/short/byte）强制类型转换。只要不超过左侧范围就好；
2、如果超过左侧范围，报错
short/char/byte类型进行运算时，会自动上升为int类型
注意：
short a=9;
short b=10;
short c=a+b;// 错误 ，，，，左侧在运算时 自动转化为int+int； 结果为int类型；而左侧却是short类型
又没有强制类型转换；
short c = 3+4； //正确，虽然右侧是int类型，因为没有变量，所以系统自动强制转换（再class字节码文件中 直接就是 c=7）
这是“编译器的常量优化” （常量不能超过左侧范围）；注意：不能有变量的存在
方法重载
public static void main(String[] args){
System.out.println(sum(10,20));
}
public static int sum(int i,int j);
public static int sum(int i,int j,int k);
public static int sum(int i,int j,int k,int l);
方法名相同，但是参数个数不同。直接输入数字就行了，会自动匹配。
可以类型不同，会自动匹配
--------------------------------------------------------------
方法重载注意
与下列因素有关：
1.参数个数不同
2.参数类型不同
3.参数多类型顺序不同
与下列因素无关
1.与参数名称无关
2.与返回值类型无关
数组
两种初始化：
1.动态初始化（指定长度）
2.静态初始化（指定内容）
动态初始化格式： 数据类型[] 数组名称 = new 数据类型 [数组长度];
int[] arrayA = new int[300];
double[] arrayB = new double [10];
String[] arraryC =new String[5];
静态初始化格式 1： 数据类型[] 数组名称 = new 数据类型[] {元素1，元素2，…}
int[] arrayA=new int[]{4,5,6}
String[] arrayB=new String[]{“hello”,“World”…}
静态初始化省略格式 2： 数据类型[] 数组名称 = {元素1，元素2，…}
int[] arrayA = {10,20,30};
注意：
1.动态初始化可以拆分成两个步骤：
int[] arrayB;
arrayB=new int[5];
2.静态初始化也可以拆分：
int[] arrayC;
arrayC=new int[]{10,20,30}
*静态初始化省略格式不可以拆分
int [] arrayD;
arrayD={10,20}//报错
动态初始化数组时，再赋值之前会有默认值
int[] arrayA= new int [3];
整数类型 默认为0；
浮点类型 默认为0.0；
字符类型 默认为’\u0000’;
布尔类型 默认为false;
引用类型 默认为null；
Java的内存需要划分为5个区
1.栈（stack）：存放的是方法中的局部变量，方法的运行一定在栈中运行
局部变量：方法的参数，或者方法（）内部的变量
作用域：一旦超过作用域，立刻从栈内存中消失
2.堆（heap）：凡是new出来的东西，都在堆当中。
堆内存里面的东西都有一个地址值：16进制
堆内存中的数据都有默认值
整数类型 默认为0；
浮点类型 默认为0.0；
字符类型 默认为’\u0000’;
布尔类型 默认为false;
引用类型 默认为null；
3.方法区（Method Area）：存储.class 相关信息，包含方法信息
4.本地内存栈：与操作系统有关
5.寄存器：与cpu有关
一个数组的内存图
1.方法区中存储.class相关信息 （保存方法的信息，名字、返回值、参数等）
2.先再方法区中 看看方法main 信息是什么，并把信息加载到栈中。并在栈中开辟一段空间
3.变量 int[ ] array 放在栈中，new出的东西放在堆中并开辟一段空间。
4.new出的 空间地址值 放在栈中的array名称中。
** new出的数组是在堆中的。数组名称（变量）是在栈中的（存储的是地制值，有了地址就可以找到堆中的数组）
** 注意 程序是加载到栈中运行的
两个数组的内存图
两个引用指向同一数组的
常见问题： 数组索引越界
int[] array= {16,17,18}
System.out.println(array[3]);//越界错误
空指针异常
int[] array;
//array=new int[3];
System.out.println(arrray[0]);//错误，没有初始化
。。。。。。。。
int[] array;
array=null;
System.out.println(array[0]);//NullpointerException（空指针异常）
所有引用类型变量，都可以赋值为null，但是其中什么都没有。
数组长度的获取
数组名称.length (一个int数字，代表数组长度）
数组一但创建，程序运行期间，长度不可改变
数组传参，作为返回值
int[] array=new int[8];
prin(array); // 数组名称为参数(数组地址值）
public static void prin(int [] array) //形参
数组是返回值
int[] result=claculate(10,20,30)
System.out.println(“总和：”+result[0]);
System.out.println(“平均数：”+result[1]);
public static int[]/返回值类型 数组/ claculate(int a,itn b,int c){
int sum=a+b+c;
int avg = sum/3;
int[] result=new int[2];
result[0]=sum;
result[1]=avg;
return resultl;
}