java怎么规定字面值是整数_java基础阶段复习1

环境配置

JAVA_HOME:jdk的路径(jdk下载网址：http://www.oracle.com)

Path:要把jdk的目录路径，添加到path变量

java的运行工作原理

java源代码文件(.java)-->java字节码文件(.class)-->运行结果

.java-->.class:编译期(通过javac命令将java的源文件编译为字节码文件)

.class-->运行结果：运行期(先启动java虚拟机，不同的操作系统有不同的jvm,因此java跨平台,再通过JVM加载.class字节码文件，并加载main方法执行程序)

jdk jre jvm 的关系

jdk(开发工具包):Java Development Kit 是针对java开发员的产品，是整个Java的核心，包括了Java运行环境JRE,java工具和java基础类库。

jre(运行环境):Java Runtime Envirment Kit是针对运行JAVA的运行环境，包含JVM和java的核心类库。

jvm(Java虚拟机):java Virtual Machine,java虚拟机的缩写，是整个java实现跨平台的最核心的部分，能够运行以java语言写作的软件程序。

jdk有不同系统的版本，所以jdk是跨平台的

java的一次编写,处处执行是怎样实现的?

java程序会被编译成字节码组成的class文件,这些字节码可以运行在任何平台,因此java是平台独立的.

标识符

由字母,数字,下划线(_),$组成,不能有空格和其他字符,以及不能出现关键字.

不能由数字开头

严格区分大小写

见名知意

八种数据基本类型

byte(1),short(2),int(4),long(8),float(4),double(8),char(2),boolean(1)练习1(输入个人信息):

public class Test1{

public static void main(String[] args){

System.out.println("姓名:");

String name = new Scanner(System.in).nextLine();

System.out.println("性别:");

String sex = new Scanner(System.in).nextLine();

System.out.println("年纪:");

int age = new Scanner(System.in).nextInt();

System.out.println("您输入的个人信息是:");

System.out.println("姓名:");

System.out.println("性别:");

System.out.println("年纪:");

}

}练习2(圆的面积):

public class Test2{

System.out.println("请输入圆的半径:");

double r = new Scanner(System.in).nextDouble();

System.out.println(3.14*r*r);

}练习3(变量的交换):

public class Test3{

System.out.println("请输入变量a:");

int a = new Scanner(System.in).nextInt();

System.out.println("请输入变量b:");

int b = new Scanner(System.in).nextInt();

int t = a;

a = b;

b = t;

System.out.println(a);

System.out.println(b);

}

引用类型

引用类型是一个对象类型,其值是指向内存空间的引用,就是地址.

基本类型字面值规则

整数字面值是int(4)类型,如果值超出int范围,则需要做转型处理.

byte(1),short(2),char(2)三种比int小的整数,在自身范围内可以直接赋值.

浮点数字面值时double;浮点数转成整数会直接舍弃小数点后6位.

字面值后缀:L,D,F

字面值前缀:二进制(0b);16进制(0x);8进制(0);char类型16进制(u

基本类型的类型转换

计算结果的类型与运算中的最大类型保持一致

byte(1),short(2),char(2)三种比int小的整数,计算时会自动转为int.

有long类型时,都会转为long类型.

char类型相加,提升为int类型.

整数运算溢出:可以添加后缀;

浮点数运算不精确的解决方法:

1.直接去除整数;

2.四舍五入(Math.round());

3.向上取整(Math.floor());

4.向下取整(Math.ceil());

5.StringBuffer,StringBuilder

基本类型之间的转换

数字类型之间可以互相转换,从小到大自动转换,从大到小需要强制转型.

byte-->short-->int-->long

char-->int

int-->float/double/long小转大:隐式转换

int a = 9;

long b = a;大转小:显式转换

int x = 10;

byte b =(byte)x;

运算符

&:短路与,a&b,a与b同时为真时结果才为真,有一个为false均为false.不管左边是什么结果都要继续执行右边

&&:逻辑与,有一个为假即为假,不再继续判断,左边是假,右边忽略不执行.直接判断为真

|:短路或,a|b,a与b中有一个为真即为真,不管左边是什么结果都要继续执行右边.

||:逻辑或,有一个为真即为真即为真,不再继续判断.左边是真,右边忽略不执行,直接判断为真.

流程控制

switch:jdk1.7之前只能判断byte,short,char,int,之后可以判断string.从成立的case无条件的穿透所有的case包括default直到结束,或者是遇到break,如果所有的条件都不成立的话就执行case.switch(变量或表达式){

case1:

case2:

case3:

default;

}练习1:数字匹配

public class Test{

public static void main(String[] args){

int i = 3;

switch(i){

case1:

System.out.println("1");

break;

case2:

System.out.println("2");

break;

case3:

System.out.println("3");

break;

default:

System.out.println("default");

}

}

}

break:中 断,跳出循环

countine:结束本轮循环进入下一轮循环

for循环:for(变量赋值;执行条件;变量修改){

代码

}练习1:打印正方形

for(int i = 1;i<5;i++){

for(int j=1l;j<5;j++){

System.out.println("*");

}

System.out.println();

}练习2:打印倒三角

for(int i = 5;i>1;i--){

for(int j = 0;j

System.out.print("*");

}

System.out.print();

}练习3:打印99乘法表

public class Test3{

public static void main(String[] args){

test();

}

private static void test(){

for(int i = 1;i<=9;i++){

for(int j=1;j<=i;j++){

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

}

System.out.println();

}

}

}

if分支单分支:

if(判断条件){

代码

}多分支:

if(判断条件){

代码1

}else{

代码2

}嵌套分支:

if(判断条件1){

代码1

}else if(判断条件2){

代码2

}else if{判断条件3}{

代码3

}else{

代码4

}练习1:输入年号,判断平年闰年

public class Test1{

public static void main(String[] args){

System.out.println("年号:");

int y = new Scanner(Syetem.in).nextInt();

String r = "平年";

if(y%4==0){

if(y%100!=0){

r="闰年";

}

}

if(y%400==0){

r="闰年";

}

}练习2:商品打折

接收输入的原价,满1000打9折,满2000打8折,满5000打5折.

public class test2{

public static void main(String[] args){

System.out.println("输入总原价");

double price = new Scanner(System.in).nextDouble();

double nowprice = f(price);

System.out.println(nowprice);

}

public static double f(double p){

if(p>5000){

p=p*0.5;

}else if(p>2000){

p=p*0.8;

}else if(p>1000){

p=p*0.9;

}else{

p=p;

}

return p;

}练习3:统计学员得分

>90:优秀

80-90:良好

70-80:中等

60-70:及格

<60:不及格

public class test3{

public static void main(String[] args){

double score = new Scanner(System.in).nextDouble();

if(score>=100||score<=0){

System.out.println("请输入0-100范围内的数");

}

if(score>=90 && score<=100){

System.out.println("优秀");

}else if(score >= 80 && score<90){

System.out.println("良好");

}else if(score >=70 && score<80){

System.out.println("中等");

}else if(score >=60 && score<70){

System.out.println("及格");

}else if(score < 60){

System.out.println("不及格");

}

}

}练习4:产生一个随机数,和用户一直在输入的数字比较.

public class test4{

public static void main(String[] args){

find();

}

private static void find(){

int i = new Random().nextInt(100)+1;

System.out.println("请猜1-100以内的数字:");

int a = new Scanner(System.in).nextInt();

while(true){

if(a>i){

System.out.println("猜大了");

}else if(a

System.out.println("猜小了");

}else{

System.out.println("猜对了");

break;

}

}

}

}

三种循环的区别

for:知道循环次数

while/do...while:当循环次数不确定时

while:先判断，再执行，不符合规则，不执行代码

do while:先执行，再判断。代码至少被执行一次。

方法

被命名的代码块，方法可以含参也可以不含参。修饰符 返回值 方法名(参数){

方法体；

}

public static void f(){

}练习1:

public class test1{

public static void main(String[] args){

f1(9);

}

private static void f1(int a){

return 10*a;

}

}

方法的重载

方法的重载是指在一个类中有多个同名的方法，但每个方法都有不同的参数(参数的类型，个数，顺序不同)。程序在调用方法时，可以通过传递不同个数和类型的参数和决定具体使用哪一个方法。练习：

public class test{

public static void main(String[] args){

int a = 3;

int b = 9;

String name = "jack";

f1();

f2(a);

f3(a,b,name);

}

private static void f1(){

return 0;

}

private static void f2(int a){

return a*a;

}

private static void f3(int a,int b,String name){

return a+b+name;

}

}

数组

数组Array是用于存储多个相同类型的数据的集合。想要获取数组中的元素，可以通过元素的下标来获取，下标是从0开始的。

创建数组：动态初始化：int[] a = new int[5];

静态初始化：int[] b = new int[]{1,2,3,4,5};

int[] c = {2,3,4,5,6};练习1：

public class Test1(){

public static void main(String[] args){

f1();

}

private static void f1(){

//静态初始化创建数组

int[] i = new int[]{1,2,3,4,5};

System.out.println(Arrays.toString(i));

//动态初始化创建数组

char[] j = new char[4];

j[0] = "c";

j[1] = "h";

j[2] = "a";

j[3] = "r";

System.out.println(Arrays.toString(j));

}

//获取数组的长度

System.out.println(j.length);

}练习2：创建随机数组

public class Test2{

public static void main(Stirng[] args){

f();

}

private static void f(){

int[] a = new int[5];

for(int i = 0;i < a.length;i++){

a[i] = new Random().nextInt(100)+1;

}

System.out.println(Arrays.toString(a));

}

}

数组工具类Arrays

Arrays.toString(数组)：将数组连接成字符串

Arrays.sort(数组)：数组排序

Arrays.copyOf(数组，新的长度)复制数组长度为一个指定长度的新数组。

System.arraycopy(原数组，原数组起始位置，目标数组，目标数组起始位置，复制的数量):不会创建新的数组，但是目标数组要事先存在。

Arrays.binarySearch(数组，目标值)：二分法查找，在有序数组中查找目标值下标。

冒泡排序

相邻位置比较，从小到大排序，如果小就往前换，i代表从头到尾遍历数据。升序：

public class Test1{

public static void main(String[] args){

int[] arr = new int[]{31,23,43,65,17,89,54,76};

int[] arrnew = f1(arr);

System.out.println(Arrays.toString(arrnew));

}

public static int[] f1(int[] a){

//外循环控制比较次数

for(int i = 0;i

//内循环控制比较大小，循环次数和外循环一样

for(int j = 0;j

if(a[j]>a[j+1]){

int t = a[j];

a[j] = a[j+1];

a[j+1] = t;

}

}

}

return a;

}

}

降序：

public class Test2{

public static void main(String[] args){

// f1();

int[] arr = new int[] {1,2,4,2,1,8,9,3,2,4};

int[] newarr = f2(arr);

System.out.println(Arrays.toString(newarr));

}

private static int[] f2(int[] arr) {

//外循环控制次数

for(int i = 0;i

//内循环控制大小

for(int j = 0;j

if(arr[j]

int t = arr[j];

arr[j] = arr[j+1];

arr[j+1] = t;

}

}

}

return arr;

}

变量

一般通过三部分来描述变量.变量类型,变量名,变量值.

变量的使用原则:就近原则.

局部变量

定义在方法里,局部代码块中,方法运行完内存就释放完了.

成员方法里

定义在类里方法外.作用域是在整个类中,类消失了,变量才释放.public class Test1{

int a = 9;//成员变量

{

int x = 8;//局部变量

}

public static void main(String[] args){

int sum = 10;//局部变量

}

}