java学习笔记（一）

1.java变量的基本概念：

1.1变量类似于自然语言中的代词

1.2java中的变量

java是强类型语言

变量必须声明，并且初始化以后使用

变量必须有明确的类型

变量不能重复定义

1.3变量的作用域

在声明的地方开始，到块结束为止

离开变量的作用域，变量将回收

public class VerDemo {

public static void main(String[] args) {
int age;// 变量的声明
// System.out.println(age);//还未初始化
age = 16;// 变量的初始化，第一次赋值
age = 15;// 变量二次赋值
System.out.println(age);// 输出
int score = 100;// 直接声明并初始化
System.out.println(score);
// int score=200;//不能重复定义
if (score > 80) {
int iq = 100;
System.out.println(iq);
}
// System.out.println(iq);//离开作用域访问了
int iq = 200;// 到这个位置原来的iq变量已经释放了，此处再次声明就不是重复定义了
System.out.println(iq);
}

}

2.二进制

2.1计算机内部只有二进制，包括字符数据等

2.2十进制是人类的习惯

在计算机中是：

十进制---------->二进制------------>十进制

十六进制是二进制的简写

public class BinDemo {
public static void main(String[]args){
int i=15;
System.out.println(Integer.toBinaryString(i));//转成二进制字符串
i='A';//单引号是字符，双引号是字符串
System.out.println(Integer.toBinaryString(i));//1000001
i=0xc0;
System.out.println(Integer.toBinaryString(i));
i='中';
System.out.println(Integer.toBinaryString(i));
System.out.println(Integer.toHexString(i));
}
}

3.基本类型和引用类型

3.1整数类型（byte,short,int,long）

byte      8bit          -128------127

short     16bit        -32768------32767

int         32bit        -65536------65535

long      64bit        -2^63--------2^63-1

很少使用short类型，使用int型时要注意整数的范围

直接量--字面量

a.整数的直接量的类型默认为int类型

b.以L,l为结尾的字面量是long类型

c.可以使用整数直接量给byte,short类型赋值，但不要超过byte,short的范围

public class IntegerDemo {
public static void main(String[] args) {
// byte b=0x127;//127,0127(前面有0表示八进制)
int size=1024*1024*1024*2;//超过了int类型的最大值，出现上溢现象，出现上溢在java中并不报错
System.out.println(size);
//直接量
long l=1;//直接量，字面量
// l=22000000000000000;//错，直接量默认是int类型的不能超过范围
l=22000000000000000L;//这样写才可以
short s=30000;
// short s1=32768;//错误，溢出
int a=127;
// byte bx=a;//不能这样赋值，不可使用变量直接给小类型赋值
byte bx=(byte)a;//做类型转换
bx=127;//直接量不超过范围，可以直接赋值
}
}

3.2浮点数

10001000（2）=1.0001000*2^111(2)

                            尾数               指数

float   32位

0                 00000111            10001000  00000000 0000000

符号位        指数                      尾数

float的精度比int类型小

double   64位，其中1位符号位，11位指数位，52位尾数位

double可精确表示int，不可精确表示long

2.147424566E9表示2.147424566*10^9

public class FloatDemo {
public static void main(String[] args) {
int a=0x7fffffff;
int b=0x7ffffff0;
float af=a;
float bf=b;
System.out.println(af);
System.out.println(bf);

double da=a;
double db=b;
System.out.println(da);
System.out.println(db);
double d=2.5;//double类型字面量
float f=2.5F;//F表示浮点类型字面量
double c=3D;//3 3L 3D 3F
// f=2.5;浮点型数字面量默认值是double类型的，不能直接赋值给flat类型
System.out.println(d);
System.out.println(f);
System.out.println(c);
}
}

3.3字符类型

最小值0，最大值65535

字面量也是整数常量，特殊字符采用转义字符表示

import java.util.Random

public class CharDemo {
public static void main(String[] args) {
int i='A';
System.out.println(i);//65,'A'的Unicode
//字符范围：0--65535
char c=0x4e2d;//'中';
i=c;
System.out.println(i);//20013 4e2d
System.out.println(c);//中
//结论字符是一个数值，是字符的Unicode编码值，
//println()方法根据参数类型
//采用不同的输出方式，整数输出整数，字符输出字符
System.out.println((int)'B');
int n='B'-'A';
System.out.println(n);
n='C'-'A';
System.out.println(n);
char ch='G';
int num=ch-'A'+10;//14
System.out.println(num);
ch='5';
num=ch-'0';
System.out.println(num);
ch='0';
System.out.println((int)ch);
char chr='A'+3;//字面量运算
System.out.println(chr);//'D'
//生成随机数
Random r=new Random();
int x=r.nextInt(26);//随机数x的范围[0,26）
chr=(char)('A'+x);//变量运算，大类型到小类型就要强制转换
System.out.println(chr);

char cx=0;
char cy='0';//(int)48

//转义字符
char xx='\'';//  \'表示一个单引号
System.out.println(xx);
xx='\\';
xx='\n';
xx='\u4e2d';
xx='\u0041';
System.out.println(xx);
xx='\u0000';//0
System.out.println(0==xx);//true
//\n \r \t \' \" \\
System.out.println("a\tb\nc");
System.out.println((int)'\u0000');
// System.out.println("OK\u0000123");
System.out.println('\ufffe');
}
}

public class BooleanDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
boolean isMan=false;
boolean finished=true;
if(finished){
System.out.println("欢迎你再来");
}
}
}

4.数制类型转换

4.1自动类型转换（隐式类型转换）

从小类型到大类型，自动完成

byte-->short---->int---->long---->float----->double

            char----->

4.2强制类型转换

风险：精度损失或者溢出

public class CovertDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
long l=1024L*1024*1024*4;//0x100000000
System.out.println(Long.toBinaryString(l));
int i=(int)l;
System.out.println(Integer.toBinaryString(i));
}
}

5.java中的方法

5.1方法就是函数

y=f(x)=3x+6

5.2方法的语法

（修饰词）（返回值类型）（方法名）（参数列表）{

//方法体

}

5.3方法需要有return语句，返回和返回值类型兼容的数据

import java.util.Scanner;
public class MethodDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
int x=5;
int y=f(x);//Function==Method
System.out.println(y);
//从控制台读取信息:console(控制台)
Scanner console=new Scanner(System.in);
double d=console.nextDouble();
double z=k(d);
System.out.println(r(z));
}
public static int f(int x){
int y=3*x+6;
return y;
}
public static double k(double t){
double g=9.8;
return g*t*t/2;
}
//四舍五入
public static long r(double d){
return (long)(d+0.5);
}
}