目录
一、IDEA的使用
1.项目创建
a.创建项目project
b.创建模块module
c.在src下面创建软件包package
d.在包下面创建类class
2.程序编写
a.在所建的类class中创建main函数
b.在main函数中编写程序（例如编写HellWorld）
public class Test {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
二、添加注释comment
1.注释
就是对代码的解释和说明。其目的是让人们能够更加轻松地了解代码。为代码添加注释，是十分必须要的，它不影响程序的编译和运行。
2.注释分类
a.单行注释：//（快捷键ctrl+/）
public class Test {
public static void main(String[] args) {
// System.out.println("Hello World!");
}
}b.多行注释：/* */
public class Test {
public static void main(String[] args) {
System.out.println("Hello World!");
/*System.out.println("Hello!");
System.out.println("World!");*/
}
}
c.文档注释：/** */
public class Test {
public static void main(String[] args) {
/**
* 编写一个程序，输出"Hello World!"
*/
System.out.println("Hello World!");
}
}三、关键字keywords
1.关键字
是指在程序中，Java已经定义好的单词，具有特殊含义。HelloWorld案例中，出现的关键字有 public 、 class 、 static 、 void 等，这些单词已经被Java定义好，全部都是小写字母，notepad++中颜色特殊。关键字比较多，不能死记硬背，学到哪里记到哪里即可。
四、标识符
1.标识符
是指在程序中，我们自己定义内容。比如类的名字、方法的名字和变量的名字等等，都是标识符。HelloWorld案例中，出现的标识符有类名字 HelloWorld 。
2.命名规则： 硬性要求
a.标识符可以包含 英文字母26个(区分大小写) 、 0-9数字 、 $（美元符号） 和 _（下划线） 。
b.标识符不能以数字开头。
c.标识符不能是关键字。
3.命名规范： 软性建议
a.类名规范：首字母大写，后面每个单词首字母大写（大驼峰式），例如HelloWorld。
b.方法名规范： 首字母小写，后面每个单词首字母大写（小驼峰式），例如sayHello。
c.变量名规范：全部小写。
五、常量
1.概述
常量：是指在Java程序中固定不变的数据。
2.分类
| 类型 | 含义 | 数据举例 |
| 整数常量 | 所有的整数 | 0，1，567，-9，-1 |
| 小数常量 | 所有的小数 | 0.0，-0.1， 2.55，3.14 |
| 字符常量 | 单引号引起来,只能写一个字符,必须有内容 | 'a'，'好' |
| 字符串常量 | 双引号引起来,可以写多个字符,也可以不写 | "A"，"Hello"，"你好"，" " |
| 布尔常量 | 只有两个值 | true ,false |
| 空常量 | 只有一个值 | null |
public class Test{
public static void main(String[] args){
//字符串常量
System.out.println("A");
System.out.println("");
System.out.println("Hello");
//整数常量
System.out.println(30);
System.out.println(-20);
System.out.println(20);
//浮点型
System.out.println(3.14);
System.out.println(-2.5);
//字符常量
System.out.println('A');
//布尔常量
System.out.println(true);
System.out.println(false);
}
}六、变量和数据类型
1.变量概述
变量：常量是固定不变的数据，那么在程序中可以变化的量称为变量。
数学中，可以使用字母代替数字运算,例如 x=1+5 或者 6=x+5。
程序中，可以使用字母保存数字的方式进行运算，提高计算能力，可以解决更多的问题。比如x保存5，x也可以保存6，这样x保存的数据是可以改变的，也就是我们所讲的变量。
Java中要求一个变量每次只能保存一个数据，必须要明确保存的数据类型。
2.数据类型
2.1数据类型分类
Java的数据类型分为两大类：
基本数据类型：包括 整数 、 浮点数 、 字符 、 布尔 。
引用数据类型：包括 类 、 数组 、 接口 。
2.2基本数据类型
四类八种基本数据类型：
| 数据类型 | 关键字 | 内存占用 | 取值范围 |
| 字节型 | byte | 1个字节 | -128~127 |
| 短整型 | short | 2个字节 | -32768~32767 |
| 整型 | int(默认) | 4个字节 | -231次方~2的31次方-1 |
| 长整型 | long | 8个字节 | 2的63次方~2的63次方-1 |
| 单精度浮点数 | float | 4个字节 | 1.4013E-45~3.4028E+38 |
| 双精度浮点数 | double(默认) | 8个字节 | 4.9E-324~1.7977E+308 |
| 字符型 | char | 2个字节 | 0-65535 |
| 布尔类型 | boolean | 1个字节 | true, false |
a.Java中的默认类型：整数类型是 int 、浮点类型是 double 。
b.取值范围由小到大排列：byte,short,char,int,long,float,double。
3.变量的定义
a.变量定义的格式包括三个要素： 数据类型 、 变量名 、 数据值 。
b.格式：数据类型 变量名 = 数据值;
c.建议：long类型数据后加L或者l表示；float类型数据后加F或者f表示。
public class Test{
public static void main(String[] args){
//创建整型变量
//数据类型 变量名称
int num1;
//变量名称 = 数据值
num1 = 10;
System.out.println(num1);
//改变num1的值
num1 = 20;
System.out.println(num1);
//一步到位的方式定义变量
int num2 = 25;
System.out.println(num2);
//也可以进行改变
num2 = 35;
System.out.println(num2);
System.out.println("=========================");
//定义字节类型变量
byte num3 = 30;
System.out.println(num3);
//定义短整型类型变量
short num5 = 50;
System.out.println(num5);
//定义长整型类型变量
long num6 = 200000L; //如果是long类型的数据，需要在值后面加L
System.out.println(num6);
//定义单精度浮点类型
float num7 = 2.5F; //定义浮点类型数据后面一定要加F
System.out.println(num7);
//定义双精度浮点类型
double num8 = 2.34;
System.out.println(num8);
//定义字符类型
char chars = 'A';
System.out.println(chars);
//定义布尔类型
boolean flag = true;
System.out.println(flag); //true
flag = false;
System.out.println(flag); //false
}
}4.注意事项
a.变量名称：在同一个大括号{}范围内，变量的名字不可以相同。变量的名称，全小写，见名知意。
b.变量赋值：定义的变量，不赋值不能使用。变量的赋值，不能超过变量类型的作用范围。
public class Test{
public static void main(String[] args){
int num1 =10; //创建一个num1变量,给他赋值10
System.out.println(num1);
{
int num6=20;
System.out.println(num6);
}
//System.out.println(num6);// 已经超过了大括号范围.错误
//定义三个变量,都是int类型
int a,b,c; //正确
a = 100;
b = 200;
c = 300;
System.out.println(a);
System.out.println(b);
System.out.println(c);
int x=100, y= 300,z=1000;
System.out.println(x);
System.out.println(y);
System.out.println(z);
}
}七、数据类型转换
1.概述
Java程序中要求参与的计算的数据，必须要保证数据类型的一致性，如果数据类型不一致将发生类型的转换。
2.自动转换
2.1自动转换概述
a.将取值范围小的类型自动提升为取值范围大的类型 （Java自动执行 ）。
public class Test{
public static void main(String[] args){
// byte -128 ~ 127
System.out.println(1024); // 整数默认数据类型是int类型
System.out.println(3.14); // 浮点数默认类型是double类型
//左边是long类型，右边默认是int类型，左右不一样
// 一个等号代表赋值,将右边的int常量,交给左侧的long变量进行存储
// int --> long 复合范围要求，从小到大的要求
// 这行代码发生的是自动类型转换
long num1 = 100;
System.out.println(num1); //100
//复合从小范围到大范围的转换 自动转换
double num2 = 2.5F; //float 类型
System.out.println(num2);//2.5
//long类型转换float类型
float num3 = 30L;
System.out.println(num3);//30.0
}
}2.2转换原理
a.根据语言的类型转换规则，将源数据类型的值转换为目标数据类型的值，以便在表达式或操作中使用。
2.3转换规则
a.范围小的类型向范围大的类型提升， byte、short、char 运算时直接提升为 int 。
byte、short、char‐‐>int‐‐>long‐‐>float‐‐>double
3.强制转换
3.1强制类型转换概述及格式
a.概述：将取值范围大的类型强制转换成取值范围小的类型 （需要我们自己手动执行 ）。
b.格式：数据类型 变量名 = （数据类型）被转数据值；
public class Test{
public static void main(String[] args){
//左边是int类型,右边是long类型,不一样
// long --> int 不能从小到大，强制类型转换
int num1 = (int)100L;
System.out.println(num1);
int num2 = (int)6000000000L;
System.out.println(num2);
// double --> int 强制类型转换
int num3 = (int)3.99;
System.out.println(num3);
char char1 = 'A'; //A相当是一个字符.
System.out.println(char1+1); //A被当成65进行处理
//计算机底层会用数字(二进制码)来代表字符A, 就是65,
//按照上面的规则,char类型进行运算,会把他按照一定规则提升为int类型进行使用
//short类型
// 在进行运算的时候,也是要先提升到int类型
short num6 = 60;
// int -- > short
short result2 =(short) (num4 + num6);
System.out.println(result2);
}
}3.2强烈注意
a.浮点转成整数，直接取消小数点，可能造成数据损失精度。
b.int 强制转成 short 砍掉2个字节，可能造成数据丢失。
c.boolean类型不能发生数据类型转换。
八、ASCII编码表
编码表 ：就是将人类的文字和一个十进制数进行对应起来组成一张表格。
| 字符 | 数值 |
| 0 | 48 |
| 9 | 57 |
| A | 65 |
| Z | 90 |
| a | 97 |
| z | 122 |
public class Test{
public static void main(String[] args){
char zifu1 = '1';
System.out.println(zifu1 + 0); //49
char zifu2 = 'A'; //底层就是65;
char zifu3 = 'c';
//char类型会进行自动转换
//char < int 从小到大转换.
int num = zifu3;
System.out.println(num);
char zifu4 = '中';
System.out.println(zifu4 + 0);
}
}九、运算符
1.算术运算符
| 算术运算符 | 含义 |
| + | 加法运算，字符串连接运算 |
| - | 减法运算 |
| * | 乘法运算 |
| / | 除法运算 |
| % | 取模运算，两个数字相除取余数 |
| ++、-- | 自增自减运算 |
Java中，整数使用以上运算符，无论怎么计算，也不会得到小数
public class Test {
public static void main(String[] args) {
int i = 1234;
System.out.println(i/1000*1000);//计算结果是1000
}
}a.++ 运算，变量自己增长1。反之， -- 运算，变量自己减少1，用法与 ++ 一致。
独立运算：
变量在独立运算时，前++ 和 后++ 没有区别 。
变量前++ ：例如 ++i 。
变量后++ ：例如 i++ 。
混合运算：
和其他变量放在一起， 前++ 和 后++ 就产生了不同。
变量前++ ：++在变量前，先+1，再参与其他运算。
变量后++ ： ++在变量后，先参与其他运算，再+1
常量不能进行自增自减操作。
public class Demo06Operator{
public static void main(String[] args){
int num1 = 10;
System.out.println(num1); //10;
++num1; // 单独使用 前++ ;
System.out.println(num1); //11
num1++; // 单独使用 后++
System.out.println(num1); // 12
System.out.println("==============");
//与打印混合使用
int num2 = 20;
//混合使用前++
System.out.println(++num2);//21
System.out.println(num2);//21
System.out.println("==============");
//混合使用后++
int num3 = 30;
System.out.println(num3++);//30
System.out.println(num3);//31
System.out.println("==============");
//变量之间的混合运算
int num4 = 40;
int result1 = --num4; // 因为-- 在前 ,立刻马上 -1 运算后的结果39 赋值给result1
System.out.println(result1);//39
System.out.println(num4);//39
System.out.println("==============");
//后--
int num5 = 50;
int result2 = num5--;
System.out.println(result2); // 50 因为 --在后 会把本身值先赋值给result2
System.out.println(num5);//49
System.out.println("==============");
//混合运算;
int x = 10;
int y = 20;
// 11 + 20 =31
int result3 = ++x + y--;
System.out.println(result3);
System.out.println(x);
System.out.println(y);
// 10++; 常量是不能进行 自减
}
}public class Test{
public static void main(String[] args){
//两个常量之间可以直接进行数学运算
System.out.println(20 + 30); //直接运算
//定义两个变量
int a = 20;
int b = 30;
System.out.println(b - a);
//变量和常量进行混合计算
System.out.println(b *10);
int x = 10;
int y = 3;
int result1 = x % y;
System.out.println(result1); // 1
// int + double --> double + double --> double
double result3 = x + 2.5;
System.out.println(result3);// 12.5
}
}b.+ 符号在字符串中的操作：
符号在遇到字符串的时候，表示连接、拼接的含义。
"a"+"b"的结果是“ab”，连接含义。
public class Test{
public static void main(String[] args){
//定义字符串类基本使用
String str1 = "Hello";
System.out.println(str1); //Hello
System.out.println("Hello" + "World!");// HelloWorld
String str2 = "Java";
//字符串加 数字
System.out.println(str2 + 20);// Java20
//优先级问题
//String + int + int;
// String + int
System.out.println(str2 + 20 + 30); // java2030
System.out.println(str2 + (20 + 30)); // Java50
}
}2.赋值运算符
| 赋值运算符 | 含义 |
| = | 等于号 |
| += | 加等于 |
| -= | 减等于 |
| *= | 乘等于 |
| /= | 除等于 |
| %= | 取模等 |
赋值运算符，就是将符号右边的值，赋给左边的变量。
public class Test{
public static void main(String[] args){
int a = 30;
// a = 30 + 5;
a += 5;
System.out.println(a);// a= 35;
int x = 10;
// x = 10 % 3;
x %= 3;
System.out.println(x);// x = 1;
byte num = 30;
// num = num +5;
// num = byte + int;
// num = (byte) int;
// num = int
// num = int + int;
num += 5;
System.out.println(num);// num = 35
}
}3.比较运算符
| 比较运算符 | 含义 |
| == | 比较符号两边数据是否相等，相等结果是true。 |
| < | 比较符号左边的数据是否小于右边的数据，如果小于结果是true。 |
| > | 比较符号左边的数据是否大于右边的数据，如果大于结果是true. |
| <= | 比较符号左边的数据是否小于或者等于右边的数据，如果小于结果是true。 |
| >= | 比较符号左边的数据是否大于或者等于右边的数据，如果小于结果是true。 |
| != | 不等于符号，如果符号两边的数据不相等，结果是true。 |
比较运算符，是两个数据之间进行比较的运算，运算结果都是布尔值 true 或者 false 。
public class Test{
public static void main(String[] args){
System.out.println(10 > 5 ); //true
int num1 = 10;
int num2 = 12;
System.out.println(num1 < num2); //true
System.out.println(num1 >= 100);//false
System.out.println(10 == 10);//true
System.out.println(10 != 20);//true
}
}4.逻辑运算符
| 逻辑运算符 | 含义 |
| && 短路与 | 1.两边都是true，结果是true 2.一边是false，结果是false 短路特点：符号左边是false，右边不再运算 |
| || 短路或 | 1.两边都是false，结果是false 2.一边是true，结果是true 短路特点：符号左边是true，右边不再运算 |
| ！取反 | 1.!true 结果是false 2.!false结果是true |
逻辑运算符，是用来连接两个布尔类型结果的运算符，运算结果都是布尔值 true 或者 false。
public class Test{
public static void main(String[] args){
System.out.println(true && false); //false
System.out.println(3 < 4 && 10 > 5 );//true
System.out.println("=========");
System.out.println(true || false); //true
System.out.println(false || true); //true
System.out.println(false || false); //false
System.out.println("=========");
System.out.println(true);//true
System.out.println(!true);//false
System.out.println("=========");
int a = 10;
System.out.println(3 > 4 && ++a < 100); //false
System.out.println(a);//10
System.out.println("=========");
int b = 20;
System.out.println(3 < 4 || ++b < 100 );//true
System.out.println(b);//20
}
}5.三元运算符
a.三元运算符格式： 数据类型 变量名 = 布尔类型表达式？结果1：结果2
b.三元运算符计算方式：
布尔类型表达式结果是true，三元运算符整体结果为结果1，赋值给变量。
布尔类型表达式结果是false，三元运算符整体结果为结果2，赋值给变量。
注意：结果1和结果2类型一致，需要和前面的数据类型一致。
十、方法入门
1.概述
我们在学习运算符的时候，都为每个运算符单独的创建一个新的类和main方法，我们会发现这样编写代码非常的繁琐，而且重复的代码过多。能否避免这些重复的代码呢，就需要使用方法来实现。
方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。
当我们需要这个功能的时候，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。
2.方法的定义
a.定义格式：
修饰符 返回值类型 方法名 （参数列表）｛
//功能代码
return语句;
｝
b.定义格式解释：
修饰符： 影响方法的访问权限、行为和特性。常见的修饰符包括：public、protected、private、static、final、abstract。
返回值类型： 指定方法执行完后返回的值的类型，例如 int、String、double 、void等（void: 表示方法不返回任何值）。
方法名：为我们定义的方法起名，满足标识符的规范，用来调用方法。
参数列表： 包含方法接受的输入参数，用圆括号括起来；参数类型：指定每个参数的数据类型；参数名：是参数的标识符，在方法内部使用。
return：方法结束。如果返回值类型是void，方法大括号内的return可以不写。
c.举例：
public static void method() {
System.out.println("这是一个方法");
}3.方法的调用
a.方法在定义完毕后，方法不会自己运行，必须被调用才能执行，我们可以在主方法main中来调用我们自己定义好的方法。在主方法中，直接写要调用的方法名字就可以调用了。
public class Test{
//我
public static void me(){
System.out.println("吃");
}
//厨师
public static void cook(){
System.out.println("洗菜");
System.out.println("切菜");
System.out.println("炒菜");
System.out.println("装盘");
}
//农名伯伯
public static void farmer(){
//农名伯伯
System.out.println("播种");
System.out.println("浇水");
System.out.println("施肥");
System.out.println("除虫");
System.out.println("收割");
System.out.println("卖给小商贩");
}
//小商贩
public static void seller(){
//小商贩
System.out.println("运输到农贸市场");
System.out.println("抬高物价");
System.out.println("卖给厨子");
}
public static void main(String[] args){
//方法的调用
farmer();
seller();
cook();
me();
}
}b.流程图解
4. 调用方法的三种形式
a.直接调用：直接写方法名调用 。
public class Test {
public static void main(String[] args) {
print();
}
public static void print() {
System.out.println("方法被调用");
}
}b.赋值调用：调用方法，在方法前面定义变量，接收方法返回值 。
public class Test {
public static void main(String[] args) {
int sum = getSum(5,6);
System.out.println(sum);
}
public static int getSum(int a,int b) {
return a + b;
}
}c.输出语句调用：在输出语句中调用方法， System.out.println(方法名()) 。
public class Test {
public static void main(String[] args) {
System.out.println(getSum(5,6));
}
public static int getSum(int a,int b) {
return a + b;
}
}5. 方法重载
a.方法重载：指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返回值类型无关。
参数列表：个数不同，数据类型不同，顺序不同。
重载方法调用：JVM通过方法的参数列表，调用不同的方法。
b.方法重载练习
比较两个数据是否相等。参数类型分别为两个 byte 类型，两个 short 类型，两个 int 类型，两个 long 类型，并在main方法中进行测试。
/*
注意事项:
1.参数个数不同.
2.参数类型不同
4.参数的多类型顺序不同
方法重载与下列因素无关
1.与参数的名称无关
2.与方法的返回类型无关
总结:
方法的重载: 就是在一个类中方法名相同, 参数不同,(参数的个数,参数的类型不同,参数的顺序不同)
*/
public class Test {
public static void main(String[] args) {
//定义不同数据类型的变量
byte a = 10;
byte b = 20;
short c = 10;
short d = 20;
int e = 10;
int f = 10;
long g = 10;
long h = 20;
// 调用
System.out.println(compare(a, b));
System.out.println(compare(c, d));
System.out.println(compare(e, f));
System.out.println(compare(g, h));
}
// 两个byte类型的
public static boolean compare(byte a, byte b) {
System.out.println("byte");
return a == b;
}
// 两个short类型的
public static boolean compare(short a, short b) {
System.out.println("short");
return a == b;
}
// 两个int类型的
public static boolean compare(int a, int b) {
System.out.println("int"); return a == b;
}
// 两个long类型的
public static boolean compare(long a, long b) {
System.out.println("long");
return a == b;
}
}6.注意事项
a.方法的命名遵循小驼峰规范。
b.方法的定义先后顺序无所谓，不影响方法的执行顺序。
c.方法定义好，调用之后才会执行，不调用不执行。
d.方法定义的时候不能产生嵌套关系，但是方法里面可以调用其他方法。
e.返回值类型，必须要和 return 语句返回的类型相同，否则编译失败 。
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
