Java基础语法

内存区分配:

1. code segment:存放代码

2. data segment: 静态变量

3. stack: 局部变量

4. heap: new出来的东西

8种基本数据类型:

布尔型: boolean

字符型: char:1 字节

整数型:

byte:1字节 -127-128

short:2字节 -2 15次方--2 15次方-1

int:4字节

long:8字节

浮点类型:float (4字节, 10的38次方), double(8字节, 10的300次方)

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

double放到float变量里不行, long 放到int里不会出错

数据类型转换:

1. boolean类型不能转换成其他类型

2. 整形int, 字符型char, 浮点型float数据可以相互转换

3. 容量小的类型自动转换为容量大的类型:容量指的是代表的数字的多少, 大小排序为:

byte,short,char-->int-->long-->float-->double(byte,short,char运算时自动转换成int,int+long=long...)

byte, short, char不能互相转换,他们三者在计算时首先自动转换为int类型

4. 容量大的转换为容量小的数据类型要加上强制转换符, 但会造成精度降低或者溢出.

5. 多种类型的数据混合计算时, 系统自动将所有的数据转换成容量最大的那种数据类型, 然后进行计算.

6. 实数常量默认为double, 整形常量默认为int

7. double变量不能强制转换为float, 因为浮点型存的方式不一样

8. float类型要标明f

byte=1 ;  //可以, 只要别超过127
byte b3=b1+b2; //不可以, 要强制转换(byte),改成下面
byte b3=(byte)b1+b2; //如果超过了127, 会自动砍掉前面的字节
float f1=1.23f; //必须加f
float f2=3.2f;
float f3=f1+f2; //不可以, 要强制转换, 因为会变成double

　　

public class TestConvert {
public static void main(String arg[]) {
int i1 = 123;
int i2 = 456;
double d1 = (i1+i2)*1.2;//系统将转换为double型运算
float f1 = (float)((i1+i2)*1.2);//需要加强制转换符
byte b1 = 67;
byte b2 = 89;
byte b3 = (byte)(b1+b2);//系统将转换为int型运算，需
//要强制转换符
System.out.println(b3);
double d2 = 1e200;
float f2 = (float)d2;//会产生溢出
System.out.println(f2);

float f3 = 1.23f;//必须加f
long l1 = 123;
long l2 = 30000000000L;//必须加l
float f = l1+l2+f3;//系统将转换为float型计算
long l = (long)f;//强制转换会舍去小数部分（不是四舍五入）

}
}

public class TestConvert2 {
public static void main(String[] args) {

int i=1,j=12;
float f1=(float)0.1;  //0.1f
float f2=123;
long l1 = 12345678,l2=8888888888L;
double d1 = 2e20,d2=124;
byte b1 = 1,b2 = 2,b3 = 127;
j = j+10;
i = i/10;
i = (int)(i*0.1);
char c1='a',c2=125;
byte b = (byte)(b1-b2);
char c = (char)(c1+c2-1);
float f3 = f1+f2;
float f4 = (float)(f1+f2*0.1);
double d = d1*i+j;
float f = (float)(d1*5+d2);
}
}

　　

　　

char类型相加自动转换int,需要强制转换回来:

public class Test {
public static void main(String[] args){
char c1='c';
char c2=1;
char c=(char)(c1+c2);
System.out.println("c="+c);
//System.out.println("c2="+c2);
}
}

阶乘相加的程序:

public class Test{
public static void main(String[] args){
long result = 0;
long f = 1;
for(int i=1;i<=10;i++){
f=f*i;
result=result+f;
}
System.out.println(result);
}
}

　　

1+3+5+...+99:

public class Test {
public static void main(String[] args){
int sum = 0;
for(int i=1; i<=99;i=i+2){
sum=sum+i;
}
System.out.println(sum);
}
}

　　

输出0~9:

public class TestWhile{
public static void main(String args[]){
int i=0;
while(i<10){
System.out.println(i);
i++;
}
}
}

while break, continue:

public class Test{
public static void main(String args[]){
int stop=4;
for(int i=1;i<10;i++){
if(i==stop) break;
System.out.println(i);
}
}
}

1-100被3整除的前5位:

public class Test{
public static void main(String args[]){
int num=0;
for(int i=1;i<=100;i++){
if(i%3==0){
System.out.println(i);
num++;
}
if(num==5) break;
}
}
}

　　

101-200之间的质数:只能被自身和1整除的数:

public class Test{
public static void main(String args[]){
for(int i=101;i<200;i+=2){
boolean f=true;
for(int j=2;j<i;j++){
if(i%j==0){
f=false;
break;
}
}
if(!f) continue;
System.out.println(i);
}

}
}

switch语句: case可以合并, 小心case穿透, 要使用break, switch里面的变成只能检测int型, 所以可以使用可以转换为int的 char,byte,short类型

public class Test{
public static void main(String args[]){
int i=8;
switch(i){
case(2):
case(3):
case(5):
case(8):
System.out.println("AAAA");
break;
case(9):
System.out.println("bbbb");
break;
default:
System.out.println("bbbb");
}
}
}