Java初学

ys52IT

已于 2024-03-17 10:15:38 修改

阅读量465

点赞数 5

分类专栏： Java 文章标签： java 开发语言

于 2024-03-07 10:06:30 首次发布

本文链接：https://blog.youkuaiyun.com/ys1215/article/details/136522941

版权

Java 专栏收录该内容

3 篇文章

订阅专栏

1、永不过时的HelloWorld

public class Hello，用于定义一个公共类的关键字。在Java中，类是一种面向对象编程的基本构建块，它封装了数据和方法，并提供了对他们的访问控制。其中Hello是类名。
public static void main的简写psvm。它是方法，程序的入口方法
public static void main 是java程序的主入口方法，它是程序执行的起点。当运行一个Java程序时，JVM会自动调用这个方法。在这个方法中，你可以编写程序的逻辑代码。

System.out.println 的简写sout，用于在控制台输出信息。

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

2、标识符规则

标识符由字符、数字、下划线、汉字、美元符号"$"组成，第一个符号不能是数字。
不能把java关键字和保留字作为标识符。
标识符没有长度限制。
标识符对大小写敏感。

3、常量与变量

无论是常量还是变量的定义都是在类中进行的，常量的定义如下：

定义常量，在改常量声明的时候赋值，后面就不可以变更其值

变量名称：所有的字母全部大写，如果是多个单词组成、单词之间以下划线连接

定义常量的语法：final 数据类型常量名 = 初始值；

//定义一个类，文件名和类名保持一致
public class Demo1{
    /**
	*修饰符：
	*public：公共的、基础的，一旦成员被public修饰那么该成员可以在任意的地方调用
	*
	*static：被static修饰的成员优先被装载到内存中，反之则后被加载
	*
	*final：最终的、最后的、如果成员(变量)被final修饰，则表示该成员（变量）无法被重新赋值
    **/
    public static final double decimals=3.15;
    //定义变量
    int x=10;
}

4、数据类型

基本数据类型

整形（int、byte、short），占4、1、2

//基本数据类型
int age=10;
//除于2.2
 System.out.println(age/2.2);

浮点型（float、double），占4/8个字节

字符型（char），2个字节

//定义一个字符型，单引号中间只能存在一个字符
char r='1';

字符串（string），不是基本数据类型，而是Java中的类，用于表示一系列字符

//定义一个字符串
String str="哈哈哈";
//字符串连接符 +
System.out.println(str + 10 + 20);

布尔型（Boo lean）

类型转换

自动转换：取值范围（表数范围）小的向取值范围大的数据类型转换，java能自动实现转换
```
double a=10;
System.out.println(a);
//最后结果是10.0
```
强制转换：取值范围大的向取值范围小的转换，需要强制转换，强制转换容易出现精度丢失。
```
double d=100.6;
int x=(int)d;
System.out.println(x);
//最后结果就是100
```

注意事项：

Boolean不参与类型转换
byte、short、char如果转换，需要先转成int然后再转
字符类型转成int类型的原因是每个字都有一个数字与之对应（字符编码)
```
char c="中";
System.out.println((int)c);
```

5、算术运算符

加法	减法	乘法	除法	取余	自增	自减
+	-	*	/	%	++	--

关系运算符

相等	不等	大于	小于	大于等于	小于等于
==	！=	>	<	>=	<=

逻辑运算符

与	或	非
&&	\|\|	！=

在Java中，单&和双&&都是逻辑与操作符，但它们之间有一些区别：

单&（按位与）操作符：当两个操作数都为true时，结果为true；否则，结果为false。它主要用于整数类型的按位运算。
双&&（逻辑与）操作符：它是短路操作符，当第一个操作数为false时，不会计算第二个操作数，直接返回false；只有当第一个操作数为true时，才会计算第二个操作数。如果两个操作数都为true，结果为true；否则，结果为false。

单|和双||的区别

单个| 是无论前面是否为真，都判断后面的语句
双|| 是前面为真，就不执行后面的语句了

注意：括号里面加个！，表示取反

sSystem.out.println(!(3>2  || 5>3))

条件运算符（三元运算符）

public class Test{
	public static void main(String[] args){
	int a,b;
     a = 10;
     // 如果a等于1成立，则设置b为 20，否则为 30
     b = (a==1)?20:30;
     System.out.println("value of b is :" + b);
	}
}

赋值运算符

等于	加等于	减等于	乘等于	除等于	取余等于
=	+=	-=	*=	/=	%=

a+=b就等于a=a+b

6、语句

流程控制

顺序流程：代码的执行顺序是自左向右，自上而下的顺序执行

if

格式一：

if（逻辑表达式）{
    当逻辑表达式的结果为true时执行的代码
}

格式二：

if（逻辑表达式）{
    当逻辑表达式的结果为true时执行的代码
}else{
    当逻辑表达式的结果为false时执行的代码
}

格式三：

if(逻辑表达式1){

}else if(逻辑表达式2){

}else if(逻辑表达式3){

}else{
	表示以上所有的逻辑表达式都不成立时所执行的代码
}

switch

名词解释：

· case穿透：从某个符合情况的case开始一直向下执行直至遇到结束语句或者整体执行完成。

（整体的意思可以理解为当该变量的值等于某个case后面的值时，执行这个case对应的代码。同时在JDK1.8之后switch开始支持字符串类型）

基础语法

switch(含有具体值的变量){
    case 变量的某个值:要执行的语句;
    case 变量的某个值:要执行的语句;
}

public class Demo{
	public static void main(String[] args){
		int month=2;
		//case穿透
		switch (month){
			case 1:System.out.println("1月");
			case 2:System.out.println("2月");
			case 3:System.out.println("3月");
            default:
                System.ou-t.println("这个是前面都不成立时，执行")
		}
	}
}
//执行结果是2月 3月
//如果在要执行的语句后面加上break或return等，就会避免case穿透，

避免case穿透，具体的玩法有以下几种：

break：跳出它所在的语句块，它是语句级别的控制
return：它是方法级别的控制，终止它所在的方法的运行，向该方法的调用者提供一个值（返回值）
System.exit(0)：退出Java虚拟机，一般不用。

判断取值范围时一般使用if、而判断具体值的时候使用switch

for循环

循环结构：根据循环条件，重复性的执行某段代码

基础语法

for(表达式1;表达式2;表达式3){
    循环执行的语句
}

流程解析：

表达式1：当for循环首次执行时，它会被执行，后面循环则不执行该表达式
表达式2：作为循环的控制条件，该表达式会被反复执行一直到结果为false
表达式3：每次循环它都是最后执行，执行多次

退出循环：

break：跳出它所在的语句块，它是语句级别的控制
return：它是方法级别的控制
System.exit(0)：退出Java虚拟机，一般不用
continue：表示跳过本次执行

注意：将一个循环写到另一个循环里面这种情况称为嵌套循环。而这种情况下需要知道的是外层循环执行一次，内层循环执行多次。

while

基础语法

while（逻辑表达式）{
    循环执行的代码
}

do-while

基础语法

do{
    循环执行的代码
}while（逻辑表达式）

7、方法

这种方法也称为静态方法

	/**
	 *名称
	 *		-自定义的标识符
	 *		-第二个单词开始首字母大写
	 *参数列表
	 *		-当前方法和未来调用者之间的通讯的桥梁
	 *返回值(return)
	 *		-终止方法的运行
	 *		-给当前方法的调用者提供一个值
	 *void
	 *		-一种比较特殊的返回值类型
	 *		-代表的值一般没有具体值，类似于"" ''
	 */
	 public static void demo1(){
		System.out.println("HelloWorld")
	 }

	 /**
	  *方法，程序的入口方法
	  */
	 public static void main(string[] args){
         //方法的调用
         demo1();
     }

8、数组

理论上就是相同类型的数据的一个集合，Java中数组是定长（属组在声明的时候，它的大小就会被确定）

名词解释

索引：数组对其成员的编号，该编号从0开始

数组长度：数组的最大可用下标、数组长度、数组的组成成员，它的计数方式是从1开始计算的。

定义方式

	public static void main(Strint args[]){
        //第一种方式只声明长度不声明具体内容
        int mode1[]=new int[5];
        //第二种方式既有长度也有具体元素
        int mode2[]={100,60,80,90};
        //第三种方式，其实是前面两种的综合属于扩展写法
        int mode3[]=new int[]{80,60,90};
	}
}

默认值

数组中元素的默认值是根据其类型来决定的

Object：上帝类型（任意类型）Object arr[]= new Object[10] 默认值是null

指定对应的类型：定义一个长度为10的属组 int arr[] =new int[10] 默认值是0

public class Demo1{
    //这个也是属组
	public static void main(Strint args[]){
		Systm.out.println(args[]);
	}
}

遍历数组：

    public static void main(Strint[] arrgs){
		int arr[] = {10,30};
		//Ctrl + Shift + Enter自动补全
    
   		 //方式一：通过索引+循环的形式，在不停的改变索引值的同时获取数组元素
		for (int i = 0;i < 2;i++){
			//0--1 代表数组索引值
			System.out.println(arr[i]);
		}
	
		Strint brr[] = {"hello","World"};
		//增强for循环
        //方式二：需要注意的是String的类型需要和属组中元素的类型一致
		for (String i:brr){
			System.out.println(i);
		}
    }
}

排序：

public class sort {
    public static void main(String[] args) {
        int arr[]= {52,44,33,99};
        //让属组从小到大排序
        for(int i=0;i<arr.length;i++){
            for(int x=0;x< arr.length;x++){
                if(arr[i]<arr[x]){
                    int num=arr[i];
                    arr[i]=arr[x];
                    arr[x]=num;          
                }
            }
        }
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

二维及多维

二维数组可以理解为数组中的数组。

public class Demo1{
	pubic static void main(Strint args[]){
		//具体元素
		int numbers[]={{100},{60,80},{90}};
		//只定义个数
		int arr[][]=new int[5][5];
	}
}

方法重载（概念）：

方法名相同
参数列表不同

9、类和对象

定义：

类：将某一类事物中所有的共同点抽离出来，形成一个模板，而这个模板我们在编程中称为类，需要注意的是类只是个概念
对象：依托于某个模板（类）而产生的某个个体，个体是真实存在的

类的定义

类的定义其实并不复杂，涉及到的关键字也只有一个class

public class Demo{

}

对象

类似于现实世界一样，只有类没有对象是没有任何用途的。类似于我们都知道钱的概念，可是在你没有拿到一张纸人民币之前，这个概念可能对你没有任何用途。

在编程中对象的主要作用

方便我们更好的去使用某些功能，隐藏一些不必要暴漏在外面的细节，使我们的程序更加安全
将我们类中的数据全部加载到内存中，我们可以通过内存地址指向类中的某一个成员

对象的创建方式：new 该类的构造器()；【类的构造器其实就是和类名相同的一个方法】。

public class User{

}
public class Demo1{
    public staticvoid main(String args[]){
        //创建User类的对象
        new User();
    }
}

包机制

作用：

为了解决类文件的命名冲突
把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类

包名的定义方式： src右键，点击New，再选择Package，之后再新建一个class文件

使用包名：

第一种使用方式：int c=demo1.test01.add(10,20) 【分别是包名，类名，方法名】
```
	//方法的调用
	int c=demo1.Test01.add(10,20);
}
```

统一在类文件的开始位置，同时低于package的定义，import demo1.Test01;

import demo1.Test01;
public class Demo2{
    public static void main(Strint[] args) {
	//方法的调用
	int c=Test01.add(10,20);
    System.out.println(c);
	}
}

包名的定义

一般采用公司的域名反过来写。例如：com.coder123.项目名称.功能名词.类名
包名的所有字母全部小写

关键字import

为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用”import“语句可完成此功能。

在Java源文件中import语句应位于 package 语句后，所有类的定义之前，可以没有，也可以有多条，其语法格式为：

import 包名.类名

完整案例

package com.coder163.demo1

import com.coder163.domain

public class Boss{
	public void payEmployee(Employee e){
	e.mailCheck();
	}
}

访问权限

我们遵循的法则：隐藏细节，提供特定的访问方式（读、获取和写、设置）

关键字	使用频率	控制范围
public：公共的	常用	随意调用
private：私有的	常用	当类或者类的成员被private修饰时，表示该类的成员只能在本类中使用，一般情况下成员变量会使用private修饰
protected：受保护的	较少	只能在同一个包中调用
Default：默认的	一般	如果使用的话，在声明部分不要书写任何访问权限