JAVA基础语法01-05
day01【前言、入门程序、常量、变量】
1.
按下Windows+R键盘，打开运行窗口，输入cmd回车，进入到DOS操作窗口。
2.
命令 操作符号
盘符切换命令 盘符名: 不区分大小写
查看当前文件夹 dir
进入文件夹命令 cd 文件夹名 按table，可以选当前页面的文件夹
退出文件夹命令 cd..
退出到磁盘根目录 cd\
清屏 cls
退出 exit
3.
JRE (Java Runtime Environment) ：是Java程序的运行时环境，包含 JVM 和运行时所需要的 核心类库 。
JDK (Java Development Kit)：是Java程序开发工具包，包含 JRE 和开发人员使用的工具。
我们想要运行一个已有的Java程序，那么只需安装 JRE 即可。
我们想要开发一个全新的Java程序，那么必须安装 JDK 。
三者关系： JDK > JRE > JVM
4.
Java程序开发三步骤：编写、编译、运行。
5.
编译和运行是两回事
编译：是指将我们编写的Java源文件翻译成JVM认识的class文件，在这个过程中， javac 编译器会检查我们
所写的程序是否有错误，有错误就会提示出来，如果没有错误就会编译成功。
运行：是指将 class文件 交给JVM去运行，此时JVM就会去执行我们编写的程序了。
运行源文件：每次运行都要重新两行
将文件目录切换到你要编译的文件的目录：
javac HelloWorld.java
java HelloWorld
6.
main：是程序执行的起点
标识符：是指在程序中，我们自己定义内容。比如类的名字、方法的名字和变量的名字等等，都是标识符。 、
命名规则： 硬性要求
标识符可以包含 英文字母26个(区分大小写) 、 0-9数字 、 $（美元符号） 和 _（下划线） 。
标识符不能以数字开头。
标识符不能是关键字。
命名规范： 软性建议
类名规范：首字母大写，后面每个单词首字母大写（大驼峰式）。Helloworld
方法名规范： 首字母小写，后面每个单词首字母大写（小驼峰式）。helloWorld
变量名规范：全部小写。
7.
常量：在程序运行期间，固定不变的量
常量的分类：
1.字符串常量：凡是用双引号引起来的部分。如：“abc”、“hello”
2.整数常量：直接写上的数字，没有小数点。如：100、0、200
3.浮点数常量：直接写上的数字，有小数点。如：2.5、-3.14
4.字符常量：凡是用单引号引起来的单个字符。如：‘A’、‘B’、‘9’ -- 打印的时候，单引号之间没有字母或者两个字母都不可以
5.布尔常量：只有两种取值。true、false
6.空常量：null。代表没有任何数据 ------ 不能直接打印输出
Java的数据类型分为两大类：
基本数据类型：包括 整数(byte.short.int.long).--浮点数(float\double).--字符(char). --布尔(boolean) 。
引用数据类型：包括 类 、 数组 、 接口 ，字符串，lambda。。。
注意事项：
1.java中字符串不是基本数据类型，是引用类型！
2.浮点型可能只是一个近似值，并非精确值。
3.数据范围与字节数不一定相关，例如float数据范围比long更加广泛，但是float是4字节，long是8字节
4.浮点数当中默认类型是double，如果一定要使用float类型，需要加一个后缀 F
如果是整数，默认为int类型，如果一定使用long类型，需要加上一个后缀L，推荐使用大写字母后缀
8.
byte 1个字节（8 bit） -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
9.
day02 【数据类型转换、运算符、方法入门】
1.
自动转换：将 取值范围小的类型 自动提升为 取值范围大的类型 。
public static void main(String[] args) {
int i = 1;
byte b = 2;
// byte x = b + i;
// 报错 //int类型和byte类型运算，结果是int类型
int j = b + i;
System.out.println(j);
}同样道理，当一个 int 类型变量和一个 double 变量运算时， int 类型将会自动提升为 double 类型进行运算。
byte、short、char‐‐>int‐‐>long‐‐>float‐‐>double
注意事项：
1.强制类型转换一般不推荐使用，可能会发生精度损失，数据溢出
2.byte/short/long这三种类型都可以发生数学运算，例如加法“+”
3.byte/short/long这三种类型在运算时，都会被首先提升为int类型，然后计算
4.boolean类型不能发生数据类型转换
2.
强制类型转换：
将 取值范围大的类型 强制转换成 取值范围小的类型 。
浮点转成整数，直接取消小数点，可能造成数据损失精度。
int 强制转成 short 砍掉2个字节，可能造成数据丢失。
// double类型数据强制转成int类型，直接去掉小数点。
int i = (int)1.5;byte x = 1;
byte y = 2;
int z = x + y; //这是对的
byte z = x + y; // 这是错的3.
ASCII编码表
0 48
A 65
a 97
public static void main(String[] args) {
//字符类型变量
char c = 'a';
int i = 1;
//字符类型和int类型计算
System.out.println(c+i);
//输出结果是98
}4.
独立运算：
变量在独立运算时， 前++ 和 后++ 没有区别 。
混合运算：
变量前++ ：【先加后用】变量a自己加1，将加1后的结果赋值给b，也就是说a先计算。a和b的结果都是2。
public static void main(String[] args) {
int a = 1;
int b = ++a;
System.out.println(a);
//计算结果是2
System.out.println(b);
//计算结果是2
}变量 后++ ：【先用后加】变量a先把自己的值1，赋值给变量b，此时变量b的值就是1，变量a自己再加1。a的结果是2，b
的结果是1。
public static void main(String[] args) {
int a = 1;
int b = a++;
System.out.println(a);
//计算结果是2
System.out.println(b);
//计算结果是1
}四则运算当中的加号“+”有常见的三种用法
1.对于数值来说，那就是加法。
2.对于字符char类型来说，在计算之前，char会被提升成为int，然后再计算。
char类型字符和int类型数字，之间的对照关系表：ASCLL、Unicode
3.对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作。
任何数据类型和字符串进行连接的时候，结果都会变成字符串
只要遇到字符串，就算整数，那也是直接加，如 5+5--->55
byte num = 30;
// num = num + 5
// num = byte + int
// num = int + int
// num = int
// num = (byte)int
num += 5
System.out.println(num); // 355.
逻辑运算符包括：
&& 短路与 : 短路特点：符号左边是false，右边不再运算
|| 短路或 : 短路特点： 符号左边是true，右边不再运算
6.
三元运算符计算方式：
布尔类型表达式结果是true，三元运算符整体结果为结果1，赋值给变量。
布尔类型表达式结果是false，三元运算符整体结果为结果2，赋值给变量。
public static void main(String[] args) {
int i = (1==2 ? 100 : 200);
System.out.println(i); //200
int j = (3<=4 ? 500 : 600);
System.out.println(j); //500
}7.
方法定义注意事项：
方法必须定义在一类中 并且在其他方法外
方法不能定义在另一个方法的里面
public static void main(String[] args) {
//调用定义的方法method
method();
}
//定义方法，被main方法调用
public static void method() {
System.out.println("自己定义的方法，需要被main调用运行");
}8.
public static void main(String[] args){
short s = 1;
s+=1;
System.out.println(s);
}分析： s += 1 逻辑上看作是 s = s + 1 计算结果被提升为int类型，再向short类型赋值时发生错误，因为不能将取值范围
大的类型赋值到取值范围小的类型。但是， s=s+1进行两次运算 ， += 是一个运算符，只运算一次，并带有强制转换的特点，
也就是说 s += 1 就是 s = (short)(s + 1) ，因此程序没有问题编译通过，运行结果是2.
9.
public static void main(String[] args){
byte b1=1;
byte b2=2;
byte b3=1 + 2;
byte b4=b1 + b2;
System.out.println(b3);
System.out.println(b4);
}分析： b3 = 1 + 2 ， 1 和 2 是常量，为固定不变的数据，在编译的时候（编译器javac），已经确定了 1+2 的结果并没
有超过byte类型的取值范围，可以赋值给变量 b3 ，因此 b3=1 + 2 是正确的。
反之， b4 = b2 + b3 ， b2 和 b3 是变量，变量的值是可能变化的，在编译的时候，编译器javac不确定b2+b3的结果是什
么，因此会将结果以int类型进行处理，所以int类型不能赋值给byte类型，因此编译失败。
1.对于byte/short/char三种类型来说，如果右侧赋值的数值没有超过范围，
那么javac编译器将会自动隐含地为我们补上（byte）（short）（char）
2.这称为“编译器的常量优化”，但是一旦表达式有变量参与，就不能进行这种优化。
day03【 流程控制语句】
1.判断语句1--if
if(关系表达式)｛
语句体;
｝2.判断语句2--if...else
if(关系表达式) {
语句体1;
}else {
语句体2;
}3.判断语句3--if..else if...else
if (判断条件1) {
执行语句1;
} else if (判断条件2) {
执行语句2;
}
...
}else if (判断条件n) {
执行语句n;
} else {
执行语句n+1;
}4.选择语句--switch
switch(表达式) {
case 常量值1:
语句体1;
break;
case 常量值2:
语句体2;
break;
...
default:
语句体n+1;
break;
}注意事项：
1.多个case后面的数值不可以重复。
2.switch后面的小括号只能是以下数据类型：
基本数据类型：byte / short / char / int
引用数据类型：String字符串、enum枚举
3.switch语句格式很灵活：前后顺序可以颠倒，而且break可以省略，但是会发生穿透效果
在switch语句中，如果case的后面不写break，将出现穿透现象，也就是不会在判断下一个case的值，
直接向后运行，直到遇到break，或者整体switch结束。
5.循环语句1--for
for(int i=0; i<10; i++){
System.out.println(i);
}
// 01234567896.循环语句2--while
int a = 10;
while(a>1){
System.out.println(a);
a--;
}//10987654327.循环语句3--do...while
int a = 10;
do{
System.out.println(a);
a--;
}while(a>0);
// 109876543218.
for 和 while 的小区别：
控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，
while循环结束还可以继续使用，
原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。
在已知循环次数的时候使用推荐使用for，循环次数未知的时推荐使用while。
9.
break ：直接终止switch或者循环 ，下面的循环都不做了，跳出循环
continue ：结束本次循环剩余内容，马上继续下一次的循环
day04【 Idea、方法】
1.
我们创建的项目，在d:\ideawork目录的demo下
.idea 目录和 demo.iml 和我们开发无关，是IDEA工具自己使用的
out 目录是存储编译后的.class文件
src 目录是存储我们编写的.java源文件
2.
快捷键 功能
Alt+Enter 导入包，自动修正代码
Ctrl+Y 删除光标所在行
Ctrl+D 复制光标所在行的内容，插入光标位置下面
Ctrl+Alt+L 格式化代码
Ctrl+/ 单行注释
Ctrl+Shift+/ 选中代码注释，多行注释，再按取消注释
Alt+Insert 自动生成代码，toString，get，set等方法
Alt+Shift+上下箭头 移动当前代码行
智能提示：在detting的keymap，可以先复制一份快捷键，再重新编辑你想要的。
3.定义方法的格式
(1) 5.fori == for(int i=0;i<5;i++){}
(2) 注意事项：
1.方法定义的先后顺序无所谓
2.方法定义必须是挨着的，不能在一个方法的内部定义另外一个方法
3.方法定义后，自己不会执行；如果希望执行，一定要进行方法的调用
（3）
修饰符 返回值类型 方法名(参数列表){
//代码省略...
return 结果;
}
// 修饰符： public static 固定写法
// 返回值类型： 表示方法运行的结果的数据类型，方法执行后将结果返回到调用者
// 参数列表：方法在运算过程中的未知数据，调用者调用方法时传递
// return：将方法执行后的结果带给调用者，方法执行到 return ，整体方法运行结束不能在 return 后面写代码， return 意味着方法结束，所有后面的代码永远不会执行，属于无效代码。
4.调用方法的三种形式
1.直接调用：方法名（参数）；
2.打印调用：System.out.println(方法名（参数）)；
3.赋值调用： 数据类型 变量名 = 方法名称（参数）；
不能用输出语句调用 void 类型的方法。因为方法执行后没有结果，也就打印不出任何内容。
5.
使用方法注意事项：
1.方法应该在类当中，但是不能在方法中再定义方法，不能嵌套。
2.方法定义的前后顺序无所谓。
3.方法定义之后不会执行，如果希望执行，一定要调用：单独调用、打印调用、赋值调用。
4.如果方法有返回值，那么必须写上“return 返回值”，不能没有。
5.return后面的返回值数据。必须和方法的返回值类型，对应起来。
6.对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己。
7.对于void方法当中最后一行的return可以省略不写。
8.一个方法当中可以有多个return语句，但是必须保证同时只有一个会被执行到，两个return不能连写。
6.方法重载（OverLoad）
好处：只需要记住唯一一个方法名称，就可以实现类似的多个功能。
方法重载与下列因素相关：有效
1.参数个数不同
2.参数类型不同
3.参数的多类型顺序不同
方法重载与下列因素无关：无效
1.与参数的名称无关
2.与方法的返回值类型无关
按住Ctrl然后点击，可以直接阅读JDK源码！！！
day05【数组】
1.
容器：是将多个数据存储到一起，每个数据称为该容器的元素。
数组概念： 数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。
数组的定义：
// 注意：数组有定长特性，长度一旦指定，不可更改。
// 方式一：格式： 数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];
int[] arr = new int[3];
// 方式二：格式： 数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
int[] arr = new int[]{1,2,3,4,5};
// 方式三：格式：数据类型[] 数组名 = {元素1,元素2,元素3...};
int[] arr = {1,2,3,4,5};直接打印数组名称，得到的是数组对应得：内存地址哈希值。
应该用循环啥的去遍历，或者根据索引去取。
使用动态初始化数组得时候，其中得元素将会自动拥有一个默认规则。规则如下：
1.如果是整数类型，那么默认为0
2.如果是浮点类型，那么默认是0.0
3.如果是字符类型，那么默认为‘\u0000’
4.如果是布尔类型，那么默认为false
5.如果是引用类型，那么默认为null
2.JVM的内存划分：
一个数组的情况：
两个数组的情况：
数组赋值数组就是直接一样：
package hello1;
public class test1 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
System.out.println("==================");
// 反转数组
for (int min=0,max=arr.length-1 ; min<max ; min++,max--){
int temp = arr[min];
arr[min] = arr[max];
arr[max] = temp;
}
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
// 实现数组的反转3.数组作为方法参数
数组作为方法参数传递，传递的是数组的地址值。
package hello1;
public class test1 {
public static void main(String[] args) {
int[] arr = { 1, 3, 5, 7, 9 };
//调用方法，传递数组
printArray(arr);
}
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
System.out.println("arr的地址值是：");
System.out.println(arr);
}
}
/*
1
3
5
7
9
arr的地址值是：
[I@1cd072a9
*/4.数组作为方法返回值
数组作为方法的返回值，返回的是数组的内存地址
package hello1;
public class test1 {
public static void main(String[] args) {
int[] result = calculate(10, 20, 30);
System.out.println("main方法接收到的返回值数组是：");
System.out.println(result); // 地址值
System.out.println("总和：" + result[0]);
System.out.println("平均数：" + result[1]);
}
public static int[] calculate(int a,int b, int c){
int sum = a+b+c; //总和
int avg = sum / 3; //平均数
// 两个结果都希望返回
// 需要一个数组，也就是一个塑料兜，数组可以保存多个结果
/*int[] array = new int[2];
array[0] = sum; // 总和
array[1] = avg; // 平均数*/
int[] array = {sum, avg};
System.out.println("array的地址值是：");
System.out.println(array);
return array;
}
}
/*
array的地址值是：
[I@1cd072a9
main方法接收到的返回值数组是：
[I@1cd072a9
总和：60
平均数：20
*/总结:
方法的参数为基本类型时,传递的是数据值. 方法的参数为引用类型时,传递的是地址值.
面向对象和封装06
day06【类与对象、封装、构造方法】
1.
类：是一组相关属性和行为的集合。可以看成一类事物的模板，用事物的属性特征和行为特征描述该类事物。
属性：就是该事物的状态信息。
行为：就是该事物能够做什么。
对象：一类事物的具体体现。对象是类的一个实例，必然具备该类事物的属性和行为。
类与对象的关系
类是对一类事物的描述，是抽象的。
对象是一类事物的实例，是具体的。
类是对象的模板，对象是类的实体。
2.类的定义格式
定义类：就是定义类的成员，包括成员变量和成员方法。
成员变量：和以前定义变量几乎是一样的。只不过位置发生了改变。在类中，方法外。
成员方法：和以前定义方法几乎是一样的。只不过把static去掉.
public class Student {
//成员变量
String name；//姓名
int age；//年龄
//成员方法
//学习的方法
public void study() {
System.out.println("好好学习，天天向上");
}
//吃饭的方法
public void eat() {
System.out.println("学习饿了要吃饭");
}
}3.对象的使用格式
成员变量的默认值：
数据类型 默认值
基本类型 整数（byte，short，int，long） 0
浮点数（flfloat，double） 0.0
字符（char） '\u0000'
布尔（boolean） false
引用类型 数组，类，接口 null
/*
1.导包：也就是指出需要使用的类，在什么位置。
import 包名称.类名称
import cn.itcast.day06.demo01.Student;
对于和当前类属于同一个包的情况，可以省略导包语句不写。
2.创建，格式：
类名称 对象名称 = new 类名称（）；
Student stu = new Student（）；
3.使用，分两种情况：
使用成员变量：对象名.成员变量名
使用成员方法：对象名.成员方法名（参数）
（也就是，想用谁，就用对象名点儿谁。）
注意事项：
如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。
*/
package hello1;
public class test1 {
public static void main(String[] args) {
// 1.导包
// 我需要使用的Student类，和我自己Demo02Student位于同一个包下，所以省略导包语句不写
// 2.创建，格式：
// 类名称 对象名 = new Student（）；
//根据Student类，创建了一个名为stu的对象
Student stu = new Student();
// 3. 使用其中的成员变量，格式：
// 对象名.成员变量名
System.out.println(stu.name); // null
System.out.println(stu.age); // 0
// 改变对象中的成员变量数值内容
// 将右侧的字符串，赋值交给stu对象中的name成员变量
stu.name = "赵丽颖";
stu.age = "18";
System.out.println(stu.name);
System.out.println(stu.age);
// 4.使用对象的成员方法，格式：
// 对象名.成员方法名（）
stu.eat();
}
}
4.
在类中的位置不同 重点
成员变量：类中，方法外
局部变量：方法中或者方法声明上(形式参数)
作用范围不一样 重点
成员变量：类中
局部变量：方法中
初始化值的不同 重点
成员变量：有默认值
局部变量：没有默认值。必须先定义，赋值，最后使用
在内存中的位置不同 了解
成员变量：堆内存
局部变量：栈内存
生命周期不同 了解
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
5.封装
封装的步骤
1. 使用 private 关键字来修饰成员变量。
2. 对需要访问的成员变量，提供对应的一对 getXxx 方法 、 setXxx 方法。
private的含义
1. private是一个权限修饰符，代表最小权限。
2. 可以修饰成员变量和成员方法。
3. 被private修饰后的成员变量和成员方法，只在本类中才能访问。
private的使用格式 ： private 数据类型 变量名 ；
1. 使用 private 修饰成员变量，代码如下：
public class Student {
private String name;
private int age;
}
2. 提供 getXxx 方法 / setXxx 方法，可以访问成员变量，代码如下：
public class Student {
private String name;
private int age;
public void setName(String n) {
name = n;
}
public String getName() {
return name;
}
6.
this的含义
this代表所在类的当前对象的引用（地址值），即对象自己的引用。
记住 ：方法被哪个对象调用，方法中的this就代表那个对象。即谁在调用，this就代表谁。
this使用格式 ：this.成员变量名；
小贴士：方法中只有一个变量名时，默认也是使用 this 修饰，可以省略不写。
public class Student {
private String name;
private int age;
public void setName(String name) {
//name = name;
this.name = name;
}
public String getName() {
return name;
}
}7.构造方法的定义格式
修饰符 构造方法名(参数列表){
// 方法体
}
public class Student {
private String name;
private int age;
// 无参数构造方法
public Student() {}
// 有参数构造方法
public Student(String name,int age) {
this.name = name;
this.age = age;
}
}注意事项
1. 如果你不提供构造方法，系统会给出无参数构造方法。
2. 如果你提供了构造方法，系统将不再提供无参数构造方法。
3. 构造方法是可以重载的，既可以定义参数，也可以不定义参数。
扫一扫
2819
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
