Java语言的基础

Java语言的基础

　　引导语：Java是一种可以撰写跨平台应用程序的面向对象的程序设计语言。以下是百分网小编分享给大家的Java语言基础，帮助大家了解Java语言的名称，描述，定义，例子，备注。

　　java语言基础(名称，描述，定义，例子，备注)

　　1.1标识符、关键字、保留字

　　标识符、关键字、保留字

　　名称：标识符;定义：由任意顺序的字母、数字、下划线、美元符号$组成，第一个字母不能是数字，不能是保留关键字;描述：指用户自定义的类名、变量名、接口名、方法名;例子：合法的：name、user_age1、$page，不合法的：5word、int、Username(字符不能有空格);备注：命名法则：文件|文件夹方式命名。

　　名称：关键字;定义：对java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名;描述：java语言中已经被赋予特定意义的一些单词，不可以把这些字符作为标识符来使用。例子：Java关键字

　　friendly，sizeof不是java的关键字，并且java关键字都是小写的

　　保留字：指现有Java版本尚未使用但以后版本可能会作为关键字使用的单词;例子：Java保留字

　　1.2量(常量、变量)

　　量的分类：常量和变量

　　名称：变量;定义：指一个内容可变的数据存储空间的表示(在程序中使用变量内容可改变);描述：由变量类型和变量名或初始值组成(type 标识符[=初始值]);例子：intage; Boolean b=true; float f1,f2,f3。

　　名称：常量;定义：指在程序中不能改变的量(与变量性质相反);描述：由final 类型名称=值组成(final type 名称=值);例子：finalfloat PI=3.1415926F;备注：常量名称一般定义为大写字母。

　　量的使用：直接打印输出;传递;对象名.变量名(实例变量);类名.变量名(静态变量);

　　量的作用范围：指量在程序中所拥有的权限。

　　量[变量]-全局变量(成员变量)|局部变量

　　成员变量：指在类中(在方法外面)声明的变量，作用域是整个类，也可以说是类的属性。分类：静态变量：创建的变量与对象无关(属于成员变量)，当不必引用对象时可以直接用类来访问静态变量;为多个实例分配一个内存空间;实例变量：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量;实例变量位于堆区中，其生命周期取决于实例的生命周期。

　　例子：

　　public class VariantTest

　　{

　　public static int staticVar = 0;

　　public int instanceVar = 0;

　　public VariantTest()

　　{

　　staticVar++;

　　instanceVar++;

　　System.out.println(“staticVar = ”++staticVar “， instanceVar = ” ++instanceVar);

　　}

　　}

　　量[常量]-系统常量|程序常量

　　1.3数据类型，类型转型，相等性测试

　　数据类型分类：基本数据类型和字符串类型、引用类型(内存占用字节数，取值范围，默认值)

　　基本数据类型(8个)：整型：byte(1字节)、short(2字节)、int(4字节)、long(8字节)，浮点型：float(4字节)、double(8字节);Boolean(1位)：ture、false;字符型：Char (2字节)

　　定义：基本类型的值是一个数字，一个字符或一个布尔值，其内容存在栈中，变量直接指向数值内容;

　　基本数据类型包括byte、int、char、long、float、double、boolean和short。

　　例子：

　　public class SimpleTypes{

　　publicstatic void main( String args[] ){

　　byte b=0x55;

　　shorts=0x55ff;

　　inti=1000000;

　　longl=0xfffL;

　　char c='c';

　　floatf=0.23F;

　　doubled=0.7E-3;

　　booleanbool=true;

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

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

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

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

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

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

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

　　}

　　}

　　编译并运行该程序,输出结果为:

　　C:\>java SimpleTypes

　　b = 85

　　s = 22015

　　i = 1000000

　　l = 4095

　　c = c

　　f = 0.23

　　d = 0.0007

　　bool = true

　　转义字符:

\n

回车(\u000a)

\t

水平制表符(\u0009)

\b

空格(\u0008)

\r

换行(\u000d)

\f

换页(\u000c)

\'

单引号(\u0027)

\"

双引号(\u0022)

\\

反斜杠(\u005c)

\ddd

三位八进制

\udddd

四位十六进制

　　字符串类型，是用String表示的类型，①直接赋值，如：Stringstr=”hello”(直接存储在栈里，寻找具有hello的字符串，如果已经有则直接指向hello，如果没有过就开辟一个hello空间);②用new创建字符串对象，如：String str=new String(” hello”)(每创建一个new对象，就在堆中开辟一个对象空间，栈中的地址指向堆的内容);

　　引用类型：类类型，接口类型，数组类型

　　定义：引用类型的值是指向内存空间的引用，就是地址，变量引用(地址)存在栈中，而对象存在堆中。

　　引用数据类型包括:类,数组,接口

　　基本数据类型和引用类型的区别主要在于基本数据类型的量和内容是分配在栈上的，而引用类型的量被分配在栈内存里，而真正内容是分配在堆上的，栈通过指针指向堆上的内容。

　　实例：我们分析一下”==“和equals()的区别。

　　①定义两个string对象(引用类型)

　　stringa="abc"; //a指向堆中一个对象的地址

　　string b="abc"; //b指向堆中另一个对象的地址

　　然后

　　if(a==b){system.out.println("a==b");}

　　else

　　{system.out.println("a!=b");}

　　程序输出a!=b

　　原因:a和b的地址是不相同的，a==b比较的是两个变量的地址，所以地址不相等;

　　②定义两个基本类型

　　int a=4;

　　int b=4;

　　if(a==b){system.out.println("a==b");}

　　else

　　{system.out.println("a!=b");}

　　输出：a==b

　　原因：==比较的是两个变量的内容

　　结论：不论是基本数据类型还是引用类型，他们都会先在栈中分配一块内存，对于基本类型来说，这块区域包含的是基本类型的内容;而对于对象类型来说，这块区域包含的是指向真正内容的指针，真正的内容被手动的分配在堆上

　　User user; .栈区 局部变量

　　UserDAOuserDao; .方法区 静态成员变量

　　User[] users; .堆区 实例变量

　　类型转型：自动类型转换和强制类型转换

　　自动类型转换:由低精度类型向高精度数据类型的转换，如：bytebt=5;int it=bt;

　　强制类型转换:与自动转换相反，如：inti=16;byte bt=(byte)i;

　　相等性测试：==和equals()

　　1.4操作符(运算符)

　　分类：算术运算符，布尔运算符，关系运算符，位运算符，赋值运算符，条件运算符，字符串运算符，逗号运算符，其他运算符;

　　①算术运算符：

　　单目：+ (取正) - (取负) ++ (自增1) - - (自减1)，如：i=0,j=0; j=i++(i=0,j=1);j=++i(i=1,j=1)

　　双目：+ - * / %(取余)

　　三目：a>b?true:false

　　说明：当a大于b的时候，为true(也就是冒号之前的值)，否则为false;这整个运算符包括一个关系运算符(可以是“>”"<""!="等等)，一个“?”，一个“：”，冒号前后需要有两个表达式或者是值或者是对象。

　　②关系运算：

　　= =(等于)，!= (不等于)，> (大于)，< (小于)， >= (大于等于) ，<= (小于等于)。

　　③位运算符：

　　位运算符　与(&)、非(~)、或(|)、异或(^)

　　&：当两边操作数的位同时为1时，结果为1，否则为0。如1100&1010=1000

　　| ：当两边操作数的位有一边为1时，结果为1，否则为0。如1100|1010=1110

　　~：0变1,1变0 。如~1010=0101

　　^：两边的位不同时，结果为1，否则为0.如1100^1010=0110

　　④逻辑运算符：

　　与(&&)、非(!)、或(||)

　　⑤赋值运算符：

　　= += -= *= /= %= &= ^= |= <<= >>=

　　⑥其他

　　运算符优先级

　　按优先级从高到低排列如下：[ ] ( ) ++ -- ! ～ instanceof * / % + - << >>>>> <> < = > \ == != &^& & || ? := op= 。(口决：算关位逻赋)。

　　注：instanceof：测试某个对象是否是指定类或其子类的实例,。是Java的一个二元操作符，Java的保留关键字;作用是测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据。可以用在继承中的子类的实例是否为父类的实现。instanceof 一般情况下用在对象类型的强制转换。如：if(myObjectinstanceofMyClass){MyClassanothermyObject=(MyClass)myObject;…}是判定myObject是否是MyClass的实例或是其子类的实例。

　　<<：左移，如：

　　>>：右移(带符号)

　　>>>：添零右移

　　没有必要去记忆运算符号的优先级别,在编写程序时可尽量的使用括号来实现你想要的运算次序,以免产生难以阅读或含糊不清的计算顺序.运算符的结合性决定了并列相同级别的运算符的先后顺序,例如,加减的结合性是从左到右,8-5+3 相当于(8-5)+3.逻辑否运算符的结合性是右到左, x 相当于!(!x).表3.4是Java所有运算符的优先级和结合性。

　　当运算符进行数值运算时，结果类型默认高精度者，如：longa=1.23456,float b=2.123, c=a+b,c为long型。

　　1.5表达式

　　指用运算符连接起来的符合Java 规则的式子，如：c=a+b

　　1.6语句

　　赋值语句：

　　流程控制语句：

　　判断语句(if三种语句,switch语句)

　　① 简单if条件语句，描述：当表达式返回true 时，执行语句1(或语句块);当表达式返回false 时，直接执行下面的语句。如：if ( x>90 ) System.out.println("Good!");

　　② if…else…语句，描述：当布尔表达式返回true 时执行语句块1，否则执行语句块2;如：if (x>60)

　　System.out.println("Pass!");

　　else

　　System.out.println("No pass!");

　　③ if…else if…语句，描述：多分支语句，如：

　　int score;

　　char grade;

　　score=Integer.parseInt(args[0]);

　　if (score>=90)

　　grade=’A’;

　　else if(score>=80)

　　grade=’B’;

　　else if (score>=70)

　　grade=’C’;

　　else if (score>=60)

　　grade=’D’;

　　else

　　grade=’F’;

　　System.out.println("Score="+score+" Grade="+grade);

　　④ switch语句：描述：适合于用某个值来检测一个变量是否符合某个条件;

　　switch(条件表达式){

　　case 常量表达式1:

　　语句块1;

　　break;

　　…

　　case 常量表达式n:

　　语句块n;

　　break;

　　default:

　　语句块n+1;

　　break;

　　如：int week=3;

　　Switch(week){

　　Case 1:

　　System.out.println(“星期一”);

　　Break;

　　Case 2:

　　System.out.println(“星期二”);

　　Break;

　　Case 3:

　　System.out.println(“星期三”);

　　Break;

　　…

　　default:

　　System.out.println(“请输入有效数字!”);

　　}

　　循环语句(for语句，while语句，dowhile语句)

　　for语句：

　　for(初始化语句;循环条件;迭代语句){

　　语句序列(循环体)

　　}

　　如：计算1~100各数字的和

　　Intsum=0;

　　For(inti=0;i<=100;i++){

　　Sum=sum+i;

　　}

　　System.out.println(sum);

　　while语句:

　　while(条件表达式){

　　循环体

　　}

　　如：1~10相加

　　Int i=0;

　　Intsum=0;

　　While(i<=0){

　　Sum=sum+i;

　　i++;

　　}

　　System.out.println(sum);

　　Do{

　　循环体

　　}while(循环条件);

　　如：1~10相加

　　Int i=0;

　　Int sum

　　Do{

　　Sum=sum+i;

　　i=i+1;

　　}while(i<=10);

　　System.out.println(sum);

　　跳转语句(break语句，continue语句)

　　break语句:在执行循环时可以中断循环，强迫跳出循环;一般用在循环语句中。

　　如：输出1~100各数字的整数和

　　Int sum=0;

　　Int control=1;

　　While(true){

　　Sum+=control++;

　　If(control>100){

　　System.out.pritnln(sum);

　　Break;

　　}

　　}

　　continue语句:用于结束本次(指定条件)循环直接跳过执行循环体的剩余部分语句。

　　如：输出1~100中可以整除10的数

　　For(int i=1;i<100;i++){

　　If(i%10 !=0){

　　Continue;

　　}

　　System.out.println(i+”、”);

　　}

　　其他语句：foreach语句

　　关于循环综合例子：

　　①输出格式化的九九乘法表：

　　For(int i=0;i<=9;i++){

　　For(int j=0;j<=i;j++){

　　String str=j+”*”+i+”=”+j*i;

　　System.out.print(str+”\t”);

　　}

　　System.out.println();

　　}

　　②输出一个棱形

　　Public static void main(String[] args){

　　For(int i=1;i<=7;i+=2){

　　For(int kong=7;kong>i-1;kong--){

　　System.out.print(“ “);

　　}

　　For(intxing=1;xing<=i;xing++){

　　System.out.print(“*“);

　　}

　　System.out.println();

　　}

　　For(intj=1;j<=5;j+=2){

　　For(int kong1=1;kong1

　　System.out.print(“ “);

　　}

　　For(intxing1=5;xing1>=j;xing1--){

　　System.out.print(“*“);

　　}

　　System.out.println();

　　}

　　}

　　③阶乘:实现一个计算阶乘的方法，公式：n!=n*(n-1)*(n-2)…*2*1

　　Public static void main(String[] args){

　　Int n=16;

　　Long result=1;

　　If((n<0)||(n>17)){

　　System.out.println(“n的取值范围是0~17，大于17会超出long类型范围”);

　　}

　　Else if(n==0){

　　System.out.println(“0的阶乘等于1”);

　　}

　　Else{

　　For(int i=n;i>0;i--){

　　Result*=i;

　　}

　　System.out.println(n+“的阶乘等于:”+result);

　　}

　　}

　　④素数:素数是大于1的整数，并且其正因子只有1和它本身。下面：查找40个素数，然后分别在4行中输出，每行显示10个。

　　Public static void main(String[] args){

　　Final intNUMBER_FOR_PRIMES=40; //声明素数的数量

　　Final intNUMBER_FOR_EVERY_LINE=10;级 //声明每行输出多少素数

　　Int count=0; //素数计数器

　　Int number=2; //用于判断素数的数字

　　While(count< NUMBER_FOR_PRIMES){

　　Boolean isPrime=true; //是否素数的状态变量

　　For(int i=2;i<=number/2;i++){

　　If(number%i==0){

　　isPrime=false;

　　break;

　　}

　　}

　　If(isPrime){ //如果是素数

　　Count++; //累加素数计数器

　　System.out.print (number+”\t”); //输出素数，不换行

　　If(count% NUMBER_FOR_EVERY_LINE==0){ //如果已输出10个素数

　　System.out.println(); //换行

　　}

　　}

　　Number++; //自增用于判断的数字

　　}

　　}

　　1.7代码块

　　在Java中使用“{｝”括起来的代码称为代码块，根据代码块的定义位置及声明的关键字不同，代码块可以分为以下四种：普通代码块、构造块、静态块、同步代码块

　　1、 普通代码块：直接在一个方法中出现的“{｝”就称为普通代码块。

　　2、 构造块：直接在类中定义的代码块称为构造块。

　　可以看出构造块会重复调用多次，构造块会优先于构造方法执行。

　　3、 静态块：使用static关键字声明的代码块，称为静态块，静态块的主要目的是用来为静态属性初始化。

　　静态块优先于主方法执行，静态块优先于构造块执行，而且执行一次。

　　思考：

　　要求在屏幕上打印输出“HelloWorld!”，但是不能用主方法。

　　使用静态块代替主方法，并结束程序：

　　在静态块中加入系统退出后，以保证程序不再继续搜索主方法，但是程序知识娱乐使用，本身没有任何意义。

　　4、同步代码块

　　同步代码块主要出现在多线程中。

　　2.8文件结构

　　package XXX;//一个包

　　import java.util;//可以有多个

　　class 类名

　　{

　　//略主要是方法和变量

　　}

　　2.9注释(两种方式)

　　/*

　　*文档注释

　　*/

　　//单行注释

　　/* 多行注释 */

　　快捷键：ctrl+/

【Java语言的基础】相关文章：

java基础语言有哪些09-12

Java语言基础试题及答案06-06

Java语言编程基础知识06-16

没有英语基础怎么学好java语言08-04

Java语言程序设计基础篇10-23

java教程之Java编程基础09-12

Java基础学习步骤09-17

Java基础知识精选09-07

Java语法基础for语句练习09-21

Java基础知识概述05-16