java基础_02（java基础案例教程第二版）

25-04-08 5

这篇文章主要围绕java基础_02和java基础案例教程第二版展开，旨在为您提供一份详细的参考资料。我们将全面介绍java基础_02的优缺点，解答java基础案例教程第二版的相关问题，同时也会为您带来

这篇文章主要围绕java基础_02和java基础案例教程第二版展开，旨在为您提供一份详细的参考资料。我们将全面介绍java基础_02的优缺点，解答java基础案例教程第二版的相关问题，同时也会为您带来02_Java基础_数据类型及运算符、04 java基础_数组、1.Java基础_Java核心机制简介、25.Java基础_继承的实用方法。

本文目录一览：

java基础_02（java基础案例教程第二版）
02_Java基础_数据类型及运算符
04 java基础_数组
1.Java基础_Java核心机制简介
25.Java基础_继承

java基础_02（java基础案例教程第二版）

1、变量使用 = 变量定义 + （变量初始化）+ ;
2、变量定义 = 变量类型 + 变量名

int a;
int a[];
int[] a;

3、运算符
4、Java的字符类型char是2字节，和C语言不同。boolean类型有2个值：true和false
5、java中每个变量都有确定的数据类型，当操作变量时一定要注意数据类型是兼容的，否则操作会被编译器报错。

6、Java中进行运行的2的变量必须类型一致。如果不一致则需要转换为一致然后再运算。Java中提供两种类型转换：自动类型转换和强制类型转换。自动类型转换是编译器自动进行的，只在绝对不会出错的情况下进行。当转换有可能出错有可能不出错时，编译器就不会自动转换，
需要程序员根据自己的需要进行强制类型转换。

02_Java基础_数据类型及运算符

标识符

v 标识符是赋给类、方法或变量的名字。一个标识符可以是字母、数字、下划线、美元符号的任意顺序组合，但不能以一个数字开始。
注:Java是区分大小写的;

java字符集

v java使用Unicode标准字符集,最多可以识别65536个字符,Unicode字符集的前128个字符是ASCII码表.Unicode字符集覆盖了大部分国家的“字母表”的字母; 也就是说java类名变量名等可以是中文;因为中文也是Unicode字符集中的一个字符; 但不建议开发中用中文标识符。

§ 命名规范

– 驼峰式命名：userName userSex

– 类名首字母大写

– 变量、方法名开头字母小写

– 常量所有字母大写

– 包名全部小写

– 工程名首字母大写

常量与变量

v 常量就是一个保持不变的值

v 变量是Java程序的一个基本存储单元。变量由一个标识符，类型以及一个可选初始值组合定义。
在程序执行过程中常量值可变

变量内存的空间分配

v 程序要为每一项数据分配内存，通常使用变量来存储数据。使用变量可以引用存储在内存中的数据，并随时根据需要显示数据或执行数据操纵。

§ 需要多少内存

§ 数据被存储在哪里

v 操作系统负责集注变量在内存中的地址

v 要引用内存空间中的值，只需指定变量名

注释

v java中注释有三种:

§ //单行注释，简单的解释语句含义.

§ /* 多行注释，用来说明更多的内容，包括算法等.

……

/** Java文档注释，可以通过javadoc生

* 成类和接口的HTML格式的帮助文档.

* 这种注释有其特殊的格式（参见相关文档）

数据类型

v Java语言是强类型语言

§ 每个变量每个表达式都有类型

§ 参数传递都要进行类型相容性检查

v 分类

§ 基本数据类型（Primary Data Types）

§ 复合数据类型（Composite Data Types）

八大基本数据类型

v 逻辑型(或称布尔型)

§ 所占内存: 占1个字节

§ 常量: true , false

§ 变量: 使用boolean定义

v 整型

§ 整型即整数类型,整型有:byte ;short ; int ; long

v byte(字节型)

§ 所占内存: 占1个字节

§ 常量: 12、32(十进制); 033(八进制); 0x7F (十六进制)

§ 变量: 使用byte定义

v 对于byte型变量，内存分配给1个字节，1个字节由8位(bit)组成；位有两种状态分别用0,1来表示,这样计算机可以用二进制数来存储信息。

§ 例如: byte x=7; 内存储状态为: 0000111
最高位(左边的第一位)是符号位,0表示正数,1表示负数; 正数用原码表示;负数用补码(即加1取反)表示。

§ 例如: byte x=-8 内存储状态为: 11111000
得到-8的补码，首先得到7的原码,然后将7的原码中的0变成1, 1变成0就是-8的补码。

§ 因此byte型变量的取值范围是-27~27-1 (-128 ~ 127)

v short整型

§ 所占内存: 占2个字节

§ 常量: 12、32(十进制); 01133(八进制); 0x117F (十六进制)

§ 变量: 使用short定义:

取值范围为: -2^15 ~ 2^15-1

v int 整型

§ 所占内存: 占4个字节

§ 常量: 12、32(十进制); 01133(八进制); 0x117F (十六进制)

§ 变量: 使用int定义:

取值范围为: -231 ~ 231-1

v long 整型

§ 所占内存: 占8个字节

§ 常量: 12、32(十进制); 01133(八进制); 0x117F (十六进制)

§ 变量: 使用long定义:

取值范围为: -263 ~ 263-1
注: 对long型变量赋值时,数字后要大写或小写的 L

v 浮点型(即小数类型)分两种: float ; double

v float

§ 所占内存: 占4个字节

§ 常量: 3.14F、2.23f;

§ 变量: 使用float定义:

取值范围为: -10-38 ~ 10-38 ~ 1038
注: 对float型变量赋值时,必须数字后要大写或小写的 f

v 浮点型(double)

§ 所占内存: 占8个字节

§ 常量: 3.14D、2.23d、23.23;

§ 变量: 使用double定义:

取值范围为: -10-308 ~ 10-308 ~ 10308
注: 对double型变量赋值时,(可选)数字后要大写或小写的 d

v 字符型; java使用Unicode字符集;

§ 所占内存: 占2个字节

§ 常量: ‘a’、’A’、’\t’、’你’、’ぁ’、’?’

§ 变量: 使用char定义:

注:字符型用单引号括起来

v 取值范围为: 对于char类型,内存分配2个字节,占16位,最高位不用来表示符号。char型变量取值为
0 ~ 216-1 (0 ~ 65535)

数据类型转换(隐式转换)

v 整型、实型、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算，转换从低级到高级：

低---------------------------->高

byte, short,char > int > long > float > double

强制类型转换

v 通过使用转换可以将一个表达式强制转换成某一种类型，是一元运算符。

v 转换的通用语法是：

(type) cast

type 任意有效的 java 数据类型

v 数据类型转换必须满足如下规则：

§ 不能对boolean类型进行类型转换。

§ 不能把对象类型转换成不相关类的对象。

§ 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。

§ 转换过程中可能导致溢出或损失精度

§ 浮点数到整数的转换是通过舍弃小数得到，不是四舍五入(int)23.7 == 23,(int)-45.89f== -45

字符型与int整型转换

v 字符型在计算机中是以二进制信息存储;存储的值是该字符在unicode字符集中的排序位置。

v 字符型是用2个字节存储，但它是无符号的;所以字符型范围比short范围大。字符型一般与int相互转化;

表达式

v 运算符和括号将操作数连接起来的、符合java语言语法规则的式子，称为表达式

v 运算符和操作数的有效组合

v 操作数可以是变量、常量或者函数

v 在程序执行的过程中，变量的实际值和表达式中出现的常量一起使用

v 表达式可分为：

§ 算术表达式

§ 关系表达式

§ 逻辑表达式

§ 函数表达式

v 运算符的优先级和结合方向

§ 按运算符的优先级高低次序执行。例如，先乘除后加减。

§ 如果在一个运算对象（或称操作数）两侧的运算符的优先级相同，则按java语言规定的结合方向（结合性）进行。

v 良好的源程序书写习惯：在表达式中，在双目运算符的左右两侧各加一个空格，可增强程序的可读性。

赋值运算符

v 赋值符号“=”就是赋值运算符，它的作用是将一个表达式的值赋给一个变量。

v 通用的形式：变量名=表达式

v 将同一个值赋给多个变量的操作叫做多重赋值

运算符	描述
按位与 ( x & y )	如果两个操作数的相应位均为 1，则该位的结果值为 1
按位或 ( x \| y )	如果两个操作数的相应位有一个为 1，则该位的结果值为 1
按位取反 ( ~x )	将操作数按位取反（0 到 1 和 1 到 0）
按位异或 ( x^y )	如果参加运算的两个操作数的相应位同号，则结果为 0，异号则为 1
左移 ( x<<2 )	左端（高位）移出部分舍弃，右端（低位）补0
右移 ( x>>2 )	右端（低位）移出部分舍弃，左端（高位）根据符号位补0或者1，无符号或正数补0，负数补1

v 位运算符将数字视为二进制值，并按位进行相应运算，运算完成后再重新转换为数字

一般来说，算术运算符优先级高于比较运算符高于逻辑运算符高于赋值运算符

要点补充：

其它运算符

. 调用类的静态变量和常量。对象的属性

new 实例化一个对象。对象分配到内存的堆区中。

() 调用类的静态方式，对象的方法。改变运算符的优先级

[] 数组，通过下标号来获取数组中的元素

instanceof 判断一个对象是否一个类的实例。

04 java基础_数组

04 java基础_数组

数组相关概念

v 在java语言中，数组是一种复合数据类型（引用数据类型）。数组是有序数据的集合，数组中的每个元素具有相同的数据类型，可以用一个统一的数组名和下标来唯一地确定数组中的元素。数组有一维数组和多维数组。

v java中的一个数组是一个对象。

一维数组的定义

v 一维数组的定义方式为：

§ type arrayName[]; 或者 type[] arrayName;

§ 其中类型(type)可以为java中任意的数据类型，包括简单类型和组合类型，数组名arrayName为一个合法的标识符，[]指明该变量是一个数组类型变量。

java在数组的定义中并不为数组元素分配内存，因此[]中不用指出数组中元素的个数，即数组长度，而且对于如上定义的一个数组是不能访问它的任何元素的。必须经过初始化后，才能应用数组的元素。

一维数组的初始化(静态)

v 一维数组定义之后，必须经过初始化才可以引用。数组的初始化分为静态初始化和动态初始化两种；

v 静态初始化：在定义数组的同时对数组元素进行初始化

动态初始化：使用运算符new为数组分配空间，对于简单类型的数组，

一维数组初始化注意点

v 对于动态初始化一维数组;如果只new(即只分配了内存空间)没有赋值; 整型数组所有元素为0; 浮点型数组所有元素为0.0; 布尔型数组所有元素为false; 对类类型数组所有元素为null;

一维数组的使用

v 当定义了一个数组，并用运算符new为它分配了内存空间后，就可以引用数组中的每一个元素了。元素的引用方式为：arrayName[index]

v 另外，Java对数组元素要进行越界检查以保证安全性。同时，对于每个数组都有一个属性length指明它的长度。

多维数组

在任何语言中，多维数组都被看作数组的数组。比如二维数组是一个特殊的一维数组，其每一个元素又是一个一维数组。

二维数组的定义

v 二维数组的定义方式:

§ type arrayName[ ][ ]; 或者 type[ ][ ] arrayName;

v 也可以这么写：

§ type[] arrayName[];

v 与一维数组一样，这时对数组元素也没有分配内存空间，同样要使用运算符new来分配内存，然后才可以访问每个元素。

二维数组初始化(静态)

v 二维数组的初始化也分为静态和动态两种。

v 静态初始化：在定义数组的同时为数组分配空间。
int intArray[ ][ ]={{1,2},{2,3},{3,4}};//不必指出数组每一维的大小，系统会根据初始化时给出的初始值的个数自动算出数组每一维的大小。

二维数组初始化(动态)

v 动态初始化：对多维数组来说，分配内存空间有下面两种方法：

§ 直接为每一维分配空间;

v 从最高维开始(而且必须从最高维开始)，分别为每一维分配空间，如：

int ary[ ][ ]=new int[2][ ];

ary[0]=new int[2];

ary[1]=new int[3];

ary[0][0]=11; ary[0][1]=12;

…

v 通过上面可以看出，高维数组是特殊的一维数组;

v 获取高维数组的第一维长度: ary.length; 获取第一维中第一个元素数组长度为: ary[0].length;依次类推;

补充：java数组初始化详解：

一维数组
1) int[] a; //声明,没有初始化

2) int[] a=new int[5]; //初始化为默认值,int型为0

3) int[] a={1,2,3,4,5}; //初始化为给定值

4) int[]a=new int[]{1,2,3,4,5}; //同(3)
int[] a=new int[5]{1,2,3,4,5}; //错误,如果提供了数组初始化操作，则不能定义维表达式

5) int[] a;
a=new int[5]; //正确,同(2)一样

int[] a;
a={1,2,3,4,5}; //错误,数组常量只能在初始化操作中使用，如（3）

6)   int a[];
     a[0]=1;   //错误,因为数组没有初始化,不能赋值
     a[1]=2;

二维数组
1) int[][] a; //声明,没有初始化

2) int[][] a=new int[2][3]; //初始化为默认值,int型为0

3) int[][] a={{1,2},{2,3},{3,4}}; //初始化为给定值
int[][] a={{1,2},{2,3},{3,4,5}}; //没有错,数组空间不是连续分配的，所以不要求每一维的大小相同

4)   int[][] a=new int[2][];
     a[0]=new int[3]; //a[0]其实就是一个数组
     a[1]=new int[4]; //每一维的大小可以不一样;

5) int[][]a=new int[][]{{1,2},{2,3},{3,4,5}}; //同(3)
int[] a=new int[5]{{1,2},{2,3},{3,4,5}}; //错误,如果提供了数组初始化操作，则不能定义维表达式

int[][] a=new int[2][];
a[0]={1,2,3,4,5}; //错误,数组常量只能在初始化操作中使用

6) int[][] a=new int[2][];
a[0][1]=1; //错误,第二维没有初始化,不能赋值,java.lang.NullPointerException异常

总结:1.二维就是数组的数组,里面的数组大小不要求一样
2.不管一维还是二维,在使用前(赋值,访问)必须初始化,可以用new默认初始化,也可以用数组常量初始化

1.动态初始化：数组定义与为数组分配空间和赋值的操作分开进行；
2.静态初始化：在定义数字的同时就为数组元素分配空间并赋值；
3.默认初始化：数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐士初始化。

实例：
TestD.java(动态)

程序代码

public class TestD
{
    public static void main(String args[]) {
        int a[] ;
        a = new int[3] ;
        a[0] = 0 ;
        a[1] = 1 ;
        a[2] = 2 ;
        Date days[] ;
        days = new Date[3] ;
        days[0] = new Date(2008,4,5) ;
        days[1] = new Date(2008,2,31) ;
        days[2] = new Date(2008,4,4) ;
    }
}

class Date
{
    int year,month,day ;
    Date(int year ,int month ,int day) {
        this.year = year ;
        this.month = month ;
        this.day = day ;
    }
}

TestS.java(静态):

程序代码

public class TestS
{
    public static void main(String args[]) {
        int a[] = {0,1,2} ;
        Time times [] = {new Time(19,42,42),new Time(1,23,54),new Time(5,3,2)} ;
    }
}

class Time
{
    int hour,min,sec ;
    Time(int hour ,int min ,int sec) {
        this.hour = hour ;
        this.min = min ;
        this.sec = sec ;
    }
}

TestDefault.java(默认):

程序代码

public class TestDefault
{
    public static void main(String args[]) {
        int a [] = new int [5] ;
        System.out.println("" + a[3]) ;
    }
}

1.Java基础_Java核心机制简介