Java语言基础

luoyiang

已于 2024-07-23 19:38:05 修改

阅读量171

点赞数 3

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

于 2024-07-19 18:57:14 首次发布

本文链接：https://blog.csdn.net/m0_64370841/article/details/140557439

版权

MyFirstProgramer

/** 文档注释:
	java入门案例的编写：
	
	格式：
	
	修饰词  关键字  标识符类名，大驼峰命名法
	public  class  classname{ 
		
	}
	
	1.程序员编写的文件的扩展名.java 叫java源文件。
	2.源文件中public修饰的class  只能有一个。说明文件中可以有多个class。
	3.public修饰的类的名字要尽量与文件名一模一样。
	4.类名后面的花括号及其里面的内容，称之为类体。
	5.类体的开始符号'{' 应该位于类名后；结束符号'}' 应该位于开始符号所在行的首字符下面
	6.被包含的内容，应该缩进2或者是4个空格，也可以是一个tab键。
	
	main方法：固定写法，public static void main(String [] args){}
			  作用： 程序的入口，即JVM会先执行main方法
	输出语句：System.out  会得到一个输出流，默认指向了控制台
	          .println(): 调用流的打印并换行功能，将小括号里的数据打印到控制台
			              然后插入换行符。
						  
				运行案例：
					1. 编译 ： 就是将java源文件使用javac编译器翻译成class文件（字节码文件）
						     javac 原文件名称（加上拓展名）
					2. 运行 ：就是使用java指令启动jvm，让ivm加载class文件并执行里面的main方法
						  java class文件名称(不带扩展名)
 */
public class MyFirstProgramer{
	public  static void main(String[] args){
		System.out.println("Hello World");
	}
}

VariableDemo01

/**  文档注释
      变量的应用：
		1. 语法的规则
		  -变量必须先声明和初始化
		    --声明：就是规定该变量的数据类型，也称为定义变量
		        int myNumber;  注意：句末用分号表示结束
			--初始化：就是变量的第一次赋值。
            --初始化的时机，分别是声明时直接初始化，和使用时再初始化
          -变量可以重复的存和取
            --存：用等号给变量赋值
			--取：用变量做其他事情都算取
			
			      
**/
public class VariableDemo{
	public static void main(String[] args){
		//练习1： 声明一个int类型的变量，变量名number。
		int number;
		//练习2： 给上面的number变量赋值100。
		number=100;//第一次赋值，叫初始化;
		//使用输出语句，进行打印。
		System.out.println(number);//注意：想要输出变量里的值，变量直接写在括号里，不要添加双引号。
		//练习3 ： 定义long变量time为1000.并打印。
	     long time=1000;
		 System.out.println(time);
		 //练习4： 定义int类型的变量num，打印变量。
		 int num; 
		 System.out.println(num);// 会报编译错误，
		 //除了变量在声明时的位置，出现在其他任何位置上，都是在使用变量，那么变量使用前必须初始化。
	    
		 int a = 10;
		 int b = 20;
		 int c = a + b;//将a和b里的值取出来然后计算，结果30在存入变量c里。
	      a = 5;//将5存入a变量，原来存储的10被5覆盖。
		  a = 50;//将50存入a变量，原来的5被50覆盖。
		  a = a + 6;//使用a中的50与6做加法运算，结果56再次存入a中，覆盖原有的50.
	 
	 
	 }
}

VariableDemo02

/**
    变量的应用（续）
	 -变量的操作必须与声明时所强调的一致。简而言之，类型必须一致，否则是类型不匹配。
	 -变量是有自己的作用域的（与自己的使用范围）。
	   1）作用域：从声明处开始，一直到他所在的花括号的结束符号位置。
	   2）该作用域内，变量不能重复声明（定义），出了该作用域，需要重新定义（声明）
	   
	   
	 
**/	 

public class VariableDemo02{
	public static void main(String[] args){
		//定义一个int类型的变量number，初始化为10。
		int number = 10;
		number = 3.14; //3.14是小数类型，不是int类型，因此会报编译错误。
		
		//研究变量的作用域
		int a =	 100;
		if(a>50）{
			int b = a*2;
		}else{
			int c = a-10;
			//long a = 100; 因为a已经在该作用域存在，因此不能重复定义
		}
		long c = 1000; //该处的c是、重新定义的，未重复，可以使用
		System.out.println(a);
		//System.out.println(b); 因为b这个变量出了自己的作用域
		System.out.println(c);	//使用long类型的c
	}
	public void run(){
	    System.out.println( number);//变量number想要使用，需要在使用前声明和初始化。
		
		
	}
}

VariableDemo03

/* 变量的分类：
    1. 按照位置分类
	  -成员变量：在方法外，类体里定义的变量
	  -局部变量：在方法里定义的变量
	2. 按照类型分类  
	  -基本数据类型(原始数据类型)（8种）
	  -引用数据类型(包括数组)
*/
public class VariableDemo03{
	int age = 10; //成员变量 
	public static void main（string[] args）{
		//下面三个都是局部变量
		int number = 1;
		int num = -1;
		String myName = "lucy"
	 
	 }
	 String name = " michael"//成员变量
	 String gerder= "女"//成员变量
	 
	 public void run(){
		 int a = 10;//局部变量


}

TypeDemo01

/*  
    基本数据类型之整数的类型
	- Java各整数类型都有固定的表数范围和字段长度，这样不受具体OS的影响，保证了java的可移植性。
    - 赋值时，不能超出各自的范围，否则编译不通过。
    - 整数字面量，也叫整数直接量(literal)，就是直接写出来的整数，是int类型。
    - int字面量，只要没有超出byte或者short的范围，是可以直接赋值给byte或short类型的变量的      (自动截断高位的0或1)
    - int字面量，可以直接给long类型的变量赋值。     (自动补全高位的32个0或1)
    - long字面量，需要在整数后面添加小写或者大写的L。
*/
public class TypeDemo01{
	public static void main(String[] args){
		byte b1 =10;
		//byte b12 =128; 编译错误，byte最大127。
		int n1 = 2147483647;//int最大值
		//int n2 = 2147483648;// 编译错误，超出int最大值。
		
		short s1 = 10; //10是int类型，因为没有超出short范围，因此可以直接赋值short。
		long lo1 = 1000;// 1000是字面量，属于int类型。可以直接赋值给long类型
	    long lo2 = 10L; //10L是long类型，直接就是64位二进制数
	
	System.out.println(b1);
	System.out.println(n1);
	System.out.println(s1);
	System.out.println(lo1);
	System.out.println(lo2);
	
	//long lo3 = 1000000000000000; 字面量就是int类型，因此不能超出范围
	long lo4 = 10000000000000000L;//使用long类型的字面量。
	}
}

TypeDemo02

/*  
   基本数据类型之浮点型的学习
     float：单精度类型，能精确到小数点后6~7位 
	                    能表示的整数部分范围在38位
	 double：双精度类型，能精确到小数点后15~16
	                     能表示的整数部分范围在308位 
		 
	  -浮点型的字面量默认是double类型，如果想要float字面量，需要添加F/f。
	  -浮点数字面量后面也可以添加D/d，也可以省略。	
      - 浮点数的写法： 例如： 5.12 3.12F 0.34 或者.34	  
*/

public class TypeDemo02{
	public static void main(String[] args){
		//float f1 = 3.14; //编译错误，因为字面量是double类型
		float f2 = 3.14f; //想要给float赋值，需要添加F/f
		double d1 = 0.12;
		double d2 = 10.1d;
		double d3 = .12; //.12相当于0.12;
		System.out.println(f2);
		System.out.println(d1);
		System.out.println(d2);
		System.out.println(d3);
		
		float f10 = 0.1234456789f;//将小数存入float类型的变量空间f10里面
		double d10 = 0.123456789123456789;//将小数存入float类型的变量空间d10里面
		System.out.println(f10);//取出时，发现不是原来的值
		System.out.println(d10);//取出时，发现不是原来的值
		
		double d101 = 3.0;
		double d102 = 3.9; //输出-0.8999999999999999
		System.out.println(d101- d102);//计算式有误差，并不精确。
	}
}

TypeDemo03

/*] 
    基本数据类型之字符类型的学习
	类型名：char
	解析： 在屏幕上看到的任何字符，如：汉字 子母 数字 其他等特殊符号。
	赋值特点：
	      1. 任意字符 使用单引号引起来，引号里有且只能有一个符号
		  2. 字符集:字符与底层二进制一一对应的表（密报例子）
		     
			 java语言里的字符使用的是unicode字符集，
			 每个字符都对应一个16位二进制的数（每个字符占用两个字节大小）。
             这些数的范围使用10进制就是0~65525;
             
               即：除了赋值字符本身以外，还可以赋值字符对应的数字，
			   也就是0~65525中的任意一个数字			

	注意： 因为char可以表示0~65525这个范围内的整数(无符号整数)
            因此可以参与运算	
		      
*/
public class TypeDemo03{
    public static void main (String[] args){
	    char c1 = '中';
	    char c2 = '9';
	    char c3 = '_';
	    char c4 = '\t'; //制表符 \t
	    char c5 = 't'; //给变量赋值普通的子母字符t
	    System.out.println(c1);
	    System.out.println(c2);
	    System.out.println(c3);
	    System.out.println(c4);
	    System.out.println(c5);
	    
	    //char c6 ='中国'; //编译错误，单引号里只能放入一个字符
	    //System.out.println(c6); 
		
		char c11 = 48;//字符0在unicode编码集里对应的那个整数
		char c12 = 57;//字符9在unicode编码集里对应的那个整数
		char c13 = 65;//字符A在unicode编码集里对应的那个整数
		char c14 = 90;//字符Z在unicode编码集里对应的那个整数
		char c15 = 97;//字符a在unicode编码集里对应的那个整数
		char c16 = 122;//字符z在unicode编码集里对应的那个整数
		System.out.println(c11);
		System.out.println(c12);
		System.out.println(c13);
		System.out.println(c14);
		System.out.println(c15);
		System.out.println(c16);
		
		char c21 = 'a';
		/*
		    取出c21里的字符a用其数值‘97’与7做运算得到结果104，
            存入char类型的变量里，打印出来是104对应的字符H		
		*/
		char c22 = (char)(c21 + 7);
		System.out.println(c22);
    }
}

TypeDemo04

/*
   基本数据类型之布尔类型的学习
   类型名：boolen
   值： true或 false
   作用：通常用于逻辑运算，true表示正确，false表示错误
   逻辑运算：一般用于流程控制语句，表示条件成立。

*/


public class TypeDemo04{
	public static void main(String[] args){
		boolean f1 = true;
		boolean f2 = false;
		System.out.println(f1);
        System.out.println(f2);
        boolean f3 = 1<2;
		System.out.println(f3);
		
	}
}

TypeDemo05

/*
   字符串类型：String， 引用数据类型之一，是最常用的引用类型。
   赋值特点： 双引号引起来，里面有0个以上任意字符。
    字符串可以做拼接操作：使用+号， 
      注意：+号前后只要有一个字符串类型，那就一定是拼接，
	        拼接结果是字符串类型。

*/


public class TypeDemo05{
    public static void main (String[] args){
		String myName = "lucy";//四个字符
		String str = "";//空字符串，字符长度为0
		String space = " ";//字符串里面只有一个字符，是空格
		String str1 = " 你是最棒的 ";//str1长度是7
		String str2 = "你 好";//str1长度是3
	
	    System.out.println(myName);
		System.out.println(str);
		System.out.println(space);
		System.out.println(str1);
		System.out.println(str2);
		
	    System.out.println("---字符串的拼接---");
		String s1 = "中";
		String s2 = "国";
		String s3 = s1 + s2; //"中国"
		System.out.println(s3);
		String s4 = s3 +"是最棒的";// "中国是最棒的"
		System.out.println("s4的值："+s4); //s4的值：中国是最棒的
		
		String r1 = 1+1+"2"+3+4;
		System.out.println("r1的结果"+r1);//r1的结果：2 2 3 4
		
		String r2 = 1+2+"3"+(4+5)+5*6;
		System.out.println("r2的结果"+r2);//r2的结果：3 3 9 30
	}
}

TypeTransform01

/*
    类型转换： 基本数据类型之间可以进行转换。
	  细分为：
		1.自动类型转换（隐式类型转换）
		   取值范围小的数据类型想取值范围大的数据转换
		   自动发生，不需要我们进行操作。
		   取值范围从小到大排序：
		       byte-->short（char)-->int-->long-->float-->double、
			   
		2.强制类型转换	   
			   取值范围大的数据类型想取值范围小的数据转换
			   注意：转换过程中，有可能发生精度损失或溢出
			   语法： 小范围类型名 变量=（小范围类型名）大范围变量
*/


public class TypeTransform01{
	public  static void main(String[] args){
		byte b1 = 10;
		// b1变量里存的是8位二进制的10，存入s1时自动变成16位二进制的10
		short s1 = b1;
		// s1变量里存的是16位二进制的10，存入n1时自动变成32位二进制的10
		int n1 = s1;
		// n1变量里存的是32位二进制的10，存入n1时自动变成64位二进制的10
		long n2 = n1;//32位的int变成64位的long
		double d1 = n2;//long类型的10转成的double类型的10.0
		
		System.out.println("-----强制转换类型-----");
		double d10 = 3.14;
		long n10 =(long) d10;//强制转换，精度损失。3.14变成3，丢失小数点后数据
		int n11 = (int)n10; //强制转换，64位的3转成了32位的数字3、
		
		int n12 = 32767;//short最大值
		short s11 = (short)n12;//编译期间，编译器只检查语法，不考虑变量
		
		System.out.println("short类型的s11的值"+s11);
		
		int n13 = 32768; //0000000 00000000 10000000 00000000
		
		short s12 = (short)n13;//强制转换，发生溢出（值改变了）
		System.out.println("s12的值"+s12); //-32768
		
		byte b11 =(byte) s12;//强制转换类型
		System.out.println("b11的值"+b11);//b11为0
		
		/*注意： int类型的字面量，如果没有超出 byte，short char的范围时，
		是可以直接给这些类型的变量进行赋值，因为底层会自动将前面的0或1截断。
		*/
		byte b100 = 10;//128
		short s100 = 30000;//32767
		char c100 = 6000;//65535
		byte b101 = (byte)128;//超范围就需要强制转换
		
	}
}

SymbolDemo01

/*
  运算的注意事项：
    1. 各种类型进行混合运算是，都是先自动转成其中取值范围最大的那种类型，在做运算。
	2. byte，short，char，在做运算时，会优先转成int类型做运算。
	   如果有其他取值范围大的类型，会选择范围最大的哪种类型。
	3. 运算时，有可能是溢出运算。（封闭式运算）
	     最大值+1，就变成最小值
		 最小值-1，就变成最大值
		 
		 
		 
		 
*/


public class SymbolDemo01{
	public static void main (String[] args){
		byte b1 = 10;
		byte b2 = 20;
		int b3 = b1 + b2;
		byte b4 = (byte)(b1+b2);//结果是int 将int强转为byte。
		
		int n1 =100;
		long n2 = 10;
		long n3 = n1 -n2;//int n1先转为long类型，然后和n2做运算，结果是long类型
		
		byte num1 =2;
		byte num2 = 127;
		byte num3 =(byte) (num1*num2);//溢出
		System.out.println("num3"+num3);//-2
		
		long num4 = 10;
		int num5 = 4;
		/*两个整数在做出发运算时，实际上是结果取整数部分，去掉小数
		long num6 =num4/num5;
		*/
		long num6 =num4/num5;
		double num7 = 10.0;
		int num8 = 4;
		/*除法运算时，有一个浮点类型，就是真正的浮点运算*/
		double num9 = num7/num8;
		
		/*  % : 取模运算（求模，取余数）*/
        long num10 = 20;
         int num11 = 6;
		 long num12 = num10%num11;
		 System.out.println(num12);
		 
		

		
	}
}

SymbolDemo02

/*
   算数运算符之 自增自减运算符
    ++：
	  符号在变量前：先加后赋值
	                变量先自增1，然后将变量的新值赋值给表达式
	  符号在变量后：先赋值再加
	                 先将变量的值赋值给表达式，然后变量自增1
    
	--：
	  符号在变量前：先减后赋值
	                变量先自减1，然后将变量的新值赋值给表达式
	  符号在变量后：先赋值再减
	                 先将变量的值赋值给表达式，然后变量自减1
					 
	简而言之：
	   符号在前，先运算后赋值
	   符号在后，先赋值后运算
	   
	   int i = 0;
	   int m = (i++);
	   int n = (++i);

*/
public class SymbolDemo02{
	public static void main(String[] args){
		int i = 10;
		i++;
		System.out.println(i);//11
		
		int m = 100;
		++m;
		System.out.println(m);//101
		
		int n = 2;
		--n;
		System.out.println(n);//1
		--n;
		System.out.println(n);//0
		
		/* 上述代码，不管自增自减，输出语句都是里面的变量，
		    因此就是自增自减*/
			
		/* 当自增自减式子参与运算，就要考虑注释了*/	
		int x = 1;
		int m5 = x++;
		System.out.println("x的值"+x);//2
		System.out.println("m的值"+m);//1
		x = 5;
		m = ++x;
		System.out.println("x的值"+m);//6
		System.out.println("m的值"+m);//6
		
		x = 5;
		//x 6  7  8  7 
		//r 6  6  8  7
		m = ++x + x++ + ++x - --x;
		System.out.println("x的值"+m);//7
		System.out.println("m的值"+m);//13
		
		int y = 5;
		int z = 6;
		//变量  y=6 z=7 z=8 y=5  z=7
		//表达式 5   6   8    5   8
		z = y++ + z++ + ++z +--y +z--;
		System.out.println("y的值"+y);//5
		System.out.println("z的值"+z);// 32
		
		
	}
}