java基础语法

语言基础

编码规范

常量和变量
变量
  • 第一种声明方式——先声明后赋值
    数据类型 变量名;
    Int age;//开辟整数変量空间
    変量名=值
    age=18;/将整数值赋给変量
  • 第二种声明方式——声明并赋值
    int age = 18；
  • 第三种声明方式——多个同类型变量的声明并赋值
    int x,y,z = 11,12,13;
  • 注意:Java是强类型语言,変量的类型必须与数据的类型一致。
  • 声明一个变量后，必须用赋值语句对变量进行显式初始化

常量
# 常量名一般使用大写字符
final 常量名=值;
final double PI=3.14; 
final String LOVE="imooc";
运算符
赋值运算符

算术运算符

关系运算符

逻辑运算符

位运算符

与（&）、非（~）、或（|）、异或（^）

移位运算符

<< : 左移运算符，num << 1,相当于num乘以2

>> : 右移运算符，num >> 1,相当于num除以2

>>> : 无符号右移，忽略符号位，空位都以0补齐

三目运算符

格式
布尔表达式?结果1:结果2 //布尔表达式为真，则结果1，布尔表达式为假，则结果2

public static void main(String[] args) {
	int age = 18;
	String age1=age == 17?"成年了":"未成年";
	System.out.println(age1);
	int x = 10;
	int y = 5;
	int z;
	z = (x > y) ? x : y;//三目运算符
		/*if (x>y){
			z = x;
		}else {
			z = y;
		}*/
	System.out.println("z = " + z);
	}
}
转义运算符

System.out.println("xx\tx\t");
System.out.println("y\nyy");
System.out.println("\\");
System.out.println("\"");
System.out.println("\'");
System.out.println("\rzzz");
数据类型

数据类型转换
  • 自动类型转换

byte->short->char->int->long->float->double

  • 强制类型转换
public class TypeConversion {
    public static void main(String[] args) {
        short s = 123;
        int i = s;        	// 目标类型大于源类型  自动类型转换 short ---> int
        System.out.println(i);

        double d = i;       // 目标类型大于源类型  自动类型转换 int ---> double
        System.out.println(d);

        short num = 123;
        byte target = (byte) num;       // 目标类型小于源类型  强制类型转换 short ---> byte
        System.out.println(target);

        double x = 12.34;
        int y = (int) x;            // 目标类型小于源类型  强制类型转换 double ---> int
        System.out.println(y);

        short m = 258;
        byte n = (byte) m;      // 目标类型小于源类型  强制类型转换 short ---> byte
        System.out.println(n);

        int a = -65;
        char b = (char) a;      // 目标类型小于源类型  强制类型转换 int ---> char
        System.out.println(b);
    }
}
  • 字符串转为Int类型
public class StringChangeToInt {
    public static void main(String[] args) {
        // 方式一
        int num = Integer.parseInt("56544" );
        // 方式二
        int num2=Integer.valueOf("123");
        System.out.println(num+"  "+num2);
    }
}
包装类

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

基本类型 对应的包装类（位于java.lang包中）
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
Integer类

  • Integer类概述

    包装一个对象中的原始类型 int 的值

  • Integer类构造方法及静态方法

方法名 说明
public Integer(int value) 根据 int 值创建 Integer 对象(过时)
public Integer(String s) 根据 String 值创建 Integer 对象(过时)
public static Integer valueOf(int i) 返回表示指定的 int 值的 Integer 实例
public static Integer valueOf(String s) 返回保存指定String值的 Integer 对象
  • 示例代码
public class IntegerDemo {
    public static void main(String[] args) {
        //public Integer(int value)：根据 int 值创建 Integer 对象(过时)
        Integer i1 = new Integer(100);
        System.out.println(i1);

        //public Integer(String s)：根据 String 值创建 Integer 对象(过时)
        Integer i2 = new Integer("100");
		//Integer i2 = new Integer("abc"); //NumberFormatException
        System.out.println(i2);
        System.out.println("--------");

        //public static Integer valueOf(int i)：返回表示指定的 int 值的 Integer 实例
        Integer i3 = Integer.valueOf(100);
        System.out.println(i3);

        //public static Integer valueOf(String s)：返回保存指定String值的Integer对象 
        Integer i4 = Integer.valueOf("100");
        System.out.println(i4);
    }
}
装箱与拆箱

https://www.cnblogs.com/dolphin0520/p/3780005.html

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：

  • 装箱：从基本类型转换为对应的包装类对象。

  • 拆箱：从包装类对象转换为对应的基本类型。

用Integer与 int为例：

基本数值---->包装对象

Integer i = new Integer(4);//使用构造函数函数
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法

包装对象---->基本数值

int num = i.intValue();

https://www.cnblogs.com/dolphin0520/p/3780005.html

Integer 例子:

  Integer i1 = 40;
  Integer i2 = 40;
  Integer i3 = 0;
  Integer i4 = new Integer(40);
  Integer i5 = new Integer(40);
  Integer i6 = new Integer(0);
  
  System.out.println("i1=i2   " + (i1 == i2));
  System.out.println("i1=i2+i3   " + (i1 == i2 + i3));
  System.out.println("i1=i4   " + (i1 == i4));
  System.out.println("i4=i5   " + (i4 == i5));
  System.out.println("i4=i5+i6   " + (i4 == i5 + i6));   
  System.out.println("40=i5+i6   " + (40 == i5 + i6));

结果：

i1=i2   true
i1=i2+i3   true
i1=i4   false
i4=i5   false
i4=i5+i6   true
40=i5+i6   true

解释：

语句 i4 == i5 + i6，因为+这个操作符不适用于 Integer 对象，首先 i5 和 i6 进行自动拆箱操作，进行数值相加，即 i4 == 40。然后 Integer 对象无法与数值进行直接比较，所以 i4 自动拆箱转为 int 值 40，最终这条语句转为 40 == 40 进行数值比较。

自动装箱与自动拆箱

由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。例如：

Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后，再次装箱，把基本数值转成对象。
基本类型转换为String

  • 转换方式

    • 方式一：直接在数字后加一个空字符串
    • 方式二：通过String类静态方法valueOf()

  • 示例代码

public class IntegerDemo {
    public static void main(String[] args) {
        //int --- String
        int number = 100;
        //方式1
        String s1 = number + "";
        System.out.println(s1);
        //方式2
        //public static String valueOf(int i)
        String s2 = String.valueOf(number);
        System.out.println(s2);
        System.out.println("--------");
    }
}
String转换成对应的基本类型

除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：

  • public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。
  • public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。
  • public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
  • public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
  • public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。
  • public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。
  • public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型。

代码使用（仅以Integer类的静态方法parseXxx为例）如：

  • 转换方式
    • 方式一：先将字符串数字转成Integer，再调用valueOf()方法
    • 方式二：通过Integer静态方法parseInt()进行转换
  • 示例代码
public class IntegerDemo {
    public static void main(String[] args) {
        //String --- int
        String s = "100";
        //方式1：String --- Integer --- int
        Integer i = Integer.valueOf(s);
        //public int intValue()
        int x = i.intValue();
        System.out.println(x);
        //方式2
        //public static int parseInt(String s)
        int y = Integer.parseInt(s);
        System.out.println(y);
    }
}

注意:如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出java.lang.NumberFormatException异常。

流程控制

选择分支
if...else...语句
switch语句
import java.util.Scanner;

public class WeekdaySwitch{
	public static void main(String[] args){	
		//一周计划
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入1-7的数字：");
		int weekDay = sc.nextInt();
		switch(weekDay){
			default:
				System.out.println("录入有误，请输入1~7之间的有效数字！");
				break;
			case 1:
				System.out.println("学习java");
				break;		
			case 2:
			case 5:
			case 6:
				System.out.println("玩游戏");
				break;		
			case 3:
				System.out.println("爬山");
				break;	
			case 4:
				System.out.println("上班");
				break;
			case 7:
				System.out.println("考试");
				break;			
		}	
		System.out.println("结束");		
	}
}
循环
do...while循环
// do ... while循环
	public static void sum2() {
		int i = 0 ;
		int sum = 0;
		do{
			sum = sum + i;
			i++;
		}while(i<101);
		System.out.println(sum);
	}
while循环
// while循环
	public static void sum1() {
		int i = 0 ;
		int sum = 0;
		while(i<101){
			sum = sum + i;
			i++;
		}
		System.out.println(sum);
	}
for循环
// for循环
	public static void sum(){
		int sum = 0;
		for(int i=1;i<101;i++) {
			if(i%2!=0) {
			sum = sum + i;
			}
		}
		System.out.println(sum);
	}
foreach 循环 (两个功能：1遍历数组 2 遍历集合）
public class ForEachCircular {
    public static void main(String[] args) {
        // foreach循环遍历数组
        String [] names = {"xiao","xian","hua","nian"};
        for(String name:names){
            System.out.print(name + "\t");
        }
        System.out.println();
        // foreach循环遍历集合
        ArrayList<String> ming = new ArrayList<String>();
        ming.add("xiao");
        ming.add("xian");
        ming.add("hua");
        ming.add("nian");
        for(String m:ming){
            System.out.print(m + "\t");
        }
    }
}
跳转
break语句 :跳出循环
continue语句：跳出本次循环
public class BreakAndContinue {
    public static void main(String[] args) {
        for (int i = 1; i < 6 ; i++) {
            if (i % 5 ==0){
                break;
            }
            System.out.println("当前循环次数：" + i);
        }
        System.out.println("<--------------------->");
        for (int i = 1; i < 7 ; i++) {
            if (i % 5 ==0){
                continue;
            }
            System.out.println("当前循环次数：" + i);
        }
    }
}

函数

函数的概念

什么是函数？

函数就是定义在类中的具有特定功能的一段独立代码（函数==方法）

函数的优点

  • 减少代码冗余。
  • 提高复用性。
  • 提高可读性。
  • 提高可维护性。
  • 方便分工合作。
函数的定义
修饰符 返回值类型 函数名（[参数类型1 参数名1,参数类型2 参数名2 ....]）{
    代码块.......
    return  返回值；    //返回值的类型必须与返回值类型一致
}
函数的参数

形参：等同于局部变量
实参：

定义语法：
public static void 函数名称(形式参数){
      // 函数主体
}
调用语法
 函数名称(实际参数);
函数的返回值与返回值类型
定义语法
public static 返回值类型 函数名称(形式参数列表){
        // 函数主体
    return value; // 返回值
}
调用语法
变量 = 函数名称();   // 变量类型与返回值类型一致
return关键字
  • 用途
    （1）返回方法指定类型的值（前提是方法的返回值类型不是void）。
    （2）方法的结束，它会导致当前的方法退出。
  • 使用形式
    （1）方法有返回值类型，格式：
    return 返回值;
    （2）方法没返回值类型，格式：
    return;
函数的重载

在同一个类中，定义多个函数名相同、参数列表不同的函数。
调用时通过函数名和参数列表来确定一个函数,函数的重载和返回值类型无关。

public class Function_test {
public static void main(String[] args) {
	// TODO Auto-generated method stub
		int a = add(4,9);
		System.out.println(a);
		int b = add(4,9,4);
		System.out.println(b);
	}

// add函数，获取两个值的和
public static int add(int x,int y){
		int sum = x+y;
		return sum;
}

// add函数的重载 ,获取三个值的和
public static int add(int x,int y,int z){
	int sum = x+y+z;
	return sum;
  }
}
函数的递归

函数的内部调用自身的过程

// 斐波那契数列
public class RecursionFibonacci {
public static void main(String[] args) {
	// 1 1 2 3 5 8 13 21 34 55 89
	Scanner sc = new Scanner(System.in);
	System.out.println("请输入fibonacci的项数：");
	int inpu = sc.nextInt();	
	int result = fibonacci(inpu);
	System.out.println(result);
}
public static int  fibonacci(int n){
	if (n == 0){
		return 0;
	}else if(n==1) {
		return 1;
	}
	return fibonacci(n-1)+fibonacci(n-2);
	}
}

递归输出文件目录名

public class RecursionFileName {   
public static void main(String[] args) {
        String path = "D:/";                   // 设定文件路径
        test(path);
    }
    private static void test(String path) {			// 输出文件目录函数
        File f = new File(path);				// 创建一个文件路径对象
        File[] fs = f.listFiles();				// 创建文件路径列表的数组
        if (fs == null) {						// if数组为空，则返回
            return;
        }
        for (File file : fs) {					// 输出数组
            if (file.isFile()) {
                System.out.println(file.getPath());
            } else {
                test(file.getPath());
            }
        }
    }
}

java数组学习

数组的定义

同一种类型数据的集合

    // 第一种  数组的定义  定义一个存储3个整数的容器
	int [] x = new int[3];
	// 第二种  数组的定义  定义一个存储3个整数的容器
	int [] y = new int[] {2,7,6,9,4,3,3};
	// 第三种  数组的定义  定义一个存储3个整数的容器
	int [] z = {2,7,6,9,4,3,3};

        // 数组定义，二维数组
	// 第一种  数组的定义  
		int [][] arr4 = new int[3][5];
	// 第二种  数组的定义  
		int [][] arr5 = new int[][] {{-2,7,6},{-9,4,3,3}};
	// 第三种  数组的定义  
		int [][] arr6= {{-2,7,6},{-9,4,3,3}};
数组的操作
package base;

public class Array_learn {
public static void main(String[] args) {
	// 数组定义，一维数组
	// 第一种  数组的定义  定义一个存储3个整数的容器
	int [] arr1 = new int[3];
	// 第二种  数组的定义  
	int [] arr2 = new int[] {-2,7,6,-9,4,3,3};
	// 第三种  数组的定义  
	int [] arr3= {2,7,6,9,4,3,3};
	
	// 数组定义，二维数组
	// 第一种  数组的定义  
		int [][] arr4 = new int[3][5];
	// 第二种  数组的定义  
		int [][] arr5 = new int[][] {{-2,7,6},{-9,4,3,3}};
	// 第三种  数组的定义  
		int [][] arr6= {{-2,7,6},{-9,4,3,3}};
	
	// 打印数组
	printArray(arr2);
	//获取数组中的最大值
	int max = getArrayMax(arr2);
	System.out.println(max);
	//获取数组中的最小值
	int min = getArrayMin(arr2);
	System.out.println(min);
	// 数组的排序之冒泡排序
	bubbleSort(arr2);
	printArray(arr2);
	// 数组的排序之插入排序
	insertSort(arr2);
	printArray(arr2);
	// 数组的排序之选择排序
	selectSort(arr2);
	printArray(arr2);
	// 数组的查找之折半查找
	// 因为折半查找要求数组必须有序，所以先进行排序
	selectSort(arr2);
	int m = halfSearch(arr2,7);	
	System.out.println(m);	// 返回查找的数组下标，如果没有找到返回-1
	}
	// 打印数组
	public static void printArray(int[] y){
		for(int i =0; i < y.length; i++)
		{
			System.out.print(y[i]+"\t");
		}
		System.out.println();
	}
	// 获取数组中的最大值
	public static int getArrayMax(int[] y){
		int max = y[0];
		for(int i = 0; i < y.length; i++){
			if(y[i]>max){
				max =y[i];
			}
		}
		return max;	
	}
	//获取数组中的最小值
	public static int getArrayMin(int[] y){
		int min = y[0];
		for(int i = 0; i < y.length; i++){
			if(y[i]<min){
				min =y[i];
			}
		}
		return min;	
	}
	// 数组的排序之冒泡排序
	public static void bubbleSort(int[] y) {
		/**
		冒泡排序
		比较相邻的元素。如果第一个比第二个大，就交换他们两个。 [1] 
		对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 [1] 
		针对所有的元素重复以上的步骤，除了最后一个。 [1] 
		持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
		**/
		int temp = 0;
		// 外层循环，它决定一共走几趟
		for (int i = 0; i < y.length-1; ++i) {
		//内层循环，它决定每趟走一次
		for (int j = 0; j < y.length-i-1; ++j) {
		//如果后一个大于前一个  	换位
		if (y[j + 1] < y[j]) {
			temp = y[j];
			y[j] = y[j + 1];
			y[j + 1] = temp;
			}
		}	
	 }
	}
	// 数组的排序之插入排序
	public static void insertSort(int y[]) {
		int i, j;
		for (i = 1; i < y.length; i++) {
		int temp = y[i];
		for (j = i; j > 0 && temp < y[j - 1]; j--) {
		y[j] = y[j - 1];
		}
		y[j] = temp;
		}
		}
	// 数组的排序之选择排序
	public static void selectSort(int y[]) {
		int temp = 0;
		for (int i = 0; i < y.length - 1; i++) {
		// 认为目前的数就是最小的, 记录最小数的下标
		int minIndex = i;
		for (int j = i + 1; j < y.length; j++) {
		if (y[minIndex] > y[j]) {
		// 修改最小值的下标
		minIndex = j;
		}
		}
		// 当退出for就找到这次的最小值
		if (i != minIndex) {
		temp = y[i];
		y[i] = y[minIndex];
		y[minIndex] = temp;
		   }
		}
	}
	// 数组的查找之折半查找
	public static int halfSearch(int[] arr,int target) {
		//定义三个变量分别记录最大、最小、中间的查找范围索引值
		int max=arr.length-1;
		int min=0;
		int mid=(max+min)/2;
		while(true) {	
			if(target<arr[mid]) {		//如果目标元素小于中点元素
				max = mid-1;			//max向mid前移动
			}else if(target>arr[mid]) { //如果目标元素大于中点元素
				min = mid+1;			//min向mid后移动
			}else {
				return mid;				//找到目标元素
			}			
			//没有找到的情况
			if(max<min) {
				return -1;
			}			
			//重新计算中间索引值
			mid=(max+min)/2;
		}		
	}	
}

Javadoc 使用详解

https://blog.csdn.net/vbirdbest/article/details/80296136

posted @ 2022-03-29 22:53  可归  阅读(36)  评论(0)  编辑  收藏  举报