2.JAVA基础知识-类、方法、关键词和基本语言元素的说明

以下为本章节的学习目录:

JAVA基础知识-类、方法、关键词和基本语言元素的说明

    |---- 1 类

    |---- 2 方法

    |---- 3 关键字

    |---- 4 基本语言元素

    |---- 5 总结


下面我们讲解第一点:JAVA类。


JAVA类的概念等的说明


1.1 JAVA类的概念

类是一个模板,它描述一类对象的行为和状态。

1.2 定义一个类
基本格式如下:

[修饰符] class 类名 {
    0到多个构造器
    0到多个成员变量
    0到多个方法
    0到多个初始化块
}
1.3 修饰符
可以写public final abstract或者不写,java类名要用大驼峰写法。
一个java源文件(也就是文件后缀名为.java的文件)可以写多个类,但是里面只能有一个用public修饰的class。
1.4 构造器
构造器也叫构造方法或者构造函数,构造器与类名相同,没有返回值,连void都不能写。
构造器定义格式:
public class RoadTest {
         /**
          * 构造器
          */
         public RoadTest() {
         }
}
[修饰符] 与类名相同的名(形参列表){
    构造器方法体代码
}
名称与类名相同,没有返回值,不能写void 。
如果类中没有手动添加构造器,编译器会默认添加一个无参构造器 。
如果手动添加了构造器(无论什么形式),默认构造器就会消失。
构造器可以重载。
1.5 java文件与class文件的区别?
java文件,就是实际编程中编辑的文件,按java语法写代码;但java虚拟机jvm不能识别,而class文件,是通过java编译器编译出来的二进制文件。这份文件是供java虚拟机jvm运行时执行的文件。里面按照java定义的规范所构建的文件内容。

class文件,可以让你在任何一台安装了java虚拟机的机器上运行。


JAVA方法的概念和说明


2.1 JAVA方法的概念

Java方法是语句的集合,它们在一起执行一个功能。

方法是解决一类问题的步骤的有序组合。
方法包含于类或对象中。
方法在程序中被创建,在其他地方被引用。
 
下面是一个无参的返回值为空的方法,参数可以加,返回值也可以是int型也可以是别的类型。

/**
 * 这是一个方法的定义
*/
public void month() {
}
方法的修饰符(public protected private)三选一、static、final、synchronize、native,使用static就是静态方法了。
[修饰符] 方法的返回值类型 方法名称(形参列表) {
    //方法体代码 [return 返回值;]
}
初始化块:是用来初始化一些值的,它的优先级比构造器要高,一些需要多次使用但又是固定的值可以放进初始化块中。
使用static就是静态初始化块了,静态初始化块优先级最高。
public class RoadTest {
         {
                   // 初始化代码块
         }
}
2.2 类和方法的关系?
类,就是一类事物的抽象。所以说类是一个模板,不能做任何实际的工作。但是类可以产生一个个功能相似的实体,就是对象,它们根据同一个类构造,具有实际的行为,就是方法。

一个类中包含方法,同时可以包含多个方法,是一对多的关系。


JAVA关键字的说明等信息


3.1 关键字说明

Java关键字是电脑语言里事先定义的,有特别意义的标识符,有时又叫保留字,还有特别意义的变量。
Java的关键字对Java的编译器有特殊的意义,他们用来表示一种数据类型,或者表示程序的结构等,关键字不能用作变量名、方法名、类名、包名和参数。
java关键字共50个(其中包含两个保留字const,goto)。
const、goto 是关键字,虽然没用,但不能拿来当变量名。
true、false、null 不是关键字,但也不能用来当变量名。
friendly、sizeof 不是关键字,可以用来当变量名。

3.2 具体关键字

abstract    表明类或者成员方法具有抽象属性
assert       断言,用来进行程序调试
boolean     基本数据类型之一,布尔类型
break        提前跳出一个块
byte         基本数据类型之一,字节类型
case         用在switch语句之中,表示其中的一个分支
catch        用在异常处理中,用来捕捉异常
char         基本数据类型之一,字符类型
class        声明一个类
const       保留关键字,没有具体含义
continue   回到一个块的开始处
default     默认,例如,用在switch语句中,表明一个默认的分支
do           用在do-while循环结构中
double     基本数据类型之一,双精度浮点数类型
else         用在条件语句中,表明当条件不成立时的分支
enum       枚举
extends    表明一个类型是另一个类型的子类型,这里常见的类型有类和接口
final        用来说明最终属性,表明一个类不能派生出子类,或者成员方法不能被覆盖,或者成员域的值不能被改变,用来定义常量
finally      用于处理异常情况,用来声明一个基本肯定会被执行到的语句块
float        基本数据类型之一,单精度浮点数类型
for          一种循环结构的引导词
goto        保留关键字,没有具体含义
if            条件语句的引导词
implements  表明一个类实现了给定的接口
import      表明要访问指定的类或包
instanceof 用来测试一个对象是否是指定类型的实例对象
int           基本数据类型之一,整数类型
interface   接口
long         基本数据类型之一,长整数类型
native       用来声明一个方法是由与计算机相关的语言(如C/C++/FORTRAN语言)实现的
new          用来创建新实例对象
package     包
private      一种访问控制方式:私用模式
protected   一种访问控制方式:保护模式
public       一种访问控制方式:共用模式
return       从成员方法中返回数据
short        基本数据类型之一,短整数类型
static        表明具有静态属性
strictfp     用来声明FP_strict(单精度或双精度浮点数)表达式遵循IEEE 754算术规范 [1] 
super       表明当前对象的父类型的引用或者父类型的构造方法
switch      分支语句结构的引导词
synchronized   表明一段代码需要同步执行
this         指向当前实例对象的引用
throw       抛出一个异常
throws     声明在当前定义的成员方法中所有需要抛出的异常
transient  声明不用序列化的成员域
try          尝试一个可能抛出异常的程序块
void        声明当前成员方法没有返回值
volatile    表明两个或者多个变量必须同步地发生变化
while       用在循环结构中


基本语言元素的说明


4.1 基础语言要素
1)标识符:用来给类、方法、变量起名。
       A.必须以字母、下划线或$符号开始,其余字符可以是字母、数字、$符号和下划线。
       B.只可包含两个特殊字符,即下划线_和美元符号$。不允许有其它特殊字符。
       C.标识符不能包含空格。
       D.区分大小写。

2)关键字:只有系统才能用的标识符。
       特别提示1:true、false、null不是关键字!是字面量。
       特别提示2:main不是关键字!它是一个特殊单词,可以被JVM识别,主函数是固定格式,作为程序入口。

3)注释:单行注释://多行注释:/*……*/文档注释:/**……*/
       特别提示1:开发中类、属性、方法前,必须有文档注视。

4.2 八种基本数据类型
1)四种整数类型(byte、short、int、long):
      byte:8位,用于表示最小数据单位,如文件中数据,-128~127
      short:16位,很少用,-32768~32767
      int:32位、最常用,-2^31-1~2^31(21亿)
      long:64位、次常用
注意事项:
      inti=5;//5叫直接量(或字面量),即直接写出的常数。
      整数字面量默认都为int类型,所以在定义的long型数据后面加L或l。
      小于32位数的变量,都按int结果计算。
      强转符比数学运算符优先级高。见常量与变量中的例子。

2)两种浮点数类型(float、double):
      float:32位,后缀F或f,1位符号位,8位指数,23位有效尾数。
      double:64位,最常用,后缀D或d,1位符号位,11位指数,52位有效尾数。
特别提示:
       二进制浮点数:1010100010=101010001.0*2=10101000.10*2^10(2次方)=1010100.010*2^11(3次方)=.1010100010*2^1010(10次方)
       尾数:. 1010100010指数:1010基数:2
       浮点数字面量默认都为double类型,所以在定义的float型数据后面加F或f;double类型可不写后缀,但在小数计算中一定要写D或X.X。
       float的精度没有long高,有效位数(尾数)短。
       float的范围大于long指数可以很大。
      浮点数是不精确的,不能对浮点数进行精确比较。

3)一种字符类型(char):
      char:16位,是整数类型,用单引号括起来的1个字符(可以是一个中文字符),
       使用Unicode码代表字符,0~2^16-1(65535)。
特别提示:
      不能为0个字符。
       转义字符:\n换行\r回车\tTab字符\"双引号\\表示一个\
两字符char中间用“+”连接,内部先把字符转成int类型,再进行加法运算,char本质就是个数!二进制的,显示的时候,经过“处理”显示为字符。

4)一种布尔类型(boolean):true真和false假。

5)类型转换:char-->
      自动转换:byte-->short-->int-->long-->float-->double
      强制转换:①会损失精度,产生误差,小数点以后的数字全部舍弃。②容易超过取值范围。
4.3 常量和变量
变量:内存中一块存储空间,可保存当前数据。在程序运行过程中,其值是可以改变的量。
     1)必须声明并且初始化以后使用。在同一个作用域中不能重复声明变量。
     2)变量必须有明确类型(Java是强类型语言)。
     3)变量有作用域(变量在声明的地方开始,到块{}结束)。变量作用域越小越好。
     4)局部变量在使用前一定要初始化。成员变量在对象被创建后有默认值,可直接用。
     5)在方法中定义的局部变量在该方法被加载时创建。

常量:在程序运行过程中,其值不可以改变的量。
特别提示:
        字面量、常量和变量的运算机制不同,字面量、常量由编译器计算,变量由运算器处理,目的是为了提高效率。
        eg:小于32位数的字面量处理

byte b1 =1;byte b2 =3;
byte b3 =b1+b2;//编译错误,按照int结果,需要强制转换
byte b3 =(byte)(b1+b2);
byte b3 =(byte)b1+(byte)b2;//编译错误!两个byte、short、char相加还是按int算
System.out.println(b3);//选择结果:A编译错误B运行异常C4Db3byte b4 =1+3;//字面量运算,编译期间替换为4,字面量4
byte b4 =4;不超过byte就可以赋值
      不管是常量还是变量,必须先定义,才能够使用。即先在内存中开辟存储空间,才能够往里面放入数据。
      不管是常量还是变量,其存储空间是有数据类型的差别的,即有些变量的存储空间用于存储整数,有些变量的存储空间用于存储小数。
4.4 运算符与表达式
1)数学运算:+-*/%++--
    特别提示:
    +-*/两端的变量必须是同种类型,并返回同种类型。
    %取余运算,负数的余数符号与被模数符号相同,-1%5=-1,1%-5=1;Num%n,n>0,结果范围[0,n),是周期函数。
    注意整除问题:1 /2=0(整数的除法是整除)1.0 /2=0.51D/2=0.5
    单独的前、后自增或自减是没区别的,有了赋值语句或返回值,则值不同!
    eg1:自增自减
        inta =1;a=a++;System.out.println("a的值:"+a);
        第1步:后++,先确定表达式a++的值(当前a的值)a++---->1
        第2步:++,给a加1a---->2
        第3步:最后赋值运算,把a++整个表达式的值赋值给aa---->1 a被赋值两次,第1次a=2,第2次把1赋值给1
    eg2:自增自减
        x,y,z分别为5,6,7计算z+=--y *z++;//x=5,y=5,z =42
        z =z+--y *z++à42=7+5 *7从左到右入栈,入的是值
    eg3:取出数字的每一位
        d =num%10;//获取num的最后一位数num/=10;//消除num的最后一位
2)位运算:&|~(取反)^(异或)>><<>>>
    注意事项:
    一个数异或同一个数两次,结果还是那个数。
    |:上下对齐,有1个1则为1;&:上下对齐,有1个0则为0;(都为二进制)
    v&相当于乘法,|相当于加法;&:有0则为0,|:有1则为1,^:两数相同为0,不同为1。
3)关系运算符:><>=<===!=
4)逻辑运算符:&&||(短路)!&|
    eg:短路运算:&&:前为flase,则后面不计算;||:前为true,则后面不计算
        intx=1,y=1,z=1;
        if(x--==1&&y++==1||z++==1)//||短路运算后面的不执行了!
        System.out.println(“x=”+x+”,y=”+y+”,z=”+z);//0 , 2,1 5)赋值运算符:=+=-=*=/=%=
    eg:正负1交替
        int  flag=-1;System.out.println(flag*=-1);……
5)条件(三目)运算符:表达式1?表达式2:表达式3
    注意事项:
    右结合性:a >b?a :i>j? i:j相当于a >b?a :(i>j?i:j)
    三目运算符中:第二个表达式和第三个表达式中如果都为基本数据类型,整个表达式的运算结果由容量高的决定。如:intx=4;x >4?99.9 :9;99.9是double类型,而9是int类型,double容量高,所以最后结果为9.9。
6)运算符优先级:括号>自增自减>~!>算数运算符>位移运算>关系运算>逻辑运算>条件运算>赋值运算
4.5 编程风格
MyEclipse/Eclipse中出现的红色叉叉:编译错误。
编译错误:java编译器在将Java源代码编译为class文件的过程出现的错误,一般是语法使用错误!当有编译错误时候,是没有class文件产生,也就不能运行程序。
4.6 流程控制语句
1)选择控制语句

    if语句:if、if-else、if-else-if:可以处理一切分支判断。格式:if(判断){…}、if(判断){…}else{…}、if(判断){…}elseif(判断){…}

    switch语句:switch(必须整数类型){case常量1:…;case常量2:… ;….}

    注意事项:
    int类型指:byte、short、int,只能写long类型,要写也必须强转成int类型;而byte、short为自动转换成int。
    swtich-case:若case中无符合的数,并且default写在最前(无break时),则为顺序执行,有break或}则退出。
    swtich-case:若case中无符合的数,并且default写在最后,则执行default。
    swtich-case:若case中有符合的数,并且default写在最后,并且default前面的case没有break时,default也会执行。

2)循环控制语句
    1. for:最常用,用在与次数有关的循环处理,甚至只用for可以解决任何循环问题。
        特别提示:for中定义的用于控制次数的循环变量,只在for中有效,for结束则循环变量被释放(回收)。
    2. while:很常用,用在循环时候要先检查循环条件再处理循环体,用在与次数无关的情况。如果不能明确结束条件的时候,先使用while(true),在适当条件使用if语句加break结束循环。
    3. do-while:在循环最后判断是否结束的循环。如:使用while(true)实现循环的时候,结束条件break在while循环体的最后,就可以使用do-while。do-while的结束条件经常是“否定逻辑条件”,不便于思考业务逻辑,使用的时候需要注意。可以利用while(true)+break替换。
    4. 循环三要素:A.循环变量初值B.循环条件C.循环变量增量(是循环趋于结束的表达式)
    5. for和while循环体中仅一条语句,也要补全{},当有多条语句,且不写{}时,它们只执行紧跟着的第一条语句。
    6. 循环的替换:
        while(布尔表达式){}等价for(;布尔表达式;){}
        while(true){}等价for(;;)
        while(true){}+break替换do{}while(布尔表达式);for(;;)+break替换do{}while(布尔表达式);

3)跳转控制语句continue:退出本次循环,直接执行下一次循环。
    break:退出所有循环
4.7 数组
类型一致的一组数据,相当于集合概念,在软件中解决一组,一堆XX数据时候使用数组。
1)数组变量:是引用类型变量(不是基本变量)引用变量通过数组的内存地址位置引用了一个数组(数组对象),即栓到数组对象的绳子。
    eg:数组变量的赋值
int [] ary=new int[3];//ary----->{0,0,0}<----ary1
int[]ary1 =ary;//ary的地址赋值给ary1,ary与ary1绑定了同一个数组
//ary[1]与ary1[1]是同一个元素,数组变量不是数组(数组对象)
2)数组(数组对象)有3种创建(初始化)方式:①new int[10000]给元素数量,适合不知道具体元素,或元素数量较多时②new int[]{3,4,5}不需要给出数量,直接初始化具体元素适合知道数组的元素。③{2,3,4}静态初始化,是②简化版,只能用在声明数组变量的时候直接初始化,不能用于赋值等情况。
    eg:数组初始化
int []ary1 =newint[]{2,3,4};//创建数组时候直接初始化元素
int[]ary2 ={2,3,4};//数组静态初始化,只能在声明变量的同时直接赋值
//ary2 ={4,5,6};//编译错误,不能用于赋值等情况ary2 =newint[]{4,5,6};
3)数组元素的访问:①数组长度:长度使用属性访问,ary.length获取数组下标。②数组下标:范围:0~length-1就是[0,length),超范围访问会出现下标越界异常。③使用[index]访问数组元素:ary[2]。④迭代(遍历):就是将数组元素逐一处理一遍的方法。

4)数组默认初始化值:根据数组类型的不同,默认初始化值为:0(整数)、0.0(浮点数)、false(布尔类型)、\u0000(char字符类型,显示无效果,相当于空格,编码为0的字符,是控制字符,强转为int时显示0)、null(string类型,什么都没有,空值的意思)。

5)数组的复制:数组变量的赋值,是并不会复制数组对象,是两个变量引用了同一个数组对象。数组复制的本质是创建了新数组,将原数组的内容复制过来。

6)数组的扩容:创建新数组,新数组容量大于原数组,将原数组内容复制到新数组,并且丢弃原数组,简单说:就是更换更大的数组对象。System.arraycopy()用于复制数组内容,简化版的数组复制方法:Arrays.copyOf()方法,但需JKD1.5+。
4.8 字符串
字符串(string):永远用“”双引号(英文状态下),用字符串连接任何数据(整数),都会默认的转化为字符串类型。
字符串与基本数据类型链接的问题:如果第一个是字符串那么后续就都按字符串处理,如System.out.println("(Result)"+6+6);那么结果就是(Result)66,如果第一个和第二个…第n个都是基本数据,第n+1是字符串类型,那么前n个都按加法计算出结果在与字符串连接。


如下例中的System.out.println(1+2+”java”+3+4);结果为3java34。eg:字符串前后的“+”都是连接符!不是加法运算符!

System.out.println("A"+'B');//AB System.out.println('A'+'B');//131 System.out.println(1+2+”java”+3+4);//3java34
注意事项:比较字符串是否相等必须使用equals方法!不能使用==。"1".equals(cmd)比cmd.equals("1")要好。
4.9 方法三要素
方法:method(函数function =功能)y=f(x) 
1)方法的主要三要素:方法名、参数列表、返回值。
2)什么是方法:一个算法逻辑功能的封装,是一般完成一个业务功能,如:登录系统,创建联系人,简单说:方法是动作,是动词。
3)方法名:一般按照方法实现的功能定名,一般使用动词定义,一般使用小写字母开头,第二个单词开始,单词首字母大写。如:createContact()。
4)参数列表:是方法的前提条件,是方法执行依据,是数据。如:login(Stringid,Stringpwd),参数的传递看定义的类型及顺序,不看参数名。
5)方法返回值:功能执行的结果,方法必须定义返回值,并且方法中必须使用return语句返回数据;如果无返回值则定义为void,此时return语句可写可不写;返回结果只能有一个,若返回多个结果,要用数组返回(返回多个值)。
注意事项:递归调用:方法中调用了方法本身,用递归解决问题比较简练,只需考虑一层逻辑即可!但是需要有经验。一定要有结束条件!如:f(1)=1;递归层次不能太深。总之:慎用递归!
4.10 Java系统API方法调用
Arrays类,是数组的工具类,包含很多数组有关的工具方法。如:
1)toString()连接数组元素为字符串,方便数组内容输出。
2)equals比较两个数组序列是否相等。
3)sort()对数组进行排序,小到大排序。
4)binarySearch(names,"Tom")二分查找,必须在有序序列上使用。
4.11 二进制基础
1)计算机中一切数据都是2进制的基本类型,对象,音频,视频。
2)10进制是人类习惯,计算按照人类习惯利用算法输入输出。
"10"-算法转化->1010(2)1010-算法转化->"10"
3)16进制是2进制的简写,16进制就是2进制!
4)计算机硬件不支持正负号,为了解决符号问题,使用补码算法,补码规定高位为1则为负数,每位都为1则为-1,如11111111=-1 =0xff
5)二进制数右移>>:相当于数学/2(基数),且正数高位补0,负数高位补1;二进制字左移<<:相当于数学*2(基数),且低位补0;二进制数无符号右移>>>:相当于数学/2(基数),且不论正负,高位都补0。
6)注意掩码运算:把扩展后前面为1的情况除去,与0xff做与运算。
    eg1:二进制计算
        int max =0x7fffffff;long l=max +max+2;System.out.println(l);//0eg2:二进制运算(拼接与拆分)
        int  b1 =192;int b2=168;int b3 =1;int b4=10;int color=0xD87455;
        int ip =(b1<<24)+(b2<<16)+(b3<<8)+b4;//或者ip=(b1<<24)|(b2<<16)|(b3<<8)|b4;int b =color&0xff;//85int g =(color>>>
8)&0xff;//116int r=(color>>>16)&0xff;//216
4.12 Java基础其他注意事项
1)Java程序严格区分大小写。
2)类名,每个单词首字母必须大写。
3)一个Java应用程序,有且只有一个main方法,作为程序的入口点。
4)每一条Java语句必须以分号结束。
5)类定义关键字class前面可以有修饰符(如public),如果前面的修饰符是public,该类的类名必须要与这个类所在的源文件名称相同。
6)注意程序的缩进。
7)double  a[]=new double[2];//语法可以,但企业中一定不要这么写,Java中[]建议放前面。
8)Java中所有范围参数都是包含0,不包含结束,如 int n = random.nextInt(26);//生成0到26范围内的随机数,不包括26。
9)任何数据在内存中都是2进制的数据,内存中没有10进制16进制。
10)int n =Integer.parseInt(str);//将字符串-->int整数。
11)System.out.println(Long.toBinaryString(maxL));Long类型用Long.XXXX。
12)程序:数据+算法数据即为变量,算法为数据的操作步骤,如:顺序、选择、循环。
13)字符串按编码大小排序。



五 总结

通过本章节我们可以全面了解java类、方法的关系,了解java中的关键字和java的基本语言语法的元素和编码标准。

本章节为java的基础环节需要熟记,对后面的学习有很大帮助。

掌握了java关键字便可在接下来的学习中快速成长。


评论 (0)