Java学习_day002：变量

最新推荐文章于 2024-08-26 23:57:38 发布
最新推荐文章于 2024-08-26 23:57:38 发布
阅读量195 收藏 1
点赞数
分类专栏： 笔记 文章标签： java 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/litter_m/article/details/105214954
版权

一、变量

1.什么是变量

在内存中开辟的存储空间，用于存放运算过程中的需要用到的数据。（存数的，代词----指代它所储存的那个数）

1.1 变量的声明

用特定的语法声明一个变量，让运行环境为其分配空间。
（在银行开立一个账户）

int a;
1.2 变量的初始化

对变量的第一次赋值。（给账户存钱）

int a;
a=10;
int b=10;
1.3 变量的使用

①对变量的使用就是对它所存数的使用

int a=5;
int b=a+10;//取出a的值5，加10后赋值给b；
System.out.println(b);//输出变量b的值。
System.out.println("b");//输出字母b，双引号中原样输出。

②变量的使用必须与数据类型匹配
③变量在使用前必须声明并初始化

1.4变量的命名

只能包含字母、数字、_、$;不能以数字开头。
严格区分大小写
不能使用关键字
允许使用中文但不建议
建议英文的“见名知意”
score,myScore,myJavaScore---------------驼峰命名法（变量）
Score,MyScore,MyJavaScore---------------帕斯卡命名法（类）

package day002;
//变量的演示
public class VarDemo {

	public static void main(String[] args) {
//1.变量的声明：开了个账户
		int a;//声明了一个整形变量名为a
		int b,c,d;//声三个整形变量名为b/c/d
//2.变量的初始化：第一次赋值；给账户存钱
		int e=250;//声明整形变量e并且赋值为250
		int f;//声明整形变量f		
		f=250;//给f赋值为250
		f=360;//修改变量f的值为360
//变量的使用：用得是账户中的钱
		int g=5;
		int h=g+10;//取出g的值5，加10后，在赋值给h
		System.out.println(h);//输出变量h的值
		System.out.println("h");//输出字母h
		//int i=3.14//编译错误，数据类型不匹配
		//System.out.println(i);//未声明变量i
		int i;
		//System.out.println(i);//声明后未赋值
//4.变量的命名
	int a1,a_5$,_$;
	//int a*a;不能使用*
	//int 1a;不能使用数字开头
	int aa=5;
	//System.out.println(Aa);大小应该区分
	//int class;不可占用关键词
	int 年龄;//可，但不建议
	int age;//建议使用
	int score,myScore,myJavaScore--------驼峰命名法（变量）
	}

}

二、基本数据类型

**八种基本类型：byte,short,int,long,float,double,boolean,char
关于大小单位换算：1G=1024M（兆）;1M=1024KB（千字节）;1KB=1024B（字节）;1B=8Bit（位）

1. int 整形

占用4个字节；取值：-21个多亿到21个多亿；

1.1 整数直接量默认为int类型，但不能超过范围，一旦超出则会发生编译错误。
1.2 两个整数相除还是整数，小数位无条件舍弃。
1.3 整数运算时若超出范围，会发生溢出（溢出需要避免）。
2. long 长整型

占用8个字节，取值：9百万万亿↑；

2.1 长整型直接量需要在数字后加L或者l
2.2 整数运算时，如果可能发生溢出，建议在第一个数字后加L。
3. double 浮点型

占用8个字节，取值范围很大；

3.1 浮点数直接量默认为double型，表示float需要在数后加F或f；
3.2 double和float型数据参与运算时，可能会发生舍入误差（精确场合不能使用）；
package day002;
//数据类型 的演示
public class DataTypeDemo {

	public static void main(String[] args) {
//1. int:整形，4字节，-21多亿到21多亿
	int a=25;//25为整数直接量，默认int型
	//int b=10000000000;//超出范围所以编辑错误；
	System.out.println(5/2);//2	
	System.out.println(2/5);//0	
	System.out.println(5.0/2);	//2.5
	int c=2147483647;//int的最大值
	int d=c+1;
	System.out.println(d);//-2147483648(int最小值)
//2.long:长整型，8个字节，很大很大
	//long e=10000000000000;//编译错误，如不加L，则默认为int；
	long f=1000000000000l;//长整型直接量需要在数字后加L
	long g=1000000000*2*10L;
	System.out.println(g);//200yi
	long h=1000000000*3*10L;
	System.out.println(h);//yichu
	long i=1000000000L*3*10;
	System.out.println(i);//300yi
//3.double:浮点型，8个字节，很大很大
	double ao=3.1415986;//3.1415986为浮点数直接量，默认double型
	double j=6.0,k=4.9;
	System.out.println(j-k);
//4. boolean:布尔型，1字节
	boolean b1=true;//true为布尔型的直接量
	boolean b2=false;//false为布尔型的直接量
	//boolean b3=25;//编辑错误，布尔型只能取值为true或者false；
//5.char:字符型，2个字节
	char c1='女';//字符女
	char c2='f';//字符f
	char c3='8';//字符8
	char c4=' ';//字符空格
	//char c5=女;//编译错误，字符必须在单引号中
	//char c6='';//不允许空字符
	//char c7='女男';//不允许多字符
	char c8=65;//直接写了代码,其等于char c8='A';0到65535之间
	System.out.println(c8);//A
//类型间的转换：
   int a=5;
   long b=a;//自动类型转换
   //int c=b;//由大到小要强转，这样为编辑错误
   int c=(int)b;//强转类型转换
   long d=5;//自动类型转换
   double e=5;//自动类型转换
   long f=100000000000l;
   int g=(int)f;
   System.out.println(g);//发生溢出现象，故强转有可能会发生溢出；
   double h=45.987;
   int i=(int)h;
   System.out.println(i);//强转有可能丢精度
   byte b1=5;//整数直接量可以直接赋值给byte、short、char
   byte b2=6;
  // byte b3=b1+b2;//byte、short、char型数据参与运算时，会先一律转换为int再运算,int比byte等级高，
  byte b4=~~(byte)( b1+b2);如果不加后面括号，会发生优先级报错；
	}

}
4. boolean 布尔型

占用1个字节，只能赋值true或false；

4.1 只能取true或false
5. char 字符型

占用2个字节

5.1 采用Unicode字符集编码，每个字符都有一对应码；表现形式是字符char，本质上是int；

ASCII码**（‘a’—97 ‘A’-------65 ‘0’------48）**
在这里插入图片描述

5.2 字符型直接量必须在单引号里面，只能有一个
5.3 特殊字符需要通过前加“\”来处理，例如‘\；’输出‘；’

三、类型间转换

类型从小到大依次为：byte-----short----int----long—float—double
char—int

1. 两种方式
1.1 自动类型转换：小类型到大类型
1.2 强转类型转换：大类型到小类型

语法：（要转成的类型）变量
注意：强转有可能会溢出or丢失精度；

2. 两点规则
2.1 整数直接量可以直接赋值给byte、short、char，但不能超出范围。
2.2 byte、short、char型数据参与运算时，会先一律转换为int再运算；
int a;//int a;int a;int a;int a;
		int b,c,d;//int b,c,d;int b,c,d;int b,c,d;int b,c,d;
        int e=25;//int e=25;int e=25;int e=25;int e=25;
		int f;f=25;
   //4 int f;f=25;
  //3 int f;f=25;
 //2 int f;f=25;
//1 int f;f=25;		
		int g=25;int h=g+10;
   //4  int g=25;int h=g+10;
  //3  int g=25;int h=g+10;
 //2  int g=25;int h=g+10;	
//1  int g=25;int h=g+10;
    //5 int i=34.567;
   //4 int i=34.567;
  //3 int i=34.567;
 //2 int i=34.567;
//1 int i=34.567;
    //5 System.out.println(j);
   //4 System.out.println(j);
  //3 System.out.println(j);
 //2 System.out.println(j);
//1 System.out.println(j);
/*5 int j;
		System,out.println(j);*/
/*4 int j;
System.out.println(j); */
/*3 int j;
System.out.println(j); */
/*2 int j;
System.out.println(j); */
/*1 int j;
System.out.println(j); */

int a=25;//int a=25;int a=25;int a=25;int a=25;
    //5 int b=10000000000;
   //4 int b=10000000000;
  //3 int b=10000000000;
 //2 int b=10000000000;
//1 int b=10000000000;
System.out.println(5/3);//1
   //4 System.out.println(5/3);
  //3 System.out.println(5/3);
 //2 System.out.println(5/30);
//1 System.out.println(5/3);
System.out.println(3/5);//0
   //4 System.out.println(3/5);
  //3 System.out.println(3/5);
 //2 System.out.println(3/5);
//1 System.out.println(3/5);
System.out.println(3.0/5);//0.6
   //4 System.out.println(3.0/5);
  //3 System.out.println(3.0/5);
 //2 System.out.println(3.0/5);
//1 System.out.println(3.0/5);
int c=2147483647;
   //4 int c=2147483647;
  //3 int c=2147483647;
 //2 int c=2147483647;
//1 int c=2147483647;
int d=c+1;System.out.println(d);
   //4 int d=c+1;System.out.println(d);
  //3 int d=c+1;System.out.println(d);
 //2 int d=c+1;System.out.println(d);
//1 int d=c=1;System.out.println(d);
		long e=10000000000L;System.out.println(e);
   //4 long e=10000000000L;System.out.println(e);
  //3 long e=10000000000L;System.out.println(e);
 //2 long e=10000000000L;System.out.println(e);
//1 long e=10000000000L;System.out.println(e);
		long g=1000000000*2*10L;System.out.println(g);
   //4 long g=1000000000*2*10L;System.out.println(g);
  //3 long g=1000000000*2*10L;System.out.println(g);
 //2 long g=1000000000*2*10L;System.out.println(g);
//1 long g=1000000000*2*10L;System.out.println(g);		
		long h=1000000000L*3*10;System.out.println(h);
   //4 long h=1000000000L*3*10;System.out.println(h);
  //3 long h=1000000000L*3*10;System.out.println(h);
 //2 long h=1000000000L*3*10;System.out.println(h);
//1 long h=1000000000L*3*10;System.out.println(h);		
double i=25.789;
   //4 double i=25.678;
  //3 double i=25.878;
 //2 double i=25.789;
//1 double i=25.789;
double j=6.0,k=4.9;System.out.println(j-k);
   //4 double j=6.0,k=4.9;System.out.println(j-k);
  //3 double j=6.0,k=4.9;System.out.println(j-k);
 //2 double j=6.0,k=4.9;System.out.println(j-k);
//1 double j=6.0,k=4.9;System.out.println(j-k);
		

boolean b1=true;
   //4 boolean b1=true;
  //3 boolean b1=true;
 //2 boolean b1=true;
//1 boolean b1=true
boolean b2=false;
   //4 boolean b2=false;
  //3 boolean b2=false;
 //2 boolean b2=false;
//1 boolean b2=false;
    //5 boolean b3=25;
   //4 boolean b3=25;
  //3 boolean b3=25;
 //2 boolean b3=25;
//1 boolean b3=25;
char c1='女';//char c1='女';char c1='女';char c1='女';char c1='女';
char c2='f';//char c2='f';char c2='f';char c2= 'f';char c2='f';
char c3='8';//char c3='8';char c3='8';char c3='8';char c3='8';
char c4=' ';//char c4=' ';char c4=' ';char c4=' ';char c4=' ';
    //5 char c5='';
   //4 char c5='';
  //3 char c5='';
 //2 char c5='';
//1 char c5='';
    //5 char c6=女；
   //4 char c6=女;
  //3 char c6=女;
 //2 char c6=女;
//1 char c6=女;
    //5 char c7='中国';
   //4 char c7='中国';
  //3 char c7='中国';
 //2 char c7='中国';
//1 char c7='中国';
char c8='\"';System.out.println(c8);
   //4 char c8='\"';System.out.println(c8);
  //3 char c8='\"';System.out.println(c8);
 //2 char c8='\"';System.out.println(c8);
//1 char c8='\"';System.out.println(c8);
char c9=65;System.out.println(c9);
   //4 char c9=65;System.out.println(c9);
  //3 char c9=65;System.out.println(c9);
 //2 char c9=65;System.out.println(c9);
//1 char c9=65;System.out.println(c9);

	int a=5;long b=a;int c=(int)b;
   //4 int a=5;long b=a;int c=(int)b;
  //3 int a=5;long b=a;int c=(int)b;
 //2 int a=5;long b=a;int c=(int)b;
//1 int a=5;long b=a;int c=(int)b;
		long d=5;
   //4 long d=5;
  //3 long d=6;
 //2 long d=7;
//1 long d=7;
		double e=5;
   //4 double e=6;
  //3 double e=7;
 //2 double e=8;
//1 double e=9
long f=10000000000l;int g=(int)f;System.out.println(g);
   //4 long f=10000000000l;int g=(int)f;System.out.println(g);
  //3 long f=10000000000l;int g=(int)f;System.out.println(g);
 //2 long f=10000000000l;int g=(int)f;System.out.println(g);
//1 long f=10000000000l;int g=(int)f;System.out.println(g);
double h=45.987;int i=(int)h;System.out.println(i);
   //4 double h=45.987;int i=(int)h;System.out.println(i);
  //3 double h=45.678;int i=(int)h;System.out.println(i);
 //2 double h=46.456;int i=(int)h;System.out.println(i);
//1 double h=46.123;int i=(int)h;System.out.println(i);
byte b1=5;byte b2=6;byte b4=(byte)(b1+b2);
   //4 byte b1=5;byte b2=6;byte b4=(byte)(b1+b2);
  //3 byte b1=5;byte b2=6;byte b4=(byte)(b1+b2);
 //2 byte b1=5;byte b2=6;byte b4=(byte)(b1+b2);
//1 byte b1=5;byte b2=6;byte b4=(byte)(b1+b2);

	
		//‘a’---97     ‘A’-------65     ‘0’------48
    //5 System.out.println('2'+'2');
   //4 System.out.println('2'+'2');
  //3 System.out.println('2'+'2');
 //2 System.out.println('2'+'2');
//1 System.out.println('2'+'2');
		long time=System.currentTimeMillis();System.out.println(time);
   //4 long time=System.currentTimeMillis();System.out.println(time);
  //3 long time=System.currentTimeMillis();System.out.println(time); 
 //2 long time=System.currentTimeMillis();System.out.println(time);
//1 long tiem=System.currentTimeMillis();System.out.println(time);
		int a=5;a=a+10;System.out.println(a);
   //4 int a=5;a=a+10;System.out.println(a);
  //3 int a=5;a=a+10;System.out.println(a);
 //2 int a=5;a=a+10;System.out.println(a);
//1 int a=5;a=a+10;System.out.println(a);
    //5 double money=5000;money=money*0.8;System.out.println(money);
   //4 double money=5000;money=money*0.7;System.out.println(money);
  //3 double money=6000;money=money-1000;System.out.println(money);
 //2 double money=7000;money=money-2000;System.out.println(money);
//1 double money=8000;money=money*0.6;Syetem.out.println(money);
litter_m
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java学习day02:IDEA自动联想功能、快捷键、注释、基本数据类型，标识符，定义变量与赋值变量与变量作用域
无悔的博客
06-01 2198
在JavaIDEA中，输入以下字母可以触发代码自动联soutforiifnifnn。
%JAVA_HOME% bin_JAVA_HOME环境配置
weixin_42168265的博客
02-23 7169
Java环境变量配置windows xp下配置JDK环境变量：1.安装JDK，安装过程中可以自定义安装目录等信息，例如我们选择安装目录为D:\java\jdk1.5.0_08；2.安装完成后，右击“我的电脑”，点击“属性”；3.选择“高级”选项卡，点击“环境变量”；4.在“系统变量”中，设置3项属性，JAVA_HOME,PATH,CLASSPATH(大小写无所谓),若已存在则点击“编辑”，不存在则...
Java基础知识测试题
大磊的学习笔记
08-12 2355
选择题： 1、下列说法正确的是（ ） A、 JAVA程序的main方法必须写在类里面 B、 JAVA程序中可以有多个main方法 C、 JAVA程序中代码的执行可以不从main开始 D、 JAVA程序的main方法中如果只有一条语句，可以不用{}(大括号)括起来 2、变量命名规范说法正确的是（ ） A、 变量由字母、下划线、数字、$符号随意组成； B、 变量不能以数字作为开头； C、 A和a在ja...
声明变量
bantai6413的博客
04-19 82
package review20140418;/** 声明变量（1.区分大小写 2.首写字母不能以数字开头* 3.不能使用关键字 4.可以一$字母，下划线开头）*/public class Test2 { //程序的入口 public static void main(String[] args) { /* 整数类型*/ ...
java基本数据类型 byte、short、int、long、float、double、char的范围和运算中注意的事项(详细)
热门推荐
i6223671的博客
03-09 2万+
1.Java的8种基本数据类型及其所占空间大小： 注意: ①为什么float占4个字节,而long占8个字节,float表示的范围却比long要大得多呢? 原因简单说是因为二者存储的模式不同,long类型是是直接用64位二进制位去存储数据的二进制原码,而float作为浮点数类型,在java里遵循IEEE754标准,将32位分为3个部分,第一部分1位存储符号,第二部分8位存储浮点数的科学表示后的指...
Java基础_day01_JDK和JRE+环境变量配置
huang_yang_fan的博客
03-21 2891
Java虚拟机——JVM JVM（Java Virtual Machine ）：Java虚拟机，简称JVM，是运行所有Java程序的假想计算机，是Java程序的 运行环境，是Java 最具吸引力的特性之一。我们编写的Java代码，都运行在 JVM 之上。 跨平台：任何软件的运行，都必须要运行在操作系统之上，而我们用Java编写的软件可以运行在任何的操作系 统上，这个特性称为Java语言的跨平台特性。该特性是由JVM实现的，我们编写的程序运行在JVM上，而JVM 运行在操作系统上。 JRE 和 JDK
Day3:Java变量、+号作用、数据类型
W_090623的博客
05-05 1669
自学Java第三天--Java变量、数据类型
Java学习_Day 02(学习内容：狂神说JAVA零基础P12-P17)
好一个区块链
04-01 4022
P12 1 JAVA发展 1.1 构建工具 Ant, Maven, Jekins 1.2 应用服务器 Tomcat, Jetty, Jboss, Websphere, Weblogic 1.3 Web开发 Struts, Spring, Hibernate, myBatis 1.4 开发工具 Eclipse, Netbean, intellij idea, Jbuilder P15 1 JAVA三大版本 JavaSE：标准版（桌面程序，控制台开发等） JavaME：嵌入式开发（手机，小家电等） JavaEE
Day22_7 Java学习之对象数组
weixin_43717536的博客
07-22 1万+
一、先定义，再开辟数组空间类名称对象数组名[]=null;对象数组名=new类名称[长度];二、定义并开辟数组空间类名称对象数组名[]=new类名称[长度];特别注意在声明对象数组后，必须对每个数组成员进行实例化之后才能直接使用，否则报空指针异常！Studentstudent[]={newStudent("小王",20),newStudent("小明",20),newStudent("小红",20)}；...
java 引用类型变量_Java基本类型变量与引用类型变量
weixin_42489088的博客
02-21 2998
Java中数据类型分为两大类：基本数据类型与复合数据类型。相应地，变量也有两种类型：基本类型与引用类型。Java的8中基本类型的变量称为基本类型变量，而类、接口和数组变量时引用类型变量。这两种类型变量的结构和含义不同，系统对他们的处理也不相同。1.基本类型与引用类型变量*基本类型(primitive type)基本数据类型的变量包含了单个值，这个值的长度和格式符合变量所属数据类型的要求，可以是一个...
PySpark_Day02：安装部署及应用开发.pdf
03-24
在安装完成后，需要设置环境变量，包括 JAVA_HOME、HADOOP_HOME 和 ANACONDA_HOME 等。这些环境变量用于指定软件的安装路径和配置文件的位置。 知识点5: PySpark 库安装 在 PyCharm 中开发 PySpark 应用需要安装 ...
Caused by: java.sql.SQLException: JZ0SJ: 没有在此数据库中发现元数据存取器信息。 请按 jConnect 文档中所述安装
03-21
标题中的“Caused by: java.sql.SQLException: JZ0SJ: 没有在此数据库中发现元数据存取器信息。 请按 jConnect 文档中所述安装”是一个典型的错误信息，表明在尝试使用Java数据库连接（JDBC）驱动程序访问数据库时...
java_in_one_day
03-22
本教程“java_in_one_day”将带你快速入门，理解Java的核心概念，并教你如何编写简单的程序。 首先，你需要安装Java Development Kit（JDK），它是开发和运行Java程序的必备工具集。访问Oracle官网，根据你的操作...
Java开发零基础篇：Day02 变量和运算符.pdf
11-03
在Java开发零基础篇的Day02中，我们主要学习了变量和运算符的基础知识。这是Java编程中非常基础且重要的概念，尤其适合刚开始接触Java的初学者。我们将详细探讨以下几个方面的知识点： 1. 变量的概念与特点 变量在...
Java_1:Java编程基础
05-18
Learn_core_java_day_1 第一天：Java编程基础知识 第二天：变量，数据类型和赋值。 第三天：更多变量/类型转换 第四天：介绍对象 第五天：方法/功能 第六天：自定义课程 第七天：JavaDoc和单元测试 第八天：If-...
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 123
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 585
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
基于jenkins部署maven项目
静水深流
08-26 195
如上所示，构建后，我们处于项目的根目录之下，可以进行后续的操作，如启动target目录下的jar包、将jar包传输到需要部署的服务器上、打docker镜像bing上传等等，需要根据实际情况进行选择，而这些都可以在“Add post-build step”选项中进行选择。我们主要关注上述几个部分，在General部分，可以对项目进行一个简单的描述，源码管理部分，需要配置对应的源码url，如下图所示。如上所示，选择“构建一个maven项目”，如果没有改选项，则需要安装maven构建的插件，请参考之前的文章。
死锁及其产生条件
最新发布
秋夫人
08-26 230
死锁是指两个或多个线程（或进程）互相等待对方释放资源，导致所有相关线程都无法继续执行的情况。这是并发编程中的一个常见问题，可能会导致系统部分或完全停止响应。
note_spark_day01：spark 基础环境
09-26
通常建议使用Oracle JDK的最新稳定版本，然后设置JAVA_HOME环境变量。 其次，我们需要安装Spark本身。Spark官方网站提供了预编译的二进制发行版，我们可以从网站上下载并解压缩到我们喜欢的位置。然后，我们可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值