Java培训笔记十一（自己总结的Java语法基础）

归纳总结

-------7月12日
（一） Java基本语法
1,数据类型
(1)基本数据类型

byte 1字节 8位 整型
short 2字节 16位 整型
char 2字节 16位 字符型
int 4字节 32位 整型
float 4字节 32位 单精度
long 8字节 64位 整型
double 8字节 64位 双精度
boolean 1字节 8位 布尔型

测试代码：

public class BaseType
{
private int i;

public short s;

private long l;

private float f;
private double d;

private byte b;

private char c;
private char r = 'a';//用单引号
private char t = 97;//ASCII码

private boolean bl;

public static void main(String[] args)
{
BaseType bt = new BaseType();
System.out.println("int-"+bt.i);
System.out.println("short-"+bt.s);
System.out.println("long-"+bt.l);
System.out.println("float-"+bt.f);
System.out.println("double-"+bt.d);
System.out.println("byte-"+bt.b);
System.out.println("char-"+bt.c+" "+bt.r + " " + bt.t);
System.out.println("boolean-"+bt.bl);
}
}

运行结果

(1)char型：
<1>ASCII字符集占用了Unicode字符集的前127个值
<2>unicode编码 (国际化，都为2个字节，移植性)和 非unicode
(2)数值型默认为0，字符型默认为空，Boolean默认为false
(2)引用数据类型
(1) 类（预定义类：有JDK的API提供和自定义类：自己命名的），接口（interface）,数组
(2)相当于指针
(3) 类：----- 1，属性<特征> 2，方法 <行为>
----- class 类名<:1，不能以数字和_开头 2，首字母必须大写 3，类名要有意义>
----- 类体：属性，类，方法
----- 方法的实现：修饰符 返回值类型 方法名<首字母小写> （参数列表）
----- 构造函数: 修饰符 类名(参数列表) {}
-->无返回值类型
作用：创建类的对象
new 类名()
(4) Java API(Application program interface)使用: 应用程序接口

测试代码：
public class Point{
int x;
int y;
int z;

//构造函数
Point(int _x,int _y,int _z){
x = _x;
y = _y;
z = _z;
}

public static void main(String[] args){
Point a1 =new Point(1,2,3);
a1.setX(2);
int s = a1.juLi();
System.out.println(a1.getX());
System.out.println(a1.getY());
System.out.println(s);

}

//含参数的方法
public void setX(int _x)
{
x = _x;
}

//不含参数的方法，用return结束方法

public int getX()
{
return x;
}

public int getY()
{
return y;
}

public int juLi()
{
return x * x + y * y + z * z;
}

}

结果：

2， 变量与常量
1：标识符

　 变量，类和方法都需要一定的名称，我们将这种名称叫做标识符。Java中对标识符有一定的限制。首先：所有的标识符的首字符必须是字母（大小写）、下划线＿或美元符￥

；其次标示符是由数字（0--9），所有从A--Z的大写字母、a--z的小写字母和下划线＿、美元符￥和所有在十六进制0xc0前的ASCII码等构成；第三注意表示符不能使用系统保留的

关键字做标示符(如goto,为了区分)。

以上是标识符命名的基本规则，以下是一个正误对照表，通过它会对标识符的命名规则有一个更好的了解：

　　　　　　合法标识符　　非法标识符

　　　　　　try　　　　　　try#　　 （注：不能用#作为标示符）　　　　　
　　　　　　group_7　　　　7group （注：不能用数字符号开头）
　　　　　　opendoor　　　 open-door （ 注：不能用下-作为标示 符号）
　　　　　　boolean_1　　　boolean (注：boolean 为关键字，不能 用关键字做标示符)

2：关键字

　　关键字是Java语言本身使用的标识符，它有其特定的语法含义。所有的Java关键字将不能被用作标识符，Java的关键字有：

abstract、continue、for、new、switch、boolean、default、goto、null、synchronized、break、do、if、package、this、byte、double、implements、private、threadsafe

、byvalue、else、import、protected、throw、case、extends、instanceof、public、transient、catch、false、int return、true、char、final、interface、short、try、

class、finally、long、static、void、const、 float、native、super、while等。

3: 变量声明：
<1>int age;//声明int 型变量
Char char1 = ‘c’;//声明char型 变量并赋值
<2>变量名必须是有效的标示符
不可以使用java的关键字
不能重复
应选择有意义的单词作为变量名；

4：常量声明
<1>final 数据类型 常量名 （大写）= 必须赋值 ；
该值不能被修改
例：final double PI = 3.1415926;
3， 运算符:
<1>赋值(=)，
算术（+ - * / %），
自增自减（++ --），
关系(< > == != >= <=)，
逻辑（&& & || ！ | ^）， 短路（从左端表达式可推断出整个表达式的值 如&& ； 而始终执行逻辑运算符 两边 的表达式称为“非短路”），
三元运算符（？：）

<2>逻辑运算符 VS 按位运算符
1.逻辑运算符只能操作布尔值或者一个能产生布尔值的表达式；按位运算符能操作整型值，包括byte、short、int、long，但是不能操作浮点型值（即float和double），它还可以

操作字符型（char）值。
2.逻辑运算符的运算遵循短路形式，而按位运算符则不是。

<3>算术运算java.lang.Math---->如Math.sqrt(double)

<4>运算符的优先级：小括号的使用
<5>比较- = = 和！= <a>基本数据类型：值的比较
<ｂ>引用数据类型：比较值和内存地址

测试代码：

public class Caculate {

public static void main(String[] args) {
Caculate cal = new Caculate();
int score = 80;
int x = -100;
boolean c = true , d = false;
String type = score < 60 ? "不及格" : "及格";
int flag = x > 0 ? 1 : ( x == 0 ? 'a' : 'b'); //三元运算符
System.out.println("type="+type);
System.out.println("flag="+flag);
System.out.println(x/score); //算术运算
System.out.println(c&d); //位运算
System.out.println(c^d);
System.out.println(cal); //引用数据类型
}
}

运行结果：

4， 数据类型转换
<1>有两点需要注意：1、14.0这样的浮点常量被认为是double型，只有加上f后缀才是float型的；2、整数常量被认为是int型，但是在编译时，可以认为编译器将其看作能表示该

数的最小数值，因此byte b = 100;不会报错。

public class ChangeTest
{
public static void main(String[] args)
{
byte a;
float f = 1.23f; //必须加上F或f,否则会报错
double d = 1.2345;
long l = 123456788L;//必须加上L或l,否则会报错
int b=266;
a=(byte)b; //强制转换
System.out.println(a);
System.out.println(b);
System.out.println(f);
System.out.println(l);
System.out.println(d);

}
}
5， 流程控制：
（1）条件语句

　　条件语句是程序设计中最常用的语句，用他来选择程序的执行流程，Java中的基本条件判断语句是if...else...语句。其机构为：

if (条件表达式)
{
语句1
}
Else
{
语句2
}
语句3

条件表达式”的值为真时执行“语句1”，然后执行语句3；否则执行“语句2”，然后执行语句3。

下面是一个用if--else语句构造多分支程序的例子：

if(a>5) b=1
else if(a>4) b=2
else if(a>3) b=3
...
else b=-1;

switch分支结构（开关语句）

　　switch分支结构用于多条件选择，虽然在多条件选择的情况下，也可以使用if...else...结构来实现，但是使用开关语句会使程序更为精炼、清晰。开关语句得格式为：

switch(条件表达式)
{
case 常量表达式1:
语句1 ;
break ;

case 常量表达式2:
语句2 ;
break ;
//......
case 常量表达式n:
语句n ;
break ;
default:
//
break
}

开关表达式首先计算出条件表达式的值，如果其值等于某个常量表达式，则执行该常量表达式后的语句，如果其值与所有的常量表达式的值不相等，则执行defualt后的语句。

　　在switch语句中，你通常在每一种case情况后都应使用break语句，否则，第一个相等情况后面所有的语句都会被执行，这种情况叫做落空。你可以试着分别加上去和去掉

break语句来执行下面的例子：

class Switch Test

public static void main(String args[])
throws java.io.IOException

char a;
System.out.println("Enter a number from 1--3:");
a=(char)System.in.read();
switch(a)

case'1':System.out.println("win a Car!");break;
case'2':System.out.println("picked the goat");break
case'3':System.out.println("get to keep your 100");
break;
default:System.out.println("entry");

在代码中加break语句后，你应明确知道程序将会发生的变化，并要确认程序没有转移到你不想执行的代码上。
　　

（2）循环语句
(1)do….while

测试代码：

public class DoWhileTest
{
public static void main(String[] args)
{
int n=0;
int sum=0;
do
{
sum+=n;
n++;
}while(n<=100);
System.out.println(sum);
}
}

(2)while
测试代码：
public class WhileTest
{
public static void main(String[] args)
{
int n=10;
int sum=0;
while(n>0)
{
sum+=n;
n--;
}
System.out.println(sum);
}
}

(3)for
测试代码：
public class Triger
{
//打印直角三角形
public void aTriger(){
for(int j = 1;j < 5;j++){
for(int i = 1; i <= 2*j - 1; i += 2){
System.out.print("*");

}
System.out.println("");
}
}

public void bTriger(){
for(int j = 4;j >= 1;j--){
for(int i = 1; i <= 2*j - 1; i += 2){
System.out.print("*");
}
System.out.println("");
}
}

//打印等腰三角形
public void cTriger(){
for(int j = 1; j < 5; j++){
for(int i = 1; i <= 4 -j; i ++){
System.out.print(" ");
}
for( int k = 1; k <= 2*j -1;k++){
System.out.print("*");

}
System.out.println("");
}
}

//打印菱形
public void dTriger(){
for(int j = 1; j < 5; j++){
for(int i = 1; i <= 4 -j; i ++){
System.out.print(" ");
}
for( int k = 1; k <= 2*j -1;k++){
System.out.print("*");

}
System.out.println("");
}
for(int a = 3; a >= 1; a--){
for (int b = 1; b <= 4 - a ; b++ )
{
System.out.print(" ");
}
for( int c = 1; c <= 2*a - 1;c++){
System.out.print("*");

}
System.out.println("");
}
}

public static void main(String[] args)
{
Triger t = new Triger();
t.aTriger();
t.bTriger();
t.cTriger();
t.dTriger();
}
}
(4)foreach

测试代码：
public class ArrayFor
{
public static void main(String[] args)
{
int []str = new int []{1,2,3,4};
for(int i:str){
System.out.println(i);
}
}
}

（二） 数组
<1>数组：用来保存一组值的数据结构
<2>语法：类型名[] 数组名 = new 类型名[长度]；
类型名[] 数组名；//声明
类型名[] 数组名 = {，，，，……}；//初始化
例：int [][] it = new int[4];

<3>特征：数组有大小限制
有类型限制
<4>数组是具有指定长度的用来存放特定类型数据的数据结构
（数据缓存）