j2se学习笔记

最新推荐文章于 2024-09-14 21:48:00 发布

一枕残梦千里殇灬

最新推荐文章于 2024-09-14 21:48:00 发布

阅读量680

点赞数

分类专栏： JavaSE 文章标签： j2se float byte java string 语言

本文链接：https://blog.csdn.net/cct0315/article/details/6522146

版权

JavaSE 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

★查看 java版本信息：java –version

★标识符： java对各种变量、方法和类等要素命名时使用的字符序列称为标识符。（凡是可以自己起名字的地方都叫标识符，args也可以自己起名字）

Java标识符命名规则：

1.标识符由字母、下划线“ _”、美元符“$”或数字组成。

2.标识符应以字母、下划线、美元符开头。

3.java标识符大小写敏感，长度无限制。

约定成俗：java标识符选取应注意“见名知意”且不能与java语言的关键字重名。

★关键字： java中一些赋以特定的含义，用做专门用途的字符串称为关键字（keyword）

大多数编辑器会将关键字用特殊方式标出

所有 java关键字都是小写英文。

goto和 const虽然从未使用，但也被作为java关键字保留。

★ java常量

Java的常量值用字符串表示，区分为不同的数据类型。

如：整型常量 123

实型常量 3.14

字符常量 ‘a’

逻辑常量 true、false

字符串常量 “helloworld”（注意区分字符常量和字符串常量）

注意：常量这个名词还会用在另外其它语境中表示值不可变的变量。如： C语言中的const，在java里叫final，不叫const

★ java变量：变量是程序中最基本的存储单元，其要素包括变量名，变量类型，和作用域。

Java程序中每一个变量都属于特定的数据类型，在使用前必须对其声明。

本质上讲，变量其实是内存中的一小块区域，使用变量名来访问这块区域，因此，每一个变量使用前必须要先申请（声明），然后必须进行赋值（填充内存），才能使用。

★内存的分析（编译原理的内容）：

程序的执行过程：首先在硬盘上有一个程序存在，比方说一个 exe文件，比方说一个class文件，但是这个时候它还只是一个静态的文件。当它运行起来后，首先进行的第一步操作是把自己全部Load到内存区或者叫转载到内存区域，也就是把代码转载到内存里去，操作系统会找到这段代码的main方法然后开始执行，它开始执行以后，这个时候往往叫做内存管理。它往往会把执行过程中的内存分成四部分（不同的操作系统不一样，但最基础的是四部分），分别为code segment（代码区，存放代码用的），data segment（放静态变量，字符串常量），stack（存放局部变量），heap（叫堆，用来动态申请内存，基本上可以认为所有new出来的东西，全部都在堆里面）。

★ java变量的分类

●按被声明的位置划分：

1.局部变量：方法或语句块内部定义的变量（方法体内部声明的变量，包括形参，称为局部变量。方法体内部是指与方法对应的大括号内部）

2.成员变量：方法体外部，类体的内部定义（声明）的变量

【注意：类外面（与类对应的大括号外面）不能有变量的声明】

【凡是在大括号里面声明的变量，出了大括号就没人认识它了】

●按所属的数据类型划分：

基本数据类型包括四类八种，四类：逻辑型— Boolean、文本型—char、整数型—byte，short，int，long、浮点数型—float，double。

靠什么区分不同的数据类型？内存里占的小格的大小，除此之外，内存里占小格的大小有时是相同的，但是，这内存里的小格布局不一样，也就是里面的0101排列的不一样，靠这样也能区分开不同的数据类型。

··············· 逻辑型boolean

boolean 类型适于逻辑运算，一般用于程序流程控制

boolean 类型数据只允许取值true或false，不可以0或非0的整数替代true和false，这点和C语言不同。

用法举例：

boolean flag ；

flag = true;

if(flag){

//do something

}

· 字符型char

char 型数据用来表示通常意义上“字符”

字符常量为用单引号括起来的单个字符，例如：char eChar = ‘a’; char cChar = ‘中’；

Java 字符采用Unicode编码，那何为Unicode编码呢？任何东西在计算机内都用010101表示，每一个0，每一个1叫做一位，叫做一个bit，一个字节是8位，每个字符占两个字节，因而可用十六进制编码形式表示，例如：char c1 = ‘﹨u0061’;

注： Unicode是全球语言统一编码。

Java语言中还允许使用转义字符‘ ﹨’来将其后的字符转变为其它的含义，例如： char c2 = ’ ﹨n’；——// ’ ﹨n’代表换行符

补充：2进制、10进制、16进制之间的转换

在 java里字符型是用Unicode编码的，所以表示全世界所有的文字都可以。

★ 下面谈整数类型：

整数类型分为 byte，short，int，long四种。四种类型用什么来作区分？在内存里占得大小空间不一样。Byte类型占1个字节， short类型占2个字节 int占4个字节，long占8个字节。Byte类型占1个字节，你说它最大的数是多少呢？有人说了，是2的8次方个，其实不是这样，即便是2^8也是2^8-1，还有一个0呢，从0开始，到那个2^8-1整好是2^8个，在java里面没有无符号的整数。Java里面所有的数都是带符号的，因此是从负数到正数，这8位里面有一个单独拿出来作为这个数的符号，所以你再算一下这个表数的范围，就是这样的，Byte：-128~~127，因为中间有一个0，以是-2^7到2^7-1；short：-2^15~~2^15-1；int：-2^31~~^2^31-1；long：-2^63~~2^63-1。

Java各整数类型有固定的表数范围和字段长度，其不受具体操作系统的影响，保证 java程序的可移植性。

Java语言整型常量的三种表示形式：

十进制整数，如： 12，-314，0。

八进制整数，要求以 0开头，如：012。

十六进制数，要求以 0x或0X开头，如：0x12。

Java语言的整型常量默认为 int型，声明long型常量可以后面加‘l’或‘L’，如：

Int i1 =600； //正确；//必须加L否则会出错 long l1=88888888888888L

★浮点类型，四类八种

浮点类型与整数类型类似， java浮点类型有固定的表数范围和字段长度，不受平台影响。

Java浮点类型常量有两种表示形式

十进制数形式，例如： 3.14 314.0 .314

科学记数形式，例如： 3.14e2 3.14E2 100E-2

Java浮点型常量默认为 double型，如要声明一个常量为float型，则须在数字后面加f或F，如：

double d=12345.6； //正确；//必须加f，否则会出错 float f=12.3f

(int放 long不会出错，float放double会出错)

float占 4个字节，double占8个字节

对于浮点数来说，它占用 4个字节，这四个字节里最多可以表示多少个浮点数? 2^32个

在计算机内部表示浮点数其实是有误差的， float在小数点后七位就不精确了，double是小数点后15位。

★下面来看 TestVar2.java这个例子程序：

public class TestVar2 {

public static void main(String[] args){

boolean b = true;

int x,y=9;

double d=3.1415;

char c1,c2;

c1='/u534e';c2='c';

x=12;

System.out.println("b="+b);

System.out.println

("x="+x+",y="+y);

System.out.println("d="+d);

System.out.println("c1="+c1);

System.out.println("c2="+c2);

}

★基本数据类型的转换

1.boolean类型不可以转换为其它的数据类型。（同理，其它类型也不可以转换为其它类型）

2.整型，字符型，浮点型的数据在混合运算中相互转换，转换时遵循以下原则（这有个问题，怎么字符型的和浮点型的还能一块运算呢？比方说，一个字符型数据 A+127可以吗？——可以！字符型在我们整个机器的内部它也是一个数字，也可以转换为010101，所以它们可以互相运算。运算的时候怎么进行运算呢？拿到字符型的args编码，它的值，然后在进行运算。）：混合运算的时候有一些规则：：

（ 1）容量小的数据类型自动转换为容量大的数据类型，数据类型按容量大小（容量大小指的是表示的数的大小，不是内存里占得多少）排序为：

l byte， short，char->int->long->flaot->double

l byte,short,char之间不会相互转换，他们三者在计算是首先会转换为 int类型

（ 2）容量大的数据类型转换为容量小的数据类型时，要加上强制转换符，但可能造成精度降低或溢出；使用时要格外注意。

（ 3）有多种类型的数据混合运算时，系统首先自动的将所有数据转换成容量最大的那一种数据类型，然后再进行计算。

（ 4）实数常量（如：1.2）默认为double。

（ 5）整数常量（如：123）默认为int。

★看例子： TesrConvert

public class TestConvert{

public static void main(String arg[]){

int i1=123;

int i2=456;

double d1=(i1+i2)*1.2; // 系统犟转换为dongble型运算（i1，i2是int类型，1.2是double类型，在做运算的时候首先会把i1，i2转换为double类型然后在做运算）

float f1=(float)((i1+i2)*1.2); // 在做运算的时候， (i1+i2)*1.2 算出来的数是double类型，放在float里需要加强制转换符，强制转换就是在一个数前面写上另外一个数据的类型就可以把这个数强制转换为另外一个数。但是能够转换才行，要是写上boolean，就不行！

byte b1=1;

byte b2=2; //1 ，2都是int类型，把int类型直接放在byte里面，这里可以把int类型直接放在byte，short，char，只要不超过它的表数范围就可以。例如，byte最多的表示为+127，你不能写byte=129，这不行，超出了表数范围了

byte b3=(byte)(b1+b2); // 系统将转换为int型运算，需要强制转换符（b1+b2算出来是int类型【byte,short,char之间不会相互转换，他们三者在计算是首先会转换为 int类型】现在要把一个int类型放在byte类型里面，要加强制转换符，你直接赋常量可以，但你做运算的时候，你要赋值过去，不行，加强制转换符。）

double d2=1e200;

float f2=(float)d2; //1e200 是1*10的200次方，你把这个值放在float类型里，它放不开，float最多也就10的38次方。这里把d2强制转换为f2，然后把这个f2打印出来，这个时候会产生溢出，运行的结果是：“Infinity”意思是无限，对于float来说这个数就是无穷大，所以这个时候转换过来是不对的，会产生溢出，会产生问题。

（这个时候把上面改一下：

byte b1=67;

byte b2=89;

byte b3=(byte)(b1+b2);// 然后把b3打印出来，应该是多少？

System.out.println(b3);

运行结果是：“-100” 这是能转换的，为什么呢？为什么那个大了强制转换就会出问题，而这个强制转换就不会出问题？简单解释一下，已知b1+b2会超出这个表数范围，当你强制转换为一个byte时，怎么转换呢？在内存里它超出表数范围，什么意思，int类型4个字节，byte类型1个字节，你要强制转换为byte类型，很简单，它把3个字节咔嚓砍掉，剩下那个字节是几就是几）（现在是double转换成float，double是8个字节，float是4个字节，它内部转换难道也是咔嚓砍掉4个只剩4个字节吗？不是！！因为浮点数在计算机内部用特殊的形式表示，它专门中间存了一个小数点，来计算小数点后面有几位，所以你直接砍掉是转换不过来的。因此，你这个double转换成float会出问题，会说Infinity，会说无穷大，但是int转换成byte就无所谓，因为它能砍掉。那把一个long转换成int呢，无所谓，把四个字节砍掉就是了）

System.out.println(f2);

float f3=1.23f; // 必须加f，不加f你就相当于把double转换为float，直接转不过去，因为你直接砍掉是不行的

long l1=123;// 这个当然可以，int类型转换为long

long l2=30000000000L; // 必须加L，如果不加会出问题。编译器一旦看到这个整数的时候会把它当成int类型，可是int类型盛不开它，所以会出问题，

float f=l1+l2+f3; // 系统将转换为float型计算，这里面float最大

long l=(long)f; // 强制转换会舍去小数部分（不是四舍五入）

｝

★ 下面看一个练习，找出错误！

void public method(){

int i=1,j;

float f1=0.1; // 错误，0.1是double类型，可以

改成0.1f或float f1=（float）0.1

float f2=123; //

long l1=12345678,l2=8888888888; // 错误，l2盛不开，后面要加个L

double d1=2e20,d2=124; // 正确，把int类型转换成double类型，容量小的自动转换成容量大的。

byte b1=1,b2=2,b3=129; // “b3=129”错误，超出表数范围

j=j+10; // 错误，j无值，变量要先声明再赋值才能去用它。必须得给j赋一个值。

i=i/10; //i 的值是0，i、10都是int类型，i/10是int类型，所以i值为0

i=i*0.1; // 错误，虽然说算的数一样，但0.1是double类型，i*0.1整个变成double类型，再赋值给i，i是int类型，把double类型赋值给int类型，需强制转换

char c1=’ a’,c2=125; //正确，直接给它一个值，不就是一个ASCII码内部，直接赋给它

byte b=b1-b2; // 错误，b1，b2做运算首先转换成int类型，所以b1-b2结果是int类型，把它赋给b需要强制转换。

char c=c1+c2-1; // 错误，同上。如果是一个常量还不超过它表数范围，直接等是可以的，但是这样算肯定是不可以的

float f3=f1+f2; // 正确

float f4=f1+f2*0.1; // 错误，0.1是double，整个算起来，先把小的转换成大的，整个全转换成double，再计算，最后算出来是double，double转车float，强制转换。

double d=d1*i+j;

float f=(float)(d1*5+d2);

}

★ 正确的程序是：

public class TestConvert2 {

public static void main(String[] args) {

int i=1,j=12;

float f1=(float)0.1; //0.1f

float f2=123;

long l1 = 12345678,l2=8888888888L;

double d1 = 2e20,d2=124;

byte b1 = 1,b2 = 2,b3 = 127;

j = j+10;

i = i/10;

i = (int)(i*0.1);

char c1='a',c2=125;

byte b = (byte)(b1-b2);

char c = (char)(c1+c2-1);

float f3 = f1+f2;

float f4 = (float)(f1+f2*0.1);

double d = d1*i+j;

float f = (float)(d1*5+d2);

}

注： float f1=(float)0.1; 和float f1=0.1f；本质上有很大的区别，float f1=0.1f；这样写在计算机内部本质上就是一个float类型，占4个字节；float f1=(float)0.1;其中0.1是int类型，占8个字节，但是你是把它强制转换成了4个字节的float

★程序格式（比算法还重要）：

1.大括号对齐

2.遇到｛缩进，Tab/Shift+Tab

3.程序块之间加空行（方法和方法之间，语句块和语句块之间，变量和方法之间，还有方法内部有一些if语句和其它的各种各样的语句之间加一空行。）

4.并排语句之间加空格

5.运算符两侧加空格（有特例，for循环里面，那个int i=几可以不加空格）

6. ｛前面有空格

7.成对编程

★运算符

·Java语言支持如下运算符 :

算术运算符 : ＋，－， * ， / ， %， ++，－－

关系运算符 : ＞，＜，＞＝，＜＝，＝＝，！＝

逻辑运算符 : ！，&，︳，^，&&，‖

位运算符 : ﹠，|，^，~，＞＞，＜＜，＞＞＞

赋值运算符 : =

扩展赋值运算符 :+= ，－=，*=，/=

字符串连接运算符 :+

·自加和自减运算符：

public class Test {

public static void main(String arg[]) {

int i1 = 10,i2 = 20; 输出结果：

int i = (i2++); i=20 i2=21

System.out.print("i=" + i); i=22 i2=22

System.out.println("i2=" + i2); i=9 i1=9

i = (++i2); i=9 i1=8

System.out.print("i=" + i);

System.out.print("i2=" + i2); 注： print—打印完括号里

i = (--i1); 面不换行。而 println—打印

System.out.print("i=" + i); 完换行。

System.out.println(" i1=" + i1);

i = (i1--); ※注意 :

System.out.print("i=" + i); · ++(－－)

System.out.println(" i1=" + i1); ·在前时先运算再取值

} ·在后时先取值再运算

}

· 逻辑运算符（它两边两个操作数全部都是true或是false）

逻辑运算符：！—逻辑非， &—逻辑与（只有两边都是true时结果才是true），︳—逻辑或（两边只要有一个是true结果就是true），^—逻辑异或（相异为true），&&— 短路与（当第一个表达式确定结果时，第二个表达式不再计算），‖—短路或（同上）

例： boolean flag1 = (i>3)&&((i+j)>5); //i<3是flase，所以结果是flase，所以第一个操作数将不再计算

·赋值运算符与扩展赋值运算符

赋值运算符（ =）

当“ =”两侧数据类型不一致时，可以使用默认类型转换成使用强制类型转换原则进行处理

long l = 100; int i = (int) l;

注意：可以将整型常量直接赋值给 byte，short，char等类型变量，而不需要进行强制类型转换，只要不超出其表数范围。

byte = 12； char c = 100；

扩展赋值运算符：

· 字符串连接符

“+”除用于算术加法运算外，还可用于对字符串进行连接操作

int id = 800+90; // 加法

String s = “hello” + “world”; // 字符串连接

“+”运算符两侧的操作数中只要有一个是字符串（String）类型，系统会自动将另一个操作数转换为字符串然后再进行连接。

例:int c = 12;

System.out.println(“c=” + c);

· 当进行打印是，无论任何类型，都自动转为字符串进行打印

当你“ System.out.println ”打印的时候，打印任何东西，只要不是字符串，自动转换为字符串，然后再打印

· 表达式

表达式是符合一定语法规则的运算符和操作数的序列（即最后能算出一个值的就叫表达式）

例： a

5.0+a

（a-b）*c-4

表达式的类型和表达式的值

对表达式中操作数进行运算得到的结果称为表达式的值。

表达式值的数据类型即为表达式的类型。

表达式的运算顺序

应按照运算符的优先级从高到低的顺序进行。

优先级相同的运算符按照事先约定的结合方向进行。

三目条件运算符

三目条件运算符，语法格式： x？y：z；

其中x为boolean类型表达式，先计算x的值，若为true，则整个三目运算的结果为表达式y的值，否则整个运算结果为表达式z的值。

★ if分支与for循环

★方法

Java的方法类似于其它语言的函数，是一段用来完成特定功能的代码片段（本质是增强程序的复用性，比方说所有的方法都写在 main函数里，从头执行到尾，中间有一段代码，如果我下一个函数还想用它的话，我还得拿出来再敲一遍。假如说我把它定义在一个方法里，直接一调这个方法就可以用了），声明格式：【修饰符1 修饰符2 ……】返回值类型方法名（形式参数列表）｛

Java语句；……

｝（函数声明后并不会被执行，只有调用它的时候才会被执行）

·形式参数：在方法被调用时用于接受外界输入的数据（事先定义好的只能接受某种类型的参数）。

·实参：调用方法时实际传给方法的数据。

·返回值：方法在执行完毕后返回给调用它的环境的数据。

·返回值类型：事先约定的返回值的数据类型，如无返回值，必须给出返回值类型 void。

·java语言中使用下述形式调用方法：对象名 .方法名（实参列表）

·实参的数目、数据类型和次序必须和所调用方法声明的形参列表匹配

·ruturn语句终止方法的运行并指定要返回的数据。

例子： TestMethod.java

public class TestMethod {

public static void main(String[] args) {