Java语言基础

最新推荐文章于 2022-06-19 09:33:47 发布

alex-zhou96

最新推荐文章于 2022-06-19 09:33:47 发布

阅读量108

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/ZHOUJIAN_TANK/article/details/87388456

版权

java基础专栏收录该内容

19 篇文章 0 订阅

订阅专栏

一、基本数据类型

(1)常量

System.out.println("123");
System.out.println("abs");
System.out.println(10000);
System.out.println(true);
System.out.println(3.14);

(2)变量

基本数据类型分类(4类8种)：

整数型
byte 占一个字节 -128到127 （字节型）
short 占两个字节 -2^15~215-1 （短整型）
int 占四个字节 -2^31~231-1 （整型）
long 占八个字节 -2^63~263-1 （长整型）
2、浮点型
float 占四个字节 -3.403E38~3.403E38 单精度
double 占八个字节-1.798E308~1.798E308 双精度
3、字符型
char 占两个字节 0~65535
4、布尔型
boolean
boolean理论上是占八分之一个字节,因为一个开关就可以决定是true和false了,但是java中 boolean类型没有明确指定他的大小。

		//整数型
		int i1 = 10;
		System.out.println(i1);

	    long l1 = 88888888888l;
		System.out.println(l1);

		long l2 = 999; //强制数据类型转换
		int i2=(int)l2;  //从容量大的向容量小的转换时需要强制类型转换，可能会损失精度
		System.out.println(i2);
		
	/******浮点型******************/
		double d = 3.14;
		System.out.println(d);

		float f = 1.2F;
		System.out.println(f);

	/**************字符型，char*************/
		char c1 = 'a';
		System.out.println(c1);

		char c2 = '大';
		System.out.println(c2);

		//char c3 = 'ab'; //报错这个叫 字符串

		char c4 = 97;
		System.out.println(c4); //输出对应的ASCII码表，输出'a'

		/******转义字符*************/
	     char c5 = '\'';
		System.out.println(c5);//输出 单引号

		char c6 = '\t'; 
		System.out.println(c6); //输出制表符

		char c7 = '\n';
		System.out.print(c7); //换行


		/*******布尔型 boolean：boolean的主要应用于逻辑运算和条件判断******/

		boolean flag = true;
		if(true){
			System.out.println(true);}
		else{
			System.out.println(false);
		}

/********各种数据类型之间的转换关系
		
		于基本数据类型转换规则：
   1.8种基本数据类型除boolean类型之外都可以相互转换.

   2.小容量向大容量转换叫做自动类型转换：
    byte<short(char)<int<long<float<double

   3.byte,short,char做混合运算的时候，各自都先转换成int在做运算

   4.大容量向小容量转换是强制类型转换，需要加强制转换符，
    编译虽然通过，运行期可能损失精度。谨慎使用。

   5.如果整数没有超出byte,short,char的取值范围，可以直接将这个整数赋值给byte,short,char

   6.多种数据类型做混合运算，先转换成容量最大的那种再做运算**************/


       byte b1 = 4;
		byte b2 = 5;
		//byte b3 = b1+b2;  //错误: 不兼容的类型: 从int转换到byte可能会有损失
		byte b3 = (byte)(b1+b2); //强制类型转换.9


		byte b4 = 10;
		short s1 = 5;
		int i4 = b4 + s1; //b4和s1先转换为int类型，所以这种方法没有任何问题
		System.out.println(i4); //15

		char c8 = 'a' ;//'a'的ASCII编码为 97
		int i5 = c1 + 100; //c8的类型转换为int类型
		System.out.println(i5);
		System.out.println((byte)(c8));//强制类型转

3、各种运算符

3.1 算数运算符

		int a = 10;
		int b =  5;
		int c1 = a+b;   //加
		System.out.println(c1);
		int c2 = a-b ;  //减
		System.out.println(c2);
		int c3 = a*b;   //乘
		System.out.println(c3);
		int c4 = a / b; //除
		System.out.println(c4);
		
		int c7 = a%b;  //取余，取模
		System.out.println(c7);

自增或自－运算符放在变量的前后有什么区别？

①单独使用，没有区别
②如果放在变量的前面，则先进行自增或自－，然后再参与运算如果放在变量的后面，则先参与运算，然后再进行自增或自减
Java里面程序运算顺序：先运算括号里面的，再运算括号外面的，然后再运算括号外面的

		int c5 = a++; //自加
		System.out.println(c5);//10
		System.out.println(a); //11

		int c6 = ++a;  //自加
		System.out.println(c6);//12
		System.out.println(a); //12

3.2赋值运算符

		/*int i1 = 10;
		i1 -=10;  //     -=  
		System.out.println(i1); //0
		i1 +=10;  //    +=
		System.out.println(i1); //10
		i1 *=3;   //    *=
		System.out.println(i1);//30
		i1 /=2;   //   /=
		System.out.println(i1);//15

3.3关系运算符

//     == 判断是否相等
		// != 不等于
		// > 大于
		// >= 大于等于
		// < 小于
		// <= 小于等于

		int d1 = 10;
		int d2 = 10;
		System.out.println(d1==d2);//true
		System.out.println(d1>d2);//false
		System.out.println(d1!=d2);//false
		System.out.println(d1>=d2);//true*/

3.4逻辑运算符

		// &  与，两边都是true,结果是true
		// |  或，一边是true,结果是true
		// !   非  取反
		// ^  异或 两边只要不一致就是true
	    // && 短路与 用法和&一样
		// ||  短路或  用法和|一样
        /*
        System.out.println((3>4)&(5>1)); //false
		System.out.println((3>4)|(5>1)); //true
		System.out.println((3>4)); //false
		System.out.println(!(3>4)); //true;取反

3.5字符串连接运算符

①做加法运算（+两边只要都是数字类型，一定是加法运算）
②字符串连接（+两边任意一端只要是字符串类型，则一定是字符串连接）

		System.out.println("hello"+123+"as"+'c');

3.6三目运算符

语法： boolean 表达式？表达式1：表达式2
解释： boolean表达式的结果是true,则整个表达式的结果就是表达式1，相反则是表达式2

		//求取a,b中最大的值
		int a = 20;
		int b = 30;
		int max = (a>b)?a:b;
		System.out.println(max);

3.7位运算符

// 位运算符，主要操作二进制
// &位与
// |位或
// ^位异或
// ~取反
// >>向右移,最高位是0，则左边补齐0，最高位是1，则左边补齐1
// >>>无符号向右移，无论最高位是0还是1，左边补齐0
// <<向左移，左边最高位丢弃，右边补齐0

		System.out.println(6&3);  //2
		System.out.println(6|3);  //7
		System.out.println(6^3);  //5
        System.out.println(~6);   //-7
 
        System.out.println(12>>1); //12/2=6
        System.out.println(12>>2); //12/4=3   //向右移n位，则除以2的n次方
        System.out.println(12<<1); //12*2=24
        System.out.println(12<<2); //12*4=48 向左移n位，则乘以2的n次方

		//System.out.println(12^3^3); //一个数据对另一个数据位异或两次，则这个数据本身不变

4、分支语句if…else…

	/*******if....else...三种结构

		第一种结构：  if(boolean表达式）{

						java语句；
						}

		第二种结构：  if (boolean表达式）{
						java 语句;
						}else{
						 java语句；
						 }

		第三种结构：   if (boolean表达书）{
						java 语句；
						} else if(boolean 表达式）{
						java 语句;
						} else if(boolean 表达式）{
						java语句;
						}else{
							java 语句
						}
		*****************/

例1：

 boolean IsSucess = true;
	 if (IsSucess)
	 {
		 System.out.println("登录成功！");
	 }else{
		 System.out.println("登录失败！");
	 }

例2：

int i = 44;
	 if (i==1)
	 {
		 System.out.println("我喜欢足球");
	 }else if (i==2)
	 {
		 System.out.println("我喜欢蓝球");
	 }else if (i==3)
	 {
		 System.out.println("我喜欢排球");
	 }else{
		 System.out.println("我不喜欢任何");
	}

5、控制语句switch

/**********
 switch

 switch(表达式){
 
	case 值1：
		java 语句
		break;
	case 值2:
		java语句；
		break;

	default:
		java语句
 
     }

	注意：
	1、程序遇到break之后就停止了，break可以不写，如果不写的话，会发生case穿透

	2、default也可以没有

	3、switch()之后可以放 byte,short,char，int类型的，只要可以自动转换为Int类的都可以。JDK7之后可以放String类型

**************/

例1：

int i1 = 2;
	switch(i1){
	case 1:
		{System.out.println("我喜欢足球");
		break;}
	case 2:
		System.out.println("我喜欢羽毛球");
		break;
	case 3:
		System.out.println("我喜欢乒乓球");
		break;
	default:
		System.out.println("我不喜欢任何球类运动");

	}

例2：多重case的情况下

int month = 3;
	switch(month){
		case 3:
		case 4:
		case 5:
			System.out.println("春季");
			break;

		case 6:
		case 7:
		case 8:
			System.out.println("夏季");
			break;

		case 9:
		case 10:
		case 11:
			System.out.println("秋季");
			break;

		case 12:
		case 1:
		case 2:
			System.out.println("冬季");
			break;

		default:
			System.out.println("请输入正确的");

	}

6、for循环

/*******for 循环 ************
		for（初始化表达式；条件表达式式；循环之后的表达式）{
		java 语句；
	}
执行的过程：
	1、执行初始化的表达式，并且在整个循环里面只执行1次
	2、将初始化的表达式的值在条件表达式里面进行判断
		如果是true,则程序继续执行
		如果是false,则循环执行结束
	3、为true执行java语句
	4、执行循环之后的表达式
	5、程序再回到第二步继续执行

例子：

	//打印10遍Hello World!

	for (int num =0;num<10 ;num++ )
	{
		System.out.println("Hello WORLD");
	}


	//打印九九乘法表
	for (int t =1;t<10 ;t++ )
	{
		for(int j =1;j<=t;j++){
			System.out.print( t + "*" + j+"="+(t*j));
			System.out.print('\t');

		}
		System.out.print('\n');
	}

	//打印1-100奇数的和
	int sum = 0;
	for(int t=1;t<100;t++){
		if(t%2==1){
			sum+=t;
		}
	}
	System.out.println(sum);

7、while循环

模式1：
while (boolean表达式）{
	循环体语句；
	循环条件语句；
   }

模式2：
do
	{
		循环体语句；
		控制条件语句；
	}while(判断条件语句）

例子：

int num = 0;
while(num<10){
	System.out.println("Hello World");
	num++;
}

//for循环；while循环;do while循环
//实际开发中：for 循环应用比较多

//break 和 Continur
//break 在switch语句里面，用来结束分支
// 在循环里面，默认结束离他最近的循环
//continue ：直接结束本次循环，进入到下次循环里面

8、方法（就是函数）

其实在之前的学习当中，已经接触过一个方法了，那就是main方法，main方法是所有程序的入口，这是sun公司规定的，程序都是从main方法开始执行的，如果将一个程序比喻成一座大楼，那么main方法就相当于是这个楼最外面的大门。

方法的优点就是可以提高代码的复用性。以后要有编写方法的意识，不要把所有代码都堆积在main方法中。什么时候需要定义方法？当希望提高某段代码复用性的时候可以去定义一个方法。

8.1如何定义方法

方法定义：

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
        方法体语句;
        //如果方法没有返回值的话就不需要return了。
        return 返回值; 
    } 

说明：
(1)修饰符：暂时先写 public static。后面再详细的讲解其他的修饰符和作用。
(2)返回值类型：可以是java语言中的任何一种数据类型(基本数据类型和引用数据类型)。如果方法执行结束后，没有任何返回值，返回值类型填写void，即表示没有返回值。
(3)方法名：自己定义，只要符合命名规则即可，使用驼峰方式命名，即第一个单词首字母小写，后面单词的首字母大写，例如sumInt。
(4)参数：
				没有参数：如果没有参数，参数类型和参数名可以不写，()里面空着就行
				有参数：可以有一个，或多个参数，多个参数用”,”隔开
				参数类型：就是参数的数据类型，基本数据类型和引用数据类型都可以
				参数名：就是变量名，符合命名规则即可
(5)方法体语句：就是完成功能的代码。
(6)return：如果方法的返回值类型不是void,那么在方法体中必须使用return 语句来返回数据。return语句一旦执行，则方法结束，因此在方法中return后面的代码是不会执行的。
(7)返回值：方法执行的结果，将结果返回给调用者。

1、编写的方法必须在main()外，在类内进行编写

2、方法的带调用和执行顺序：同一个类里面的方法可以直接调用（就像上一篇里面写的那样），还可以跨类进行调用，即调用别的类里面的方法，需要采用”类名.”的方式。

3、方法的执行顺序
main方法是程序的入口，程序是从main方法里面开始自上而下执行的。如果定义了一个方法，这个方法并未在直接或间接在main方法里面进行调用，那么这个方法将不会被执行。

4、程序执行到方法里面的return语句时，方法就会返回，return下面的语句不会被执行。

class  day1_Method{
//方法的执行顺序：从main方法里面，自上而下执行

	public static void main(String[] args) { //main方法是程序的入口，程序是从main方法开始执行的
		System.out.println("Hello World!");
		sum1(10,3);  //调用m1方法
		System.out.println(sum2(100,1000)); //调用有返回值的m2方法
		day2_method.m1(); //跨类方法的调用

	}
	public static void sum1(int a , int b){   //在main（）外部定义的方法m1
		System.out.println(a+b);
	}
	
	public static int sum2(int a,int b){  //在main（）外部定义方法m2,有返回值
		return a+b;
		//System.out.println(a+b);     //编译报错：day1_Method.java:48: 错误: 无法访问的语句
	}
}

8.2方法的重载

问题
之前已经写了一个方法sumInt用来计算两个int类型数字的和，如果要是想计算两个float类型数字的和呢？ok，那就再来写一个sumFloat方法，除此之外，还有long类型，double类型，如果每种类型都要进行求和计算的话，就会像下面这种情况写4个方法了

public class MethodTest{

    public static void main(String[] args){

        System.out.println(sumInt(10,20));

        System.out.println(sumDouble(1.0,2.0));

        System.out.println(sumLong(10L,20L));

        System.out.println(sumFloat(1.0F,2.0F));

    }

    public static int sumInt(int a,int b){

        return a + b;

    }

    public static double sumDouble(double a,double b){

        return a + b;

    }

    public static long sumLong(long a,long b){

        return a + b;

    }

    public static float sumFloat(float a,float b){
        return a + b;
    }

}

方法重载（overload）
上面程序有缺点，定义的4个方法，功能上都是计算两个数字的和，只不过传入的参数类型不同，调用者在调用的时候，需要记忆每个方法的名字，并且需要自己根据传入参数的类型来判断调用相应的方法，这样使用起来不是很方便，那为了使用方便，我们来改造一下上面的代码。

public class MethodTest{

    public static void main(String[] args){

        System.out.println(sum(10,20));

        System.out.println(sum(1.0,2.0));

        System.out.println(sum(10L,20L));

        System.out.println(sum(1.0F,2.0F));

    }

    public static int sum(int a,int b){

        return a + b;

    }

    public static double sum(double a,double b){

        return a + b;

    }

    public static long sum(long a,long b){

        return a + b;

    }

    public static float sum(float a,float b){

        return a + b;

    }

}

上面将之前的代码里面的4个方法名全部改成一样的了，这种情况叫做方法重载（overload）。
//重载可以解决：方法名较多，不需要考虑参数的个数，类型，顺序等问题

方法重载发生的条件

方法重载条件：             1、需要在同一个类里面
			   			  2、方法名要一样
			             3、参数列表不同（参数类型，个数或者顺序）
			注意：重载和返回值类型不构成关系，重载跟修饰符列表没有关系。

8.3递归

递归就是方法自己调用自己，在编写的时候一定要有一个结束条件，否则将会造成StackOverflowError的错误。

//求 1+2+3+。。。。。n
public static int sumn(int n){

	if(n==1){
		return 1;
	}else{
		return n+sumn(n-1);
	}
}


public static int fn(int n){
	if (n==1)
	{
		return 1;
	}else{
		return n*fn(n-1);
		}
}

alex-zhou96

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java语言基础

一、基本数据类型(1)常量System.out.println("123");System.out.println("abs");System.out.println(10000);System.out.println(true);System.out.println(3.14);(2)变量基本数据类型分类(4类8种)：整数型byte 占一个字节 -128到127 （字节型...
复制链接

扫一扫

专栏目录