JAVA学习（1天） #来源：异步图书

第三章 基础语法
3.1 常量变量

常量：值永远不会发生变化的量，可以表示固定的数字，字符，字符串
定义常量的关键字：final
例如：
final double PII=3.14；
final char MALE=‘M’，FEMALE=‘F’；

final double PI=value；
value=3.14；

PI是常量名称，常量名称一般为大写
value是常量的值
final表示该量只能被赋值一次

通常我们希望定义一个类常量，使得其能在多个方法中使用
但注意的是：类常量的定义在main方法外部

public class first{
/**在这一行**/
		/*这是一个main方法*/
		public static void main(String[] args){
		/*输出此消息*/
		System.out.println("第一段Java程序");
		}
}

变量：在运行过程中值随时会发生变化的量
在运行java程序过程中，变量内存空间中的值是变化的，这个内存空间就是变量的实体，这个内存空间也叫变量名

该区域的数据可以在同一数据类型范围内不断变化
内存空间是为了存储变量，所以即使申请了内存空间，变量也不一定有值，要想有值，一定要赋值

声明变量的基本格式：
typeSpencifer varName=value;
typeSpencifer可以使java语言中所有合法的数据类型
varName是变量名，变量常量的最大区别在于value的值的可有可无，还可以对其进行动态初始化
每个变量在使用前必须先声明再赋值才能使用
变量名必须是一个有效的标志符
不可以与关键字重复
建议使用有意义的单词或单词组合

变量又分为：局部变量（在一个方法快或一个函数内起作用），全局变量

局部变量运用实例

package one;

public class Zhen {
	public static void main(String args[])
	{
		//正方形面积计算
		double a1=12.2;
		double a2=a1*a1;
		System.out.println("正方形的面积为"+a2);
	}

}

全局变量实例

package one;

public class Zhenquanjvbianliang {
	int z1=2;  //定义全局变量z1并赋值
	boolean e;  //定义变量e 但不知道是用来干什么？？？

	public static void main(String[] args) {
		int z1=111;  //对z1进行重新赋值
		System.out.println("打印数据z="+z1);
		
		// TODO 自动生成的方法存根

	}

}

全局变量可以在局部里面被改变

3.2 数据类型

八种类型的取值范围

数据类型	位数 字节数	数值范围
byte	8位 1字节	-128~127
short	16位 2字节	-32768~32767
int	32位 4字节	-2的31次~2的31次-1
long	64位 8字节	-2的63次~2的63次-1
float	32位 4字节	3.4e-45~1.4e38直接赋值需要在数字后面加上f或F
double	64位 8字节	4.9e-324~1.8e308 赋值时可加d或D也可不加
boolean	只有true和false两个取值
char	16位 2字节	存储Unicode码 用单引号赋值

java决定了每种简单类型的大小 不会随机器结构的变化而变化

package come.inspur.ch2;

public class IntegerDemo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		byte myByte = 127;
		short myShort = 32767;
		int myInt = 678;
		long myLong = 7890;
		long myLong1 = 33333333;
		System.out.println(myByte+"myByte的类型为："+getType(myByte));
		System.out.println(myShort+"myShort的类型为："+getType(myShort));
		System.out.println(myInt+"myInt的类型为："+getType(myInt));
		System.out.println(myLong+"myLong的类型为："+getType(myLong));
		System.out.println(myLong1+"myLong1的类型为："+getType(myLong1));

	}
/**
 * 声明公用方法返回参数的数据类型
 * @param o
 * @return
 */
	public static String getType(Object o) {
		return o.getClass().toString();
	}
}

第十二行 如果数据范围超出了int 的最大值 要在数据后面加l或L就不会报错
打印显示数据的具体类型 用公共的方法getType

public class zhengxing
{
	public static void main(String[] args) 
	{
		//下面代码是正确的，系统会自动把56当成byte类型处理
		byte a = 56;
		/*
		下面代码是错的，系统不会把9223372036854775807当成long类型处理，
		所以超出int的表数范围，从而引起错误
		*/
		//long bigValue = 9999999999999;
		//下面代码是正确的，在巨大的整数常量后使用L后缀，强制使用long类型
		long bigValue2 = 9223372036854775807L;	
		//以0开头的整数常量是8进制的整数
		int octalValue = 013;
		System.out.println(octalValue);
		//以0x或0X开头的整数常量是16进制的整数
		int hexValue1 = 0x13;
		int hexValue2 = 0XaF;
		System.out.println(hexValue1);
		System.out.println(hexValue2);
	}
}

浮点类型
浮点数必须带一个小数点 不然会被当成int类型来处理

只有浮点类型的数才可以用科学计数法来表示
52000000是int类型 但是52E6是浮点类型

数据类型	所占位数	数值的范围
float	32	-3.403E38~3.403E38
double	64	-1.798E308~1.798E308

package come.inspur.ch2;

public class FloatDemo {
	public static void main(String[]args) {
		float myFloat=56.67F;  //后面一定要跟F  不然会报错
		double myDouble=56.98;
				System.out.println("myFloat:"+myFloat);
				System.out.println("myDouble:"+myDouble);
	}

}

字符类型
char 用于存放单个字符的数据类型，占两个字节，采用unicode编码
例如‘1’表示字符1而不是数字1
字符类型分为字符常量和字符变量
字符常量：用‘ ’ 括起来的一个字符 如‘A’
字符变量：在机器中占16位，其范围为0~65535
如char c=‘a’
变量c为char型，且赋初值为a

package come.inspur.ch2;

public class CharDemo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		char myChar='a';
		char myChar1=97;
		System.out.println("myChar:"+myChar);
		System.out.println("myChar1:"+myChar1);
	}

}

转义字符	含义
\b	后退一格
\t	后退一大格
\n	换行
\f	换页
\\	表示一个斜杠
\’	表示一个单引号
\"	表示一个双引号
\r	接受键盘输入 相当于按回车

布尔类型
通过Boolean可定义布尔类型的变量，只有true和false两个值
分别代表逻辑中的真和假，Boolean值只能用作布尔运算，通常用在流程控制结构中作为判断条件

boolean flag=true;
if(flag){
System.out.println("如果flag值为true，则控制台打印此句话");

数据类型的转换
boolean类型与其他类型不能进行类型的转换，自动类型转换与强制类型转换都不可以

Java并不会把这个较小的整数常量 直接当成一个大的类型常量来处理，依然会当成小的类型常量来处理，但是此时这个小类型的变量的值会自动将类型转换为大的类型

自动类型转换：基本数据类型中，按照精度从低到高的顺序其优先关系为byte>short>int>long>float>double

例如，使用int类型的变量可以自动为float类型的变量赋值，此时int类型会自动转化为float类型

int num1=124;
float num2=num1;
System.out.println("num1:"+num1);
System.out.println("num2:"+num2);

输出结果为124
124.0

关系式
byte+short+char +int == int
byte+short+int+char +long==long
byte+short+int+char+long +float ==float
byte+short+int+char+long+float +double =double

package come.inspur.ch2;

public class TypeTransferDemo01 {
	/**
	 * 自动类型转换实例   自动类型转换规则
	 * @param args
	 */

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		byte b=127;
		int num=789;
		float f = 234;
		double d = 45;
		System.out.println("byte类型数据和int类型数据相乘："+(b*num)+",结果的数据类型为："
		+getType( (b*num)));
		System.out.println("byte类型数据和float类型数据相乘："+(b*f)+",结果的数据类型为："
		+getType( (b*f)));
		System.out.println("int类型数据和double类型数据相乘："+(d*num)+",结果的数据类型为："
		+getType( (d*num)));
		

	}
/**
 * 声明公用方法返回参数的数据类型
 * @param o
 * @return
 */
	public static String getType(Object o) {
		return o.getClass().toString();
		
	}
}




byte类型数据和int类型数据相乘：100203,结果的数据类型为：class java.lang.Integer
byte类型数据和float类型数据相乘：29718.0,结果的数据类型为：class java.lang.Float
int类型数据和double类型数据相乘：35505.0,结果的数据类型为：class java.lang.Double

布尔类型例子

package three;

public class Typeboolean {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
			boolean b;
			b=false;
			System.out.println("b的值是"+b);
			b=true;
			System.out. println("b的值是"+b);
			if(b)System.out.println("如果b的值是true，会显示这行文本");
	}

}

b的值是false
b的值是true
如果b的值是true，会显示这行文本

测试 定义两个布尔类型并赋值

强制类型转换
将高精度的数值赋给低精度的数值变量 必须使用强制类型转换
强制类型转换有一定语法要求 规则是
（类型名称） 要转换的值或变量

package come.inspur.ch2;

public class TypeTransferDemo02 {
	/**+
	 * 强制类型转换实例
	 * @param args
	 */

	public static void main(String[] args) {
		// TODO- 自动生成的方法存根
		//强制类型转换代码演示
		float f = 234;
		double b=45;
		
		//将float类型直接赋给int时会报错
		//int num1= f；
		
		//应该这样操作
		int mun_1=(int)f;
		//将double类型赋值给float类型 也必须进行强制类型转换
		float mun_b = (float)b;
		System.out.println("mun_1:"+mun_1+",数据类型为"+getType(mun_1));
		System.out.println("mun_b:"+mun_b+",数据类型为"+getType(mun_b));
		

	}
	
	/**声明公用方法返回参数类型
	 * @param o
	@return */
			 public static String getType (Object o) {
		 return o.getClass().toString();
	 }
}
mun_1:234,数据类型为class java.lang.Integer
mun_b:45.0,数据类型为class java.lang.Float

布尔例子

package three;

public class Typeofbooleaneg1 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		


		boolean b1 = true;
		boolean b2 = false;
		//下面代码将出现错误：字符串不能直接变成boolean型的值
		//boolean b3 = "true";
		//使用boolean和字符串进行连接运算，boolean会自动转换成字符串
		String str = true + "";
		//下面将输出true
		System.out.println(str);
	}



	}


输出 true

使用强制类型转换可能会导致精度的缺失

运算符

按照操作数目分 有
一元运算符 ++ - -
二元运算符 + - < > =
三元运算符 ? :

按功能分
算术运算符 加减乘除取余
位运算符 $ | ^ ~ >> << >>>
逻辑运算符 ！ && ||
关系运算符 > < >= <= == !=
赋值运算符 =
扩展赋值运算符 += -= *= =
字符串连接运算符 +

基本运算符实例

package three;

public class Operatordemo1 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int a = 6;
		int b = 27;
		int c = 3;
		int d = (int)b/a;
		System.out.println(a-b);
		System.out.println(a*b);
		System.out.println(a/b);
		System.out.println(a/c);
		System.out.println(d);
		

	}

}

实例二
copy

package three;
import java.util.Scanner;

public class Operatordemo2 {

public static void main(String[] args) {
	// TODO 自动生成的方法存根
	   Scanner scan = new Scanner(System.in);
        System.out.println("请输入一个英文字符串或解密字符串");
        String password = scan.nextLine();// 获取用户输入
        char[] array = password.toCharArray();// 获取字符数组
        for (int i = 0; i < array.length; i++) {// 遍历字符数组
            array[i] = (char) (array[i] ^ 20000);// 对每个数组元素进行异或运算
        }
        System.out.println("加密或解密结果如下：");
        System.err.println(new String(array));// 输出密钥
}

}

取余运算符
取余运算符一般用于除法中，它的取值不是商，而是余数
5/2 取余运算符取得是余数1

使用递增和递减运算符

package three;

public class Dione {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int a = 199;
		int b = 1009;
		System.out.println(a++);
		System.out.println(a);
		System.out.println(++a);
		System.out.println(a);
		System.out.println(b--);
		System.out.println(--b);
		System.out.println(b);

	}

}

a++会直接输出原数 但是加一
++a会输出+1后的数字

package three;

public class Dionedemo1 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int x=2;
		int y=3;
		int x1=7;
		int y1=8;
		System.out.println(x1+x++);
		System.out.println(x);
		
		System.out.println(++y-x);
		System.out.println(y);
		System.out.println(x);
		System.out.println(x1---y);
		System.out.println(y);
		System.out.println(--y1*y);

	}

}

减减y1*y首先 算的是自减后是乘

package three;
import java.math.BigDecimal;
public class Accultyfloat {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		
		
		
		
		        double money = 2;// 现有金额
		        double price = 1.1;// 商品价格
		        double result=money - price;
		        System.out.println("非精确计算");
		        System.out.println("剩余金额："+result);// 输出运算结果
		        // 精确浮点数的解决方法
		        BigDecimal money1 = new BigDecimal("2");// 现有金额
		        BigDecimal price1 = new BigDecimal("1.1");// 商品单击
		        BigDecimal result1=money1.subtract(price1);
		        System.out.println("精确计算");
		        System.out.println("剩余金额："+result1);// 输出精确结果
		    }
		

			
		

	}

package three;

public class Guanxi {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		int d=10;
		int k=12;
		int j=111;
		System.out.println(d<k||k<j);
		System.out.println(d>k&&k<j);
		System.out.println(!(d>k));

	}

}

实现2的累乘

package three;
import java.util.Scanner;
public class Guanxiyunsuanfu {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		
		
		
		  
		        Scanner scan=new Scanner(System.in);// 创建扫描器
		        System.out.println("请输入一个整数");
		        long number = scan.nextLong();// 获取输入的整数
		        System.out.println("你输入的数字是："+number);
		        System.out.println("该数字乘以2的运算结果为："+(number<<1));
		        System.out.println("该数字乘以4的运算结果为："+(number<<2));
		        System.out.println("该数字乘以8的运算结果为："+(number<<3));
		        System.out.println("该数字乘以16的运算结果为："+(number<<4));
		    }
		

		
		
		
		
		

	}

表示a非

package fanli;

public class data15
{
public static void main(String[] args)
{
int a=2;
System.out.println("a 非的结果是："+(~a));
}
}

2取反为-3
假设2以一个字节存储，则其补码为：00000010（正数的原码和补码是一样的），则取反后得到11111101这么一个补码，将这个补码转换成原码得到的结果就是－3了。转换过程如下：
11111101－－将该数减1求反码得 11111100－－除符号位外每位取反求原码得10000011，最高位表示符号位

条件运算符
作用 决定把哪个值赋值给前面的变量
语法格式
变量布尔表达式 ？ 表达式1：表达式2

package three;

public class Judgegrade {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int score = 68;
		String mark = (68>60) ? "及格":"不及格";
				System.out.println("考试成绩如何："+mark);
		
		

	}

}

package three;

public class Tiaodemo1 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		
		        char x = 'X';   
		        int i = 0;   
		        System.out.println(true ? x : 0);    
		        System.out.println(false ? i : x);    
		    }   
		 

	}

输出  x
     88

直接复制的  没看懂`在这里插入代码片`
import java.util.Scanner;

public class VariableExchange {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);// 创建扫描器
        System.out.println("请输入变量A的值");
        long A = scan.nextLong();// 接收第一个变量值
        System.out.println("请输入变量B的值");
        long B = scan.nextLong();// 接收第二个变量值
        System.out.println("A=" + A + "\tB=" + B);
        System.out.println("执行变量互换...");
        A = A ^ B;// 执行变量互换
        B = B ^ A;
        A = A ^ B;
        System.out.println("A=" + A + "\tB=" + B);
    }
}

public class kuozhan
{
	public static void main(String[] args) 
	{
		//定义一个byte类型的变量
		byte a = 5;
		//下面语句出错，因为5默认是int类型，a + 5就是int类型。
		//把int类型赋给byte类型的变量9，所以出错。
		a = a + 5;
		//定义一个byte类型的变量
		byte b = 5;
		//下面语句将不会出现错误
		b += 5;
	}
}

public class OperatorSign {
	public static void main(String[] args) {
		int a = 3, b = 4;
		int intA = a / b; 				// 根据基本类型自动转换规则，除数与被除数都是整数，
		float intB = a / b;
		float intC = a / (b * 2.0f); 		// 对于声明为float类型的数字，数字后加f,
		double intD = a / (b * 2.0d); 	// 对于声明为double类型的数字，数字后加d.
		int a1 = 10;
		int b1 = 3;
		double c = 2;
		System.out.println("(intA=a/b),intA=" + intA);
		System.out.println("(intB=a/b),intB=" + intB);
		System.out.println("(intC=a/(b*2.0f)),intC=" + intC);
		System.out.println("(intD=a/(b*2.0d)),intD=" + intD);
		System.out.println(a1 + "/" + b1 + "=" + (a1 / b1));
		System.out.println(a1 + "%" + b1 + "=" + (a1 % b1));
		System.out.println(a1 + "/" + c + "=" + (a1 / c));
		System.out.println(a1 + "%" + c + "=" + (a1 % c));
		int x = 12;
		int a2 = x + x++;  		//定义一个自增的变量
		System.out.println("a2=" + a2);
		System.out.println("x=" + x);
		int b2 = x++ + x;
		System.out.println("b2=" + b2);
		System.out.println("x=" + x);
		int c2 = x + x--;			//定义一个自减的变量
		System.out.println("c2=" + c2);
		System.out.println("x=" + x);
		int d = x + --x;
		System.out.println("d=" + d);
		System.out.println("x=" + x);
	}
}

package three;

public class Daimafuzhi {

public static void main(String[] args) {
	// TODO 自动生成的方法存根
	
	
			int a = 3, b = 4;
			int intA = a / b; 				// 根据基本类型自动转换规则，除数与被除数都是整数，
			float intB = a / b;
			float intC = a / (b * 2.0f); 		// 对于声明为float类型的数字，数字后加f,
			double intD = a / (b * 2.0d); 	// 对于声明为double类型的数字，数字后加d.
			int a1 = 10;
			int b1 = 3;
			double c = 2;
			System.out.println("(intA=a/b),intA=" + intA);
			System.out.println("(intB=a/b),intB=" + intB);
			System.out.println("(intC=a/(b*2.0f)),intC=" + intC);
			System.out.println("(intD=a/(b*2.0d)),intD=" + intD);
			System.out.println(a1 + "/" + b1 + "=" + (a1 / b1));
			System.out.println(a1 + "%" + b1 + "=" + (a1 % b1));
			System.out.println(a1 + "/" + c + "=" + (a1 / c));
			System.out.println(a1 + "%" + c + "=" + (a1 % c));
			int x = 12;
			int a2 = x + x++;  		//定义一个自增的变量
			System.out.println("a2=" + a2);
			System.out.println("x=" + x);
			int b2 = x++ + x;
			System.out.println("b2=" + b2);
			System.out.println("x=" + x);
			int c2 = x + x--;			//定义一个自减的变量
			System.out.println("c2=" + c2);
			System.out.println("x=" + x);
			int d = x + --x;
			System.out.println("d=" + d);
			System.out.println("x=" + x);
		}
	


}

尽量用圆括号来控制优先级

字符串的初始化

强制类型转换
package three;

public class Daimaqiangzhi {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		double doublenum = 2.333;
		int intnum = 0;
		intnum =(int) doublenum;
		System.out.println(intnum);
		

	}

}

将浮点数强制转化为整型数

package three;

public class Daimaqiangzhi2 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		float num1 = 2.333f;
		int num2 = 3;
		int num3 = 0;
		num3 = (int) num1+num2;
		System.out.println(num3);
		
	}

}

注意点
1 定义常量
主要使用final关键字（灵活使用Static关键字）来进行常量的定义，当常量被设定后，一般情况下不允许更改
定义Java常量时，就要对常量进行初始化
关键字final不仅可以用来修饰基本数据类型的常量，而且可以用来修饰对象的引用或方法，数组就是对象引用
常量取名一般为大写，是为了和变量做区分

2 char
char类型用单引号引起来 字符串用双引号引起来
Java中单引号，双引号，反斜线都有特殊用途，若一个字符串中包含这些特殊字符，应该使用转义字符
表示c：\daima 应该写成 c:\daima

3 整数不可以除以0

课后练习
摄氏温度转华氏温度

package three;
import java.util.Scanner;
public class Zuoyeteansform {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入温度的值：");
		long A = scan.nextLong();
		double B = 0;
		B = A*33.8;
		System.out.println(B);
		
		
		

	}

}

计算圆的面积和周长

package three;
import java.util.Scanner;

public class Zuoyetransform2 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner scan = new Scanner (System.in);
		System.out.println("请输入半径：");
		double A = scan.nextLong();
		double Square = 0;
		double Zhouchang = 0;
		final double Pi = 3.1415926;
		
		
		Zhouchang = 2*Pi*A;
		Square = Pi* A * A;
		System.out.println(Zhouchang);
		System.out.println(Square);
		

	}

}

本文地址：https://blog.csdn.net/weixin_52006337/article/details/113933747