来到第二个学习日！我们来了解一些java的基础开发知识！！
Java中的开发工具：
- 系统自带的记事本：
- 优点： 不用安装 系统自带
- 缺点： 没有提示 没有颜色变化，没有行号
- 增强型记事本： notepad++ Editplus
- 优点：有高亮显示的代码 有颜色区分，有少量提示，有行号
- 缺点：提示功能不够强大，不利于构建大型的项目
- 集成的开发平台
- eclipse：开源免费 对插件的兼容性不是特别好
- MyEclipse： 收费
- IDEA：收费，个人使用免费，可以试用，也可以破解，可以集成各种插件，功能强大，自动提示功能很强，同时对电脑性能有一定要求，香的一批！
Java程序开发，企业中大多都使用idea进行开发，刚开始接触java的时候建议使用Editplus，可以提高代码的熟练度，后期有一定基础就可以用idea进行开发了。
注释：
- 注释的作用：解释说明代码的作用
- 开发者一般要求有30%的注释率
- 帮助开发者梳理思路
- 帮助我们定义错误代码，进行排错
- 被注释的内容，编译的时候并不会被识别，是一个无效的状态，只是方便我们自己阅读
- 分类：
- 单行注释：使用一行的区域来解释说明内容
- 格式： // 被注释掉的内容
- 特点： 不能换行 可以嵌套使用
- 多行注释：使用多行的区域来书写解释说明
- 格式：/* 被注释的内容 */
- 特点：可以跨行，不能嵌套使用
- 文档注释：
- 格式： /** 注释内容 */
- 单行注释：使用一行的区域来解释说明内容
代码：
//定义一个类 类名为HelloWorld
class HelloWorld {
//这是一个主方法 程序的唯一入口
/*
1、main方法是固定的写法
2、作为程序唯一入口
3、main方法中的语句的作用是输出HelloWorld
不能嵌套
*/
public static void main(String[] args) {
//这是一个输出语句，作用是输出HelloWorld
System.out.println("Hello World!");
//单行注释可以嵌套 // //
//在实际开发中，一般不会轻易删除代码，无用代码设置为注释
//完成输出HelloWorld
//1、定义一个类
//2、定义一个主方法
//3、书写输出语句
}
}
关键字：
java中提前定义好的具有特殊含义和功能的英文单词，全部小写，关键字不能作为标识符， 标识符：就是起的名。
java关键字共53个（其中包含两个保留字const，goto）
标识符：
- 用于给java中的类、接口、变量、抽象类、方法、数组等起名字的字符序列
- 组成内容：
- 所有的大小写英文字母
- 0-9的所有数字
- 英文下的$和_其他所有的英文符号都不能作为名字出现
- 其他国家的语言的字符：但是基本不用
- 注意：
- 不能和关键字重名
- 数字不能作为开头
- 最好见名知意
- 行业命名规范：
1.类和接口的命名：大驼峰命名，每个单词首字母大写
如：HelloWorld Person Teacher
2.变量命名：小驼峰命名，第一个单词首字母小写，从第二个单词开始首字母大写
如：lastDay maxNumber countPerson
3.方法命名：小驼峰命名，和变量名一样
4.常量命名：所有字母大写 单词之前下划线隔开
如：PI E MAX_OF_AGES
代码：
//类的命名首字母大写
class Demo01 {
public static void main(String[] args) {
//int public = 10; 错误名字 是关键字 不能和关键字一致
int number1 = 10;
//int number2 1 = 20; 不能有空格，有了空格number2就是一个单独的单词
int class_my_class = 10; //可以有下划线
int Number = 20; //java严格区分大小写 但是不符合命名规范，要求首字母小写
//int 1number = 10; // 数字不能作为开头
}
//方法命名，首个单词小写，后续单词大写
public void printHelloWorld(){
System.out.println("Hello World");
}
}常量:
- 常量：在程序运行过程中，其值不会发生改变的量
- 常量根据不同的表现分类：
- 字面值常量：写出常量的值，这个值就代表这个常量 1 -1 3.14
- 字符常量：给一个字面值常量设置符号，这个符号就代表这个字面值常量 PI
- 根据不同的数据类型：
- 基本数据类型的常量： 简单的数据类型
- 整数常量：所有的整数
- 小数常量：所有的小数
- 字符常量：使用单引号引起来的单个字符，就是字符常量’1’ ‘a’
- 布尔常量：用来表示真真假假的常量 只有两个值 true 真 false 假
- 引用数据类型的常量：使用基本数据类型组合成的类型，复杂的数据类型
- 字符串常量：使用双引号引起来的一系列字符就是字符串常量 “HelloWorld”
- 空常量：表示空 不指向任何类型 null
- 基本数据类型的常量： 简单的数据类型
代码：
class Demo02 {
public static void main(String[] args) {
//打印整数常量
System.out.println(1);
System.out.println(-1);
//打印小数常量
System.out.println(1.1);
System.out.println(-1.1);
//打印字符常量
System.out.println('a');
System.out.println('1');
System.out.println('!');
//System.out.println('ab'); 单引号引起来的只能有一个字符
System.out.println(' ');//空格也是一个字符
//字符常量打印 有且 只能有一个字符 不能没有
//System.out.println('');
//布尔类型常量
System.out.println(true);
System.out.println(false);
//字符串常量
System.out.println("HelloWorld");
System.out.println("一上午很快就过去了");
System.out.println("马上干饭");
System.out.println("");//可以打印什么都没有 相当于打印了一个换行符
//空常量 null不能用来打印 只能用来给引用数据类型赋值
//System.out.println(null);
}
}变量：
- 在程序运行过程中，其值会发生改变的量
- 定义格式：数据类型 变量名 = 变量值
- 使用变量的原因：在程序中有一些代表相同意义的数据，不断发生变化，例如年龄，定义一个不变的名称，对应是一块空间，来表示每一年都会发生变化的年龄，在内存中其实就是一块空间，空间的数据是不断发生变化的
代码：
class Demo03 {
public static void main(String[] args) {
//定义变量的格式
//数据类型 变量名 = 变量值;
//整数类型 int
//定义并赋值
int age = 17;//变量名 带着数据类型一定是声明一个变量
System.out.println(age);// 不带数据类型就是在使用一个变量
//过了一年，age变了
age = 18;
//这个变量其实就可以理解为在使用某一块空间
System.out.println(age);
//先定义
int num;
//赋值
num = 1;
System.out.println(num);
}
}变量的定义及作用范围
- 定义：
- 定义的同时并赋值 int a = 10;
- 先定义，后赋值 int a; 后续想要使用的时候再父子 a = 20;
- 定义在方法里边的变量一定要赋值才能使用
- 一个变量不能定义两次
- 变量的作用域
- 作用域：起作用的一个范围,出了这个范围就不能使用这个变量了！
- 变量的作用域：变量在哪个大括号的范围内定义声明，作用域就在哪个大括号中
代码：
class Demo04 {
public static void main(String[] args) {
int a = 10;//定义同时并赋值
int b;
int c;
System.out.println(a);
//System.out.println(b); 定义在方法内的变量一定要赋值之后才能使用
b = 20;//先定义 后赋值
System.out.println(b);
{
//c的范围在整个方法内
c = 20;
//int a = 20;// 同一个作用域内不能出现同名的变量
int d = 20;//作用域只在当前大括号内
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
}
//出了大括号不能，大括号中定义的 d 失效了
//System.out.println(d);
int d = 1;
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
}
}计算机存储单元：
- 计算机底层是使用二进制的方式存储数据的，计算机存储的最小的信息单元比特位(bit)。通常用b表示，8个比特位构成计算机中最基本的存储单元叫做字节(byte),通常用B
- 存储单位之间的换算关系：
- 8bit = 1B 0000 0000 - 1111 1111
- 1024B = 1KB
- 1024KB = 1MB
- 1024MB = 1GB
- 1024GB = 1TB
- 1024TB = 1PB
- 内存的概念：
- 笔记本：运行内存32G，当程序运行或者代码需要运行的时候，进入到内存中占有指定的空间运行，当程序或者代码运行完毕，释放内存，释放掉占有的空间位置。
- 硬盘2T： 固定存储，用来储存一些我们所需要的东西。
数据类型：
- Java是一门强类型语言，在定义变量的时候显式的说明变量在内存空间中所占的大小，空间的大小就是由数据类型决定的
- java的数据类型的分类：
- 基本数据类型：在jdk中已经定好的一些数据类型，这些类型无法添加，描述的都是一些简单的数据类型，基本数据类型代表的数值，都是数据本身
- 引用数据类型：描述的不是数据本身，而是描述真正的数据在内存中存储的地址，一般都是一些自定义的类，或者jdk中已经写好的类，引用相当于基本数据类型的组合，形成的复杂的类型
- 基本数据类型：四类八种
- 整数类型：
- long: 长整型 8个字节 -2^63~2^63-1
- int: 短整型 4个字节 -2^31~2^31-1
- short: 短整型 2个字节 -2^15~2^15-1
- byte: 字节 1个字节(8bit) -128~127
- 小数类型：
- float : 单精度的小数 4个字节
- double : 双精度的小数 8个字节
- 字符类型：
- char: 字符 2个字节 0~65535
- 布尔类型：
- boolean: 布尔 未知没有公布 true和false
- 整数类型：
代码：
class Demo05 {
public static void main(String[] args) {
//字节类型
byte b = 127;
System.out.println(b);
//短整型
short s = 100;
System.out.println(s);
//整型
int i = 1000;
System.out.println(i);
//长整型
long l = 100000;
System.out.println(l);
//单精度的小数
//java中所有的小数常量，默认都是double类型 float类型需要加上一个f F
float f = 3.14f;
System.out.println(f);
//双精度的小数
double d = 3.333;
System.out.println(d);
//字符类型
char c = 'A';
System.out.println(c);
//布尔类型
boolean result = false;
System.out.println(result);
}
}常量的默认类型：
- 整数类型的常量默认类型都是int，随便写出一个整数，只要是-2^31~2^31-1之间，就是使用int类型变量来存储这个整型数据（如果你写的整数超过了int的范围，此时只能使用long类型存储，如果表示一个long类型的数据，需要在这个量后面加上一个l L）
- 小数类型的常量默认是double（如果想要表示一个单精度小数，在小数后面加上f）
代码：
class Demo06 {
public static void main(String[] args) {
//int i = 4000000000;//表示一个过大的整数，这个数int装不下 只能用long
long i = 4000000000l;
System.out.println(i);
float f = 3.14f;
System.out.println(f);
}
}数据类型转换之隐式转换：
- 当小范围的数据类型的数据，给大范围的数据类型的数据赋值的时候，会把小范围的数据类型自动提升为大范围的数据类型的数据，然后使用大范围的类型来进行运算，运算结果还是大范围的
- 数据类型的范围从小到大
- byte < short = char < int < long < float < double
- 注意事项：
- byte、short、char在做运算的时候，自动向上转型，都转为int类型，最终结果也是int类型，两个int类型在做运算的时候则不会提升
代码:
class Demo07 {
public static void main(String[] args) {
byte b = 90;
int i = b;//将byte类型赋值给int类型
long l = i; //将int类型赋值给long类型
long result = l + 10;//10默认是int类型 l是long类型 int和long进行运算
//先将int转为long 两个long求和 最终结果还是long
System.out.println(result);
float f = result;
System.out.println(f);
double d = f;
System.out.println(d);
//字符比较特殊 是一个字 所有的字符在计算机中存储都是以数字的形式存储的
//数字和字符之间有一个对应关系 编码表
char c = 'a';
int i2 = c;
System.out.println(i2);
char c2 = 97;
System.out.println(c2);
byte b1 = 10;
byte b2 = 20;
//byte b3 = b1 + b2; //byte 、short、char三者之间做运算，最终结果一定是int类型
int b3 = b1 + b2;
System.out.println(b3);
short s1 = 20;
short s2 = 60;
int s3 = s1 + s2;
System.out.println(s3);
char c3 = 97;
int c4 = c3 + s2;
System.out.println(c4);
}
}数据类型转换之强制转换
- 大范围的数据类型，要转为小范围的数据类型，就要强制转换
- 格式：小范围的数据类型 新的名称 = (要转换的小范围的数据类型)大范围的数据类型的数据
- 强制转换的结果，可能跟你想的不太一样，一般是需要才去强转
代码：
class Demo08 {
public static void main(String[] args) {
int a = 100;//我想要转为byte
byte b = (byte)a;
System.out.println(b);
int a2 = 128;
//byte类型最大127
byte b2 = (byte)a2;// 大的范围往小的转，要考虑是否装的下，装的下就转
//装不下就不要转
System.out.println(b2);
float f = 1.7f;
long l = (long)f;
System.out.println(l);//小数往整数转换的时候，不会四舍五入，只保留整数部分
}
}字符类型：
- 使用单引号引起来的单个字符就是字符常量，对应的数据类型就是char
- 在计算中，所有的数据都是使用数字的形式来存储，字符也不例外
- 字符和计算机之间都有一个对应关系，每个字符都有自己的一个数字
- 从字符到数字的过程，称之为编码
- 从数字到字符的过程，称之为解码
- 编码表，别称“字符集”，最原始的编码表比较简单，只有英文和英文标点，最原始的叫做ASCII码表
5.每个国家都有自己的字符，中国的编码表GBK、GB2312前128个字符和ASCII码表都一直
6.每个国家都有自己的字符，为了统一，就设计出一张统一的编码表，Unicode
7.UTF-8：万国码表，使用1-3个字节表示所有的字符，其中中文占3个字节，英文占1个字节
8.使用：java中使用的Unicode，在磁盘上，默认是GBK，网页上最多的是UTF-8，无论哪个都是兼容ASCII码表
9.Java中表示字符使用的Unicode，表示一个字符的时候”\uXXXX” 表示任何数字对应的数据，每一个X都代表十六进制的数, \u代表Unicode
代码：
class Demo09 {
public static void main(String[] args) {
//字符 —— 数字 编码
char c = '0';
System.out.println((int)c);
//数字 —— 字符 解码
int i = 48;
char c2 = (char)i;
System.out.println(c2);
// a 97
System.out.println("\u0061");
System.out.println("\u0062");
char c3 = '杨';
System.out.println((int)c3);
//26472转为 十六进制 得到 6768
System.out.println("\u6768");
System.out.println("\u6587");
System.out.println("\u8c6a");
}
}字符串：
- 使用双引号引起来的字符序列，就是一个字符串类型的数据，如果是字符串类型的变量，存储的都是字符串那些字符在内存中对应的地址，是一个引用数据类型，java中的字符串类型：String
- 字符串可以和其他类型进行拼接，使用+拼接
- + 表示拼接，拼接之后，会把其他数据类型的数据，转为字符串类型，所有其他数据类型想要转换为字符串的时候，可以使用+进行拼接
- 最简单的转换字符串的方式： 其他数据类型 + “”;
代码：
class Demo10 {
public static void main(String[] args) {
//声明一个字符串类型的变量
String name = "Dragonl2d";//name中存储的是 Dragonl2d这个字符串常量在内存中的地址
System.out.println(name);
String age = "25";
System.out.println(age);
//我的名字：Dragonl2d，我的年龄：25岁
// + 表示拼接符号 括号内的内容可以是很长，但是最终的运算结果，只能有一个整体
// + 可以无限次拼接
System.out.println("我的名字：" + name + ",我的年龄：" + age);
double height = 180.0;
String str = "我的身高是:" + height;//其他数据类型和String类型运算的时候，会转为String类型在进行拼接
System.out.println(str);
System.out.println("我的名字：" + name + ",我的年龄：" + age + str);
//其他内容想要转为字符串，又不想改变原来的内容
boolean b = true;
String str2 = b + "";
int i = 1;
int i2 = 3;
System.out.println(i + "" +i2);
}
}运算符:
- 运算符：用来运算和操作数据的符号
- java中运算符的分类：
- 算数运算符
- 赋值运算符
- 比较运算符
- 逻辑运算符
- 三元运算符
- 位运算符
- 自增自减运算符
算数运算符:
- +
- 字符串拼接
- 表示两个数据和
- 表示正数
- -
- 表示两个数据差
- 表示负数
- *
- 表示乘法
- /
- 表示两个数的商
- %
- 用来求两个数据相除的余数部分
代码:
class Demo11 {
public static void main(String[] args) {
// +
int a = +20;//表示正数
int b = 20;
int sum = a + b;
System.out.println(sum);
String str = "Dragonl2d" + "比他同事帅";
System.out.println(str);
// -
int result = 100-50;
System.out.println(result);
int d = -100;//表示负数
System.out.println(d);
// *
result = 10 * 3;// 只是对于上面的result重新赋值
System.out.println(result);
// /
result = 15 / 3;
System.out.println(result);
result = 17 / 3;//两边如果都是整数，结果一定是整数
System.out.println(result);
//两边只要有一边是小数 结果就一定是小数
double r = 17 / 3.0;
System.out.println(r);
// %
int m = 10 % 3;
System.out.println(m);
double d2 = 10.3 % 2;//0.15 0
System.out.println(d2);
}
}赋值运算符:
- 作用：把赋值运算符右边的数据，赋值给左边的变量
- 基本的赋值运算符： =
- +=
- -=
- *=
- /=
- %=
代码:
class Demo12 {
public static void main(String[] args) {
int a = 3;// 3 是一个常量 等号的作用 就是将字面值常量赋值给a这个变量进行存储
System.out.println(a);
int b = 10;
// 想算 b + 2的值
b = b + 2;//计算式子的时候 都是先求出右边的值，再赋值给左边的变量
//可以使用 += 简化
b += 2;//作用与 b = b + 2;相同
System.out.println(b);
// -=
int c = 20;
//c = c - 10;
c -= 10;//将c原来的数 与10相减 得出结果再赋值给c
System.out.println(c);
// *=
int d = 5;
//d = d * 3;
d *= 3;
System.out.println(d);
// /=
int e = 10;
//e = e / 2;
e /= 2;
System.out.println(e);
//%=
int q = 10;
//q = q % 3;
q %= 3;
System.out.println(q);
}
}自增自减运算符:
- ++ 和--
- ++：自增运算符
- 作用：在某个变量的基础上再自增1
- ++在单独作为一行使用的时候，没有任何区别
- ++在运算中，或者在表达式中,++在变量前，先对变量+1，再取出变量的值进行运算，++在变量后，先取出变量的值进行运算，在进行+1
代码:
class Demo13 {
public static void main(String[] args) {
int a = 10;
// a++ a += 1; a = a + 1 三者等效;
a++;//在单独作为某一行使用的时候没有任何区别
System.out.println(a);
int b = 5;
System.out.println(b++);//++在后，先取值取值为5，将5给输出语句用 再加1 6
System.out.println(++b);//++在前，先自增 值为6+1 再给输出语句 7
int m = 3;
// m 4 5
// sum 4 + 3 + 4
int sum = ++m + 3 + m++;
System.out.println(m);//5
System.out.println(sum);//11
int q = 5;
// q 4 3 4
// r 4 + 2 + 4 + 3
int r = --q + 2 +q-- + q++;
System.out.println(q);// 4
System.out.println(r);// 13
}
}来三道练习题考验一下小伙伴是否有认真学习！
- int a = 5473; 求出各个位上的数
- int m = 5 ; int n = m++ + --m + 3 + --m; 求n （自己先计算，再运行，检验是否证）
- int q = 4; int p = (q++)*3 + (--q)*2 + 3; 求p （自己先计算，再运行，检验是否证）
比较运算符：
- 用于比较数据是否相等，或者是大小关系的运算符，运算结果都是boolean类型
- 分类：
- 是否相等 == ， != 这两个符号可以比较任意类型的数据
- 大小关系 > < >= <= 这四个只能比较基本数据类型的数据(整数、小数、字符)
- 判断左边的的值与右边的值是否满足某种关系
- 以上几种运算符，最终得出的结果，都是boolean类型的 true 或者false
代码:
class Demo15 {
public static void main(String[] args) {
// ==
//比较两个数据是否相同
boolean b = 10 == 20;//= 将右边的值赋值给左边的变量
// 10 == 20 这是一个式子，会得出一个值 false
// 将false赋值给b
System.out.println(b); //false
int a = 10;
int c = 20;
b = a == c;
System.out.println(b);//false
b = b == b;
System.out.println(b);//ture
//!=
b = a != c;
System.out.println(b); //ture
//大小关系
b = 10 < 5;
System.out.println(b); //false
b = 10 > 5;
System.out.println(b); //ture
b = 3 <= 3;
System.out.println(b); //ture
b = 4 >= 3;
System.out.println(b); ture
b = (3 == 3) != (3 >= 2);
System.out.println(b); //false
}
}逻辑运算符:
- 用来处理逻辑运算的符号
- 逻辑值：就是boolean的数据 真真假假就是所说的逻辑
- && || !
- &&逻辑与，同真为真，否则为假
- true && true true
- true && false false
- false && true false
- false && false false
- ||逻辑或，同假为假，否则为真
- true || true true
- true || false true
- false || true true
- false || false false
- ! 遇真为假，遇假为真
- ! true fasle
- ! false true
代码:
class Demo16 {
public static void main(String[] args) {
//短路与 &&
boolean b = false && true;
System.out.println(b);
//false代表一个值 有些式子的值也是false，也可以使用逻辑运算
b = (3 >= 2) &&(2 >= 1);
System.out.println(b);
// || 短路或
b = false || true;
System.out.println(b);
// !
b = !false;
System.out.println(b);
// 逻辑与 分为 短路与&& 和普通与 &
//在逻辑与中，如果第一个表达式的值为false，则第二个无论结果是怎么样最终结果都是false
//所以在短路与的情况，第二个式子就不在计算了
int i = 2;
//b = i < 1 && ++i>1;
b = i < 1 & ++i>1;
System.out.println(i);
// 逻辑或 分为短路或|| 和普通或 |
//在短路或中，如果第一个表达式的值为true，则第二个无论结果怎么样最终结果都是true
//所以在短路或中，第一个为true，第二个就不计算了
//b = i > 1 || ++i < 1;
b = i > 1 | ++i < 1;
System.out.println(b);
System.out.println(i);
}
}基础知道较多，理解性记忆，也不用过度担心，等后边重复多了就OK啦······
最后给个idea下载安装的教程··
Java开发工具：idea的下载安装、基本使用、介绍_dragonl2d的博客-CSDN博客
663
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
