2023.9.29 java学习 day01

最新推荐文章于 2024-11-04 22:26:34 发布

github_czy

最新推荐文章于 2024-11-04 22:26:34 发布

阅读量46

点赞数

文章标签： java 学习开发语言

本文链接：https://blog.csdn.net/m0_56366541/article/details/133418611

版权

一.什么是java

Java语言是美国Sun公司（Stanford University Network），在1995年推出的高级的编程语言。

Java语言主要应用在互联网程序的开发领域。常见的互联网程序比如天猫、京东、物流系统、网银系统等，以及服务器后台处理大数据的存储、查询、数据挖掘等也有很多应用。

二.java的运行方式

java语言离不开JVM，JRE，JDK

JVM（Java Virtual Machine ）：Java虚拟机，简称JVM，是运行所有Java程序的假想计算机，是Java程序的运行环境，是Java 最具吸引力的特性之一。我们编写的Java代码，都运行在 JVM 之上。

我们编写的程序运行在JVM上，而JVM 运行在操作系统上。

JVM本身不具备跨平台功能的，每个操作系统下都有不同版本的虚拟机。

JRE (Java Runtime Environment) ：是Java程序的运行时环境，包含 JVM 和运行时所需要的核心类库。

JDK (Java Development Kit)：是Java程序开发工具包，包含 JRE 和开发人员使用的工具。

我们想要运行一个已有的Java程序，那么只需安装 JRE 即可。

我们想要开发一个全新的Java程序，那么必须安装 JDK 。

java程序要运行起来，需要经历以下三个步骤：编写、编译、运行。

三.第一个java程序

在目录下新建一个HelloWorld.java文件，输入以下代码

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

保证文件名和类的名字是一致的，注意大小写

在cmd中，进入HelloWorld.java的目录，使用 javac 命令进行编译。

javac HelloWorld.java

会发现产生了一个.class文件，这个就是编译好的文件

在cmd中，进入HelloWorld.java的目录，使用 java命令进行运行。

java HelloWorld

注意：java 后面是类的名字，

四.java关键字，关键字，注释

Java中有单行注释和多行注释，

单行注释以 //开头换行结束

多行注释以 /*开头以*/结束

// 这里是单行注释
/*
    这里是多行注释
*/

关键字：是指在程序中，Java已经定义好的单词，具有特殊含义。

HelloWorld案例中，出现的关键字有 public 、 class 、 static 、 void 等，这些单词已经被 Java定义好，全部都是小写字母，关键字比较多，不能死记硬背，学到哪里记到哪里即可。

标识符：是指在程序中，我们自己定义内容。比如类的名字、方法的名字和变量的名字等等，都是标识符。 HelloWorld案例中，出现的标识符有类名字 HelloWorld 。

命名规则：

硬性要求标识符可以包含英文字母26个(区分大小写) 、 0-9数字、 $（美元符号）和 _（下划线）。标识符不能以数字开头。标识符不能是关键字。命名规范：

软性建议类名规范：首字母大写，后面每个单词首字母大写（大驼峰式）。方法名规范：首字母小写，后面每个单词首字母大写（小驼峰式）。变量名规范：全部小写。

五.java常量，变量，数据类型

常量：是指在Java程序中固定不变的数据。

常量分类：

整数常量所有的整数 0，1， 567， -9

小数常量所有的小数 0.0， -0.1， 2.55

字符常量单引号引起来,只能写一个字符,必须有内容 'a' ， ' '， '好'

字符串常量双引号引起来,可以写多个字符,也可以不写 "A" ，"Hello" ，"你好" ，""

布尔常量只有两个值（流程控制中讲解） true ， false

空常量只有一个值（引用数据类型中讲解） null

System.out.println("123");

变量：常量是固定不变的数据，那么在程序中可以变化的量称为变量。

变量分类：（默认类型：整数类型是 int 、浮点类型是 double ）

字节型 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

int a = 1;

六.数据类型转换、运算符、方法

Java程序中要求参与的计算的数据，必须要保证数据类型的一致性，如果数据类型不一致将发生类型的转换。

自动转换：将取值范围小的类型自动提升为取值范围大的类型。例如：byte 类型内存占有1个字节，在和 int 类型运算时会提升为 int 类型，自动补充3个字节，因此计算后的结果还是 int 类型。

转换规则：范围小的类型向范围大的类型提升， byte、short、char 运算时直接提升为 int 。

强制转换：将取值范围大的类型强制转换成取值范围小的类型。比较而言，自动转换是Java自动执行的，而强制转换需要我们自己手动执行。

int i = (int)1.5;

算数运算符：加减乘除

+ 加法运算，字符串连接运算

- 减法运算

* 乘法运算

/ 除法运算

% 取模运算，两个数字相除取余数

++ 、 -- 自增自减运算

public static void main(String[] args) {
    int i = 1234;
    System.out.println(i/1000*1000);//计算结果是1000
}

赋值运算符：等于

= 等于号

+= 加等于

-= 减等于

*= 乘等于

/= 除等于

%= 取模等

public static void main(String[] args){
    int i = 5;
    i+=5;//计算方式 i=i+5 变量i先加5，再赋值变量i
    System.out.println(i); //输出结果是10
}

比较运算符：大于小于

== 比较符号两边数据是否相等，相等结果是true。

< 比较符号左边的数据是否小于右边的数据，如果小于结果是true。

> 比较符号左边的数据是否大于右边的数据，如果大于结果是true。

= 比较符号左边的数据是否大于或者等于右边的数据，如果小于结果是true。

！= 不等于符号，如果符号两边的数据不相等，结果是true。

public static void main(String[] args) {
    System.out.println(1==1);//true
    System.out.println(1<2);//true
    System.out.println(3>4);//false
    System.out.println(3<=4);//true
    System.out.println(3>=4);//false
    System.out.println(3!=4);//true
}

逻辑运算符：与或非

&& 短路与 1. 两边都是true，结果是true 2. 一边是false，结果是false 短路特点：符号左边是false，右边不再运算

|| 短路或 1. 两边都是false，结果是false 2. 一边是true，结果是true 短路特点：符号左边是true，右边不再运算

！取反 1. ! true 结果是false 2. ! false结果是true

三元运算符：如果表达式成立，取第一个值，表达式不成立，取第二个值

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
}

方法的定义

public static void methodName() {
System.out.println("这是一个方法");
}

方法的调用

public static void main(String[] args) {
//调用定义的方法method
method();
}
//定义方法，被main方法调用
public static void method() {
System.out.println("自己定义的方法，需要被main调用运行");
}

七.流程控制 if-else if-else if-else swith for while do-while

public static void main(String[] args){
// 判断给定的数据是奇数还是偶数
// 定义变量
int a = 1;
if(a % 2 == 0) {
System.out.println("a是偶数");
} else{
System.out.println("a是奇数");
}
System.out.println("结束");
}

public static void main(String[] args) {
// x和y的关系满足如下：
// x>=3 y = 2x + 1;
//‐1<=x<3 y = 2x;
// x<=‐1 y = 2x – 1;
// 根据给定的x的值，计算出y的值并输出。
// 定义变量
int x = 5;
int y;
if (x>= 3) {
y = 2 * x + 1;
} else if (x >= ‐1 && x < 3) {
y = 2 * x;
} else {
y = 2 * x ‐ 1;
}
System.out.println("y的值是："+y);
}

public static void main(String[] args) {
//定义变量，判断是星期几
int weekday = 6;
//switch语句实现选择
switch(weekday) {
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("你输入的数字有误");
break;
}
}

public static void main(String[] args) {
//1.定义一个初始化变量,记录累加求和,初始值为0
int sum = 0;
//2.利用for循环获取1‐100之间的数字
for (int i = 1; i <= 100; i++) {
//3.判断获取的数组是奇数还是偶数
if(i % 2==0){
//4.如果是偶数就累加求和
sum += i;
}
}
//5.循环结束之后,打印累加结果
System.out.println("sum:"+sum);
}

public static void main(String[] args) {
//while循环实现打印10次HelloWorld
//定义初始化变量
int i = 1;
//循环条件<=10
while(i<=10){
System.out.println("HelloWorld");
//步进
i++;
}
}

public static void main(String[] args) {
int x=1;
do {
System.out.println("HelloWorld");
x++;
}while(x<=10);
}

跳出语句主要使用brek或continue

public static void main(String[] args) {
for (int i = 1; i<=10; i++) {
//需求:打印完两次HelloWorld之后结束循环
if(i == 3){
break;
}
System.out.println("HelloWorld"+i);
}
}

public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
//需求:不打印第三次HelloWorld
if(i == 3){
continue;
}
System.out.println("HelloWorld"+i);
}
}

八.具有返回值的方法

public class Method_Demo2 {
public static void main(String[] args) {
// 调用方法getSum，传递两个整数，这里传递的实际数据又称为实际参数
// 并接收方法计算后的结果，返回值
int sum = getSum(5, 6);
System.out.println(sum);
}
/*
定义计算两个整数和的方法
返回值类型，计算结果是int
参数：不确定数据求和，定义int参数.参数又称为形式参数
*/
public static int getSum(int a, int b) {
return a + b;
}
}

注意： return 的值的类型要与方法类型一致

直接调用：直接写方法名调用

public static void main(String[] args) {
print();
}
public static void print() {
System.out.println("方法被调用");
}

赋值调用：调用方法，在方法前面定义变量，接收方法返回值

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;
}

方法重载：指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返回值类型无关。参数列表：个数不同，数据类型不同，顺序不同。重载方法调用：JVM通过方法的参数列表，调用不同的方法

注意：虽然方法名相同，但如果接受的函数与返回值不同则jvm会认为它们是不同的函数

public class Method_Demo6 {
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;
}
}

这里面的函数就是因为参数不同，被jvm认为是不同函数

九.数组

数组的定义：

        int[] arr = new int[1];
        int[] arr2 = new int[]{1,2};
        int[] arr3 = {1,2,3};

数组的访问：

arr2[0] = 6;
System.out.println(arr2[0]);

arr2此时保存的是数组在内存中的地址，如果数组没有初始化则自动认为全0

arr=arr2时，是将同一个数组地址传递给了arr，类似于c语言中的指针

常见操作：

越界：

public static void main(String[] args) {
int[] arr = {1,2,3};
System.out.println(arr[3]);
}

数组中没有第四个元素，我们却访问了第四个，会报ArrayIndexOutOfBoundsException的错误

空指针：

public static void main(String[] args) {
int[] arr = {1,2,3};
arr = null;
System.out.println(arr[0]);
｝

arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出 NullPointerException 空指针异常。

遍历：

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]);
}
}

作为方法参数和返回值：

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]);
}
}

public static void main(String[] args) {
//调用方法，接收数组的返回值
//接收到的是数组的内存地址
int[] arr = getArray();
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
public static int[] getArray() {
int[] arr = { 1, 3, 5, 7, 9 };
//返回数组的地址，返回到调用者
return arr;
}