【Java概念】java语言基础（1），
分享于 点击 15518 次 点评：97
【Java概念】java语言基础（1），
JAVA基础知识点1
一.java语言基础组成：关键字，标识符，注释，常量和变量，运算符，语句，函数，数组。
1.关键字：用于定义数据类型的关键字：class ,interface,byte,short,int ,long ,float,double,char,boolean,void.
用于定义数据类型值得关键字：true，false，null。
用于定义流程控制的关键字：if，else，switch，case，default，while，do,for,break,continue,return.
用于定义访问权限修饰符的关键字：public，private，protected
用于定义类，函数，变量修饰符的关键字：abstract，final，static，synchronized
用于定义类与类之间的关键字：extends，inplements
用于定义建立实例及引用实例，判断实例的关键字：new,this,super,instanceof(实例)
用于异常处理的关键字：try,catch,finally,throw,throws
用于包含的关键字：package，import
2.标识符：由数字，英文字母，_$组成。数字不可以开头。
3.注释：可以进行调试；编译完之后注释消失；
/* */进行注释的时候，先写“需求”，第二步，“思路”，有多少步写多少步。第三步“步骤”，。
4.常量：
1.整数常量
2.小数常量
3.布尔型常量 true，false
4.字符常量 将一个字母数字或者符号用单引号（‘’）标识。
5.字符串常量。用双引号“”标识。
6.null常量。
整数的表现形式：二进制，八进制，十进制，十六进制（用ox开头）
5.变量：内存中的一个存储区域 。该区域有自己的名称即变量名和类型即数据类型。
为啥要定义变量？为了重复使用。数据是变得。
定义变量的格式：数据类型 变量名=初始化值
数据类型：
基本数据类型：数值型，字符型，布尔型。
数值型：整数类型，byte(一个字节)，short(2个字节)，int（4个字节），long(8个字节)
浮点类型 float(4个字节)，double（8个字节）
字符型：char（2个字节）
布尔型：boolean
引用数据类型：类class，接口interface，数组【】
1.强制类型转换。
2.默认的数值是int类型。
6.运算符：
算术运算符：+（还有连接符） - * / %（取余，模运算） ++（自增） --（自减）
**** i++在内存中的运算过程：
例：int i=3;i=i++;System.out.println("i="+i);
*解释：在内存中，i++不是独立的，是参与其他的运算中了。
原则是：i先记录住自己的值（如图1），i先进行右边的i++运算（如图4），暂时还不能赋值。
i开辟一块临时缓存空间（如图3）将i的值临时的存储下来，放在temp中，
然后在进行右边的运算。现在开始i++运算（如图4）；然后将3+1=4的结果
放到i的源内存中（如图5），i的值变成4，4覆盖掉3，此时右边才算完。
现在往左边赋值，即：将temp=3的临时值赋给左边的i。也就是说
i=i++; temp =i;i=i+1;i=temp;（如图6）
（图1）
（图2）
（图3）
（图4）
（图5）
（图6）
赋值运算符：+=,-=,*=,/= ，赋值运算符可以在底层做自动的转换，不会有精度的损失。比如short s=3;s+=4;最后不会出现精度的损失。但是s=s+4;则会出现精度的
损失。因为short 类型和int 类型不一样。
赋值运算符不需要强制类型的转换。在底层进行了类型的提升。
比较运算符：
逻辑运算符：用于连接两个boolena 类型的表达式。
&：与，|:或，^异或（如果符号两边真值相同，结果是false ,不相同是true）
！：非运算，判断事物的另一面。&&与与。||或或。&&与&的区别和||与|的区别就是双与的
具有短路运算。
位运算符：<<左移，>>右移，>>>无符号右移，&与运算，|或运算，^异或运算，~反码。
//位运算符<<,>>
System.out.println(3<<2);
//左移的原则是：|00000011|，两边的是边界，将00000011整体左移两位，即得到00|000011… …|
低位空出了两位用0补上。得到|00001100|，所以3<<2的值为1100，12。
//右移的原则同左移。
//^一个数异或同一个数两次还是这个数。
三元运算符：
二.流程控制
判断结构
选择结构
循环结构
1.判断结构:
if(条件表达式)
{执行语句；} ,
if else,
if else if,
if（）｛｝
else if（）｛｝
else if(){}//对前面的所有的否定
2.选择结构：
switch 语句：
格式：
switch(表达式)
｛
case 取值1：
执行语句1；
break；
case 取值2：
执行语句2；
break；
……
default：
执行语句；
break；
｝
｝
****选择结构可以选择的类型有限，只有byte,short,int,char.四种。
》1 if和switch的应用场景
if:
1.对具体的值进行判断。
2.对区间判断。
3.对运算结果是boolean 类型的表达式进行判断。
switch：
1.对具体的值进行判断。
2.值的个数通常是固定的。
3.循环结构
代表语句：while，do while ,for
while(条件表达式)
｛执行语句；｝
do
{
执行语句；
}while；
****
for(初始化表达式；循环条件表达式；循环后的操作表达式)
｛
执行语句；（循环体）
｝
####无限循环的最简单的形式：
while(true){}
for(;;){}//for里的循环条件默认的是true
***转义字符：
\n:回车
\t:制表
\r:按下回车键
\b:退格
windows系统中回车符其实是由两个字符组成的：\n\r。
Linux 是由\n组成的
4.其他流程控制语句。
break（跳出），continue（继续）
continue语句是结束本次循环继续下次循环。
break 的作用范围：要么是switch，要么是循环语句。
break跳出所在的当前的循环。如果出现了循环嵌套，break想要跳出指定的循环，可以通过标号来完成。
continue：继续。作用的范围。结束本次循环，继续下次循环。
第一篇：
//数据类型的演示Demo2
/**
进行数据类型，变量的测试
*/
public class Data_type{
public static void main(String[]args)
{//数据类型基本定义
byte b=3;//定义b的类型
// b=8;//使用b,给b赋值
short s=5402;
int x=11;
long l=12345678922324l;//加l是强制转换
//float f=2.3;//错误: 不兼容 的类型: 从double转换到float可能 会有损失float f=2.3;
float f=2.3f;//小数默认的是double类型，所以需要在2.3后加f,即float f=2.3f;
double d=2.3;
char ch='a';
boolean b1=true;
System.out.print(ch);
}
}
第二篇：
/**测试变量的内存存储空间
*/
public class VarDemo
{
public static void main(String[]args)
{
int x=2;
x=x+3;
/*CPU计算的时候，先调出存储在内存中的2（0010）与3（0011）做加法运算
得到：0010+0011=0101，即得到5。*/
byte b=2;
b=(byte)(b+200);//对b+4的结果进行强制的转换，将其转换为byte型。byte（b+4）.
/*错误: 不兼容的类型: 从int 转换到byte可能会有损失
b=b+4;*/
/*b=(byte)(b+200);b=-54 ,x=5精度溢出。(11001000)=200*/
/*因为b在内存中占有一个字节，4在内存中占有四个字节，
当：b+4在进行运算的时候，进行位数的提升，将b提升为int型；
但是在最后将b+4的值赋给b时出现了精度损失，因为，int型变成byte型。
*/
byte b1=3;
byte b2=7;
//b=b1+b2;
/*从int 转换到byte可能会有损失
b=b1+b2; 因为b1,b2为变量*/
int y=b1+b2;
System.out.println(y);
int x2=Integer.MAX_VALUE;//求int里的最大的值
x2=x2+2;
System.out.println("x2="+x2);
System.out.println("b="+b);
System.out.println("x="+x);
}
}
第三篇：
/*运算符的运算测试*/
public class OperateDemo
{
public static void main(String[]args)
{
int x=2%5;
int x1=-2%5;
int x2=2%-5;
System.out.println("x="+x+" "+"x1="+x1+" x2="+x2);//结果为x=2;
//结果：x=2 x1=-2 x2=2
//得出的结果：有负数参与模运算时，正负号看被取模的数的符号！！！
//测试”+“连接运算符
System.out.println("5+5="+5+5);//连接运算符和加运算符的优先级
//测试++ --
int a=3;
//a++;结果为4
//++a;结果为4
/*int b=3,c;
c=b++;
System.out.println("c="+c+"b="+b);//结果c=3,b=4*/
int b=3,c;
c=++b;
System.out.println("c="+c+"b="+b);
System.out.println("a="+a);
//测试i++
int i=2;
i=i++;
System.out.println("i="+i);//得到的结果是：i=2
//测试++i
int i1=2;
i1=i1++;
System.out.println("i1="+i1);//得到的结果是：i1=2
//测试赋值运算符 +=，-=，*=，/=，
short s=3;
s+=5;//不需要强制类型的转换
System.out.println("s="+s);//结果为8，没有出现精度的损失
//s=s+5;//需要强制类型的转换
//System.out.println(s);// 错误: 不兼容的类型: 从int转换到short可能会有损失
//测试逻辑表达式
int bo=3;
System.out.println(bo>2&&bo<8);
//位运算符<<,>>
System.out.println(3<<2);
/*左移的原则是：|00000011|，两边的是边界，将00000011整体左移两位，即得到00|000011… …|
低位空出了两位用0补上。得到|00001100|，所以3<<2的值为1100，12。*/
//右移的原则同左移。
//^一个数异或同一个数两次还是这个数。
int a1=3,b1=5;
a1=a1^b1;
b1=a1^b1;
a1=a1^b1;
System.out.println("a1="+a1+"b1="+b1);
}
}
第四篇：
//选择结构：if
public class IfDemo
{
public static void main(String[]args)
{
{
int a=2;
System.out.println(a>3?1:2);
}
//将一个代码块加括号，可以节省内存空间，当虚拟机遇到结束的“｝"的时候，自动释放所定义的变量。
//局部代码块可以定义局部变量的生命周期。
if(true)
{int a=2;
System.out.println("结果是true"+a);
}
else
System.out.println("结果是false");
//if(false)System.out.println("false");
//错误的语句，只有当if 里的条件表达式是true的时候才执行语句。
/*通过输入的月份判断所在的季节*/
int month=8;
if(month<1||month>12)
System.out.println(month+"没有对应的季节");
else if(month>=3 && month<=5)
System.out.println(month+"是春季");
else if( month<=8)
System.out.println(month+"是夏季");
else if(month<=9)
System.out.println(month+"是秋季");
else System.out.println(month+"是冬季");
}
}
第四篇：
/*选择结构的测试
switch 格式：
switch(表达式)
｛
case 取值1：
执行语句1；
break；
case 取值2：
执行语句2；
break；
……
default：
执行语句；
break；
｝
*/
public class SwitchDemo
{
public static void main(String[]args)
{
int x=2;
switch(x)
{
default:
System.out.println("d");
case 2:
System.out.println("a");
break;
case 3:
System.out.println("b");
break;
case 1:
System.out.println("c");
break;
}
int month=24;
switch(month)
{
case 3:
case 4:
case 5:
System.out.println(month+"是春季");
break;
case 6:
case 7:
case 8:
System.out.println(month+"是夏季");
break;
case 9:
case 10:
case 11:
System.out.println(month+"是秋季");
break;
case 12:
case 1:
case 2:
System.out.println(month+"是冬季");
break;
default:
System.out.println(month+"没有对应的季节");
break;
}
}
}
第五篇：
/*while循环结构的测试
while(条件表达式)//当条件表达式为真的时候执行语句。
｛
执行语句；
｝
*/
public class WhileDemo
{
public static void main(String[]args)
{
//while 循环语句
int x=1;
while(x<3)
{
System.out.println("x="+x);
x++;
}
int y=1;
do
{ y++;
System.out.println("我是do while 循环");
}
while(y<=4);
//1到100的6的倍数的次数
int i=1;
int count=0;
//计数器思想
while(i<=100)//总的循环次数，有100次。
{
if(i%6==0)//判断是否为6的倍数
{
System.out.print(i+" ");
count++;
if(count%5==0)
System.out.println();
}
i++;
}
System.out.println();
System.out.println("次数为"+count);
}
}
第六篇：
/*for语句的测试*/
public class ForDemo
{
public static void main(String[]args)
{
/*for(初始化条件；循环条件的表达式；循环后的操作表达式)
｛
执行语句；（循环语句）
｝*/
for(int i=1;i<=3;i++)
{
System.out.println("i="+i);
}
//初始化条件为输出语句的时候：
int i=1;
for(System.out.println('a');i<3;System.out.println('b'))
{
System.out.println('c');
i++;
}//最后的结果为：a,c,b,c,b
/*原理解释：先执行第一句得到输出的 a,判断i<3,执行循环体里的输出语句，输出 c,
接着，i++得到i=2,再接着执行输出语句输出b,2<3,执行循环体，输出 c,再执行输出语句输出b*/
for(int j=1,sum=0;j<=100;j++)//将sum的初始化值在for 循环的里定义
{
sum=sum+j;
if(j==100)//判断当j为100的时候，将所有的和输出。
System.out.println("sum="+sum);
}
//在for循环的外面进行定义sum的初始化值。
int sum=0;
for(int j1=1;j1<=100;j1++)
{
sum+=j1;
}
System.out.println("sum="+sum);
//由此可见局部变量局限性比较大，定义在代码块里的话，只能在模块里有含义。
//for循环里的变量只在这个局部有作用，出了作用域就被释放了。
}
}
第七篇：
/*for语句的嵌套循环*/
public class ForForDemo
{
public static void main(String[]args)
{
//forfor嵌套循环
for(int i=1;i<=4;i++)
{
for(int j=1;j<=4;j++)
System.out.println("*&*");
}
System.out.println("------------------");
//打印出一个有四行五列的星星
/*
******
******
******
******
*/
for(int i=1;i<=4;i++)
{
for(int j=1;j<=5;j++)
{
System.out.print('*');
}
System.out.println();
}
System.out.println("------------------");
//打印一系列的三角形
/* ******
*****
****
***
**
*
*/
//总共有6行，每一行的个数为第n行数
for(int i=6;i>=1;i--)
{
for(int j=1;j<=i;j++)
{
System.out.print("*");
}
System.out.println();
}
System.out.println("------------------");
//打印一系列的三角形
/* *
**
***
****
*****
******
*/
//总共6行，每一行的个数为行号
for(int i=1;i<=6;i++)
{
for(int j=1;j<=i;j++)
{
System.out.print("*");
}
System.out.println();
}
System.out.println("------------------");
//打印三角形数
/*
54321
5432
543
54
5
*/
for(int j=1;j<=5;j++)
{
for(int i=5;i>=j;i--)
{
System.out.print(i);
}
System.out.println();
}
System.out.println("------------------");
//打印三角形相同数
/*
1
22
333
4444
55555
*/
for(int i=1;i<=5;i++)
{
for(int j=1;j<=i;j++)
{
System.out.print(i);
}
System.out.println();
}
System.out.println("------------------");
//打印出久久乘法表
/*
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
……
*/
for(int i=1;i<=9;i++)//总共有九行乘法
{
for(int j=1;j<=i;j++)
{
System.out.print(j+"*"+i+"="+i*j+'\t' );//'\t'是制表符，专门用于控制表的结构
}
System.out.println();
}
System.out.println("------------------");
//打印出倒立的三角形
/*
* * * * *
#* * * *
##* * *
###* *
####*
*/
//总共需要打印5行，每一行分别是5，4，3，2，1个星
//可以对这个三角形分析，三角形星号前面都是空格
for(int i=1;i<=5;i++)
{
//1.先打印##正立三角形
for(int j=1;j<i;j++)
{
System.out.print("#");
}
//2.再打印出倒立的三角形，倒立的三角形是由一个*和一个空格组成的
for(int k=5;k>=i;k--)
{
System.out.print("* ");
}
System.out.println();
}
}
}
第八篇：
//测试break continue
public class BreakContinue
{
public static void main(String[]args)
{
A:for(int i=0;i<=3;i++)
{
System.out.println("i="+i);
//break;
B:for(int j=1;j<=4;j++)
{
System.out.println("j="+j+",i="+i);
}
break A;
}
//continue 继续使用
for(int x=0;x<=13;x++)
{ if(x%2==0)continue;
System.out.println("x="+x);
}
}
}相关文章
- 暂无相关文章
用户点评