Java基础，
分享于 点击 42812 次 点评：26
Java基础，
java开发环境:
1)java编译运行过程:
.java源文件，经过编译，生成.class字节码文件
JVM加载.class并运行.class
--------跨平台，一次编程到处使用
2)JVM:java虚拟机
加载.class并运行.class
JRE:java运行环境
除了包含JVM以外还包含运行java程序所必须的环境
JRE=JVM+java系统类库
JDK:java开发工具包
除了包含JRE以外还包含开发java程序所必须的命令工具
JDK=JRE+编译、运行等工具
运行java程序的最小环境是JRE
开发java程序的最小环境是JDK
3)配置环境变量:-----了解
3.1)JAVA_HOME:指向jdk的安装目录
3.2)CLASSPATH:表示类的搜索路径，
一般简写为.
3.3)PATH:指向jdk下的bin目录
javac,java…都在bin目录下
//变量的演示
public class VarDemo {
public static void main(String[] args) {
//1.变量的声明
int a; //声明一个整型变量，名为a
int b,c,d; //声明三个整型变量，名为b,c,d
//2.变量的初始化:第一次赋值
int a=250; //声明整型变量a并赋值为250
int b; //声明整型变量b
b=250; //给变量b赋值为250
//3.变量的使用:
// 1)变量的使用必须与数据类型匹配
// 2)变量在使用之前必须声明并且初始化
// 3)对变量的操作就是对那个数的操作
//int a=25.678; //编译错误，数据类型不匹配
//System.out.println(c); //编译错误，c未声明
//int b;
//System.out.println(b); //编译错误，b未初始化
int c=5;
int d=c+10; //取出c的值5，加10后，赋值给d
System.out.println(d); //输出d的值15
int e=10;
e=e+100; //取出e的值10，加100后，赋值给e
//在本身基础之上增100
System.out.println(e); //输出e的值110
/*
4)变量的命名:
4.1)只能包含字母、数字、_和$符
不能以数字开头
4.2)严格区分大小写
4.3)不能使用关键字
4.4)可以中文命名，但不建议
建议"见名知意"和"驼峰命名法"
*/
int a1,a_2,a_$5y;
//int a*b; //编译错误，不能包含*号
//int 1a; //编译错误，不能以数字开头
//int class; //编译错误，不能使用关键字
//Int a; //编译错误，严格区分大小写
int 年龄; //正确，但不建议
int age; //建议"见名知意"
int score,myScore,myJavaScore; //驼峰命名法
/*
* 补充:
* 1.变量的作用域/范围:
* 从变量的声明开始，到包含它最近的大括号结束
* 2.变量的重名问题:
* 变量作用域重叠时，变量不能同名
*/
int a=5;
if(a>2){
//int a=55; //编译错误，作用域重叠时不能同名
int b=8;
}else{
int b=88;
}
int a=5;
if(a>2){
int b=8;
System.out.println(a);
System.out.println(b);
}
System.out.println(a);
//System.out.println(b); //编译错误，b超出作用范围了
}
}
//数据类型的演示
public class DataTypeDemo {
public static void main(String[] args) {
//1.int:整型，4个字节，-21个多亿到21个多亿
int a=250; //250叫整数直接量，默认为int型
//int b=10000000000; //编译错误，100亿默认为int型，但超出int范围了
System.out.println(5/2); //2，两个整数相除，结果还是整数，小数位被舍弃了
System.out.println(2/5); //0，小数位被舍弃了
int c = 2147483647;
c=c+1;
System.out.println(c); //-2147483647，溢出了，是需要被避免的
//2.long:长整型，8个字节，很大很大
long a=250L; //250L叫长整型直接量
//long b=10000000000; //编译错误，100亿为int型，但超范围了
long c=10000000000L;
//有可能超int范围时，将L写在第一个数字的后面
long d = 1000000000*2*10L;
System.out.println(d); //200亿
long e = 1000000000*3*10L;
System.out.println(e); //溢出了
long f = 1000000000L*3*10;
System.out.println(f); //300亿
//获取自1970.1.1零时到此时此刻的毫秒数
long g = System.currentTimeMillis();
System.out.println(g);
//3.double:浮点型，8个字节
double a=25.678; //25.678为浮点型直接量，默认为double型
float b=25.678F; //25.678F为float型直接量
double c=3.0;
double d=2.9;
System.out.println(c-d); //0.10000000000000009，舍入误差
//4.boolean:布尔型，1个字节，只能取值为true和false
boolean b1 = true; //声明布尔型变量b1并赋值为true
boolean b2 = false;
//boolean b3 = 250; //编译错误，数据类型不匹配
//5.char:字符型，2个字节 ‘0’码48(1-49) ‘a’码97 ‘A’码65 eg：int n=‘2’+‘2’//50+50=100
char c1 = '中';
char c2 = 'a';
char c3 = '1';
char c4 = ' ';
//char c5 = ''; //编译错误，必须有字符
//char c6 = '男性'; //编译错误，只能有一个字符
char c7 = 65;
System.out.println(c7); //A
char c8 = '\'';
System.out.println(c8); //'
System.out.println(2+2); //4
System.out.println('2'+'2'); //100,'2'的码50加上'2'的码50，结果为100
System.out.println(2+'2'); //52,2加上'2'的码50，结果为52
/*数据类型的转换
数据类型间的转换:
数据类型从小到大依次为:
byte-short-int-long-float-double
char--
1)两种类型:
1.1)自动类型转换:从小类型到大类型
1.2)强制类型转换:从大类型到小类型
(要转换成的类型)变量
强转有可能溢出和精度丢失
2)两点规则:
2.1)整数直接量可以直接赋值给byte,short,char，
但是不能超范围
2.2)byte,short,char类型的变量参与运算时，
先一律转换为int再运算
仅以byte为例进行阐述，byte为一字节8位，最高位是符号位。
最大值是01111111(补码)，补码即原码：
最大值为：2^0+2^1+2^2+2^3+2^4+2^5+2^6=(1-2)2^7/(1-2)=2^7-1=127
最小值是10000000(补码)，首先计算反码(补码-1)：
01111111
然后计算原码：
10000000
最大值为：-2^7=-128
*/
int a=5;
long b=a; //自动类型转换
int c=(int)b; //强制类型转换
long d=5; //自动类型转换
double e=5; //自动类型转换
float f=(float)5.678; //强制类型转换
long g = 10000000000L;
int h = (int)g;
System.out.println(h); //溢出，强转有可能会溢出
double i = 56.987456;
int j = (int)i;
System.out.println(j); //56，强转有可能会精度丢失
//多种类型参与运算时，系统自动向较大的类型转换
int k=5/2;
System.out.println(k); //2
double l=5/2;
System.out.println(l); //2.0，5/2的结果为int型的2，自动类型转
double m=5/2.0;
System.out.println(m); //2.5，5.0/2的结果为double型，所以能保留小数位
//两点规则:
//1)整数直接量可以直接赋值给byte,short,char，
// 但不能超范围
//2)byte,short,char型变量参与运算时，
// 先一律转换为int再运算
short b1 = 5;
short b2 = 6;
short b3 = (short)(b1+b2);
System.out.println(b3);
}
}
//运算符的演示
public class OperDemo {
public static void main(String[] args) {
/*
* 1.算术运算符:+,-,*,/,%,++,--
* 1)%:取模/取余，余数为0即为整除
* 2)++/--:自增1/自减1，可在变量前也可在变量后
* 2.1)单独使用时，在前在后无差别
* 2.2)被使用时，在前在后有差别:(值就近原则)
* a++的值为a的值
* ++a的值为a+1的值
*/
System.out.println(5%2); //1,商2余1
System.out.println(8%2); //0,商4余0，整除
System.out.println(2%8); //2,商0余2
System.out.println(8.4567%2); //0.4567
int a=5,b=5;
a++; //相当于a=a+1
++b; //相当于b=b+1
System.out.println(a); //6
System.out.println(b); //6
int a=5,b=5;
int c=a++;
int d=++b;
System.out.println(a); //6
System.out.println(b); //6
System.out.println(c); //5
System.out.println(d); //6
int a=5,b=5;
System.out.println(a++); //5
System.out.println(a); //6
System.out.println(++b); //6
System.out.println(b); //6
/*
* 2.关系运算符:
* 1)>(大于),<(小于)
* >=(大于或等于),<=(小于或等于)
* ==(等于),!=(不等于)
* 2)关系运算的结果为boolean型
* 关系成立则为true，关系不成立则为false
*/
int a=5,b=10,c=5;
boolean b1=a>b;
System.out.println(b1); //false
System.out.println(c<b); //true
System.out.println(a>=c); //true
System.out.println(c<=b); //true
System.out.println(a==c); //true
System.out.println(a!=c); //false
/*
* 3.逻辑运算符:
* 1)&&:短路与(并且)，两边都为真则为真，见false则false
* 第一个数为false，则短路(第二个数不走了)
* ||:短路或(或者)，有一边为真则为真，见true则true
* 第一个数为true，则短路(第二个数不走了)
* ! :逻辑非(取反)，非真则假，非假则真
* 2)逻辑运算是建立在关系运算基础之上的
* 逻辑运算的结果也是boolean型
*/
int a=5,b=10,c=5;
boolean b4=a<b || c++>2;
System.out.println(b4); //true
System.out.println(c); //5,发生短路了
boolean b3=a>b && c++>2;
System.out.println(b3); //false
System.out.println(c); //5，发生短路了
boolean b2=!(a>b);
System.out.println(b2); //!false=true
System.out.println(!(c<b)); //!true=false
System.out.println(a>b || c<b); //false||true=true
System.out.println(a==c || b<c); //true||false=true
System.out.println(a!=c || a>b); //false||false=false
System.out.println(a==c || a<b); //true||true=true
boolean b1 = a>b && c<b;
System.out.println(b1); //false&&true=false
System.out.println(a==c && b<c); //true&&false=false
System.out.println(a!=c && a>b); //false&&false=false
System.out.println(a==c && a<b); //true&&true=true
/*
* 4.赋值运算:
* 1)简单赋值运算:=
* 2)扩展赋值运算:+=,-=,*=,/=,%=
*/
int a=5;
a+=10; //相当于a=a+10
System.out.println(a); //15
a*=2; //相当于a=a*2;
System.out.println(a); //30
/*
* 5.字符串连接运算:
* 1)+:
* 1.1)若两边都是数字，则做加法运算
* 1.2)若有一边为字符串，则做字符串连接
*/
int age=37;
System.out.println("age="); //age=，字符串原样输出
System.out.println(age); //37
System.out.println("age="+age); //age=37
System.out.println("我的年龄是:"+age); //我的年龄是:37
System.out.println("我今年"+age+"岁了"); //我今年37岁了
System.out.println(10+20+""+30); //"3030"
System.out.println(10+20+30+""); //"60"
System.out.println(""+10+20+30); //"102030"
/*
* 6.三目/条件运算:
* 1)语法:
* boolean ? 数1 : 数2
* 2)执行过程:
* 计算boolean的值:
* 若为true，则整个的结果为数1
* 若为false，则整个的结果为数2
*/
int a=55,b=8;
int max=a>b?a:b;
System.out.println("max="+max); //55
}
}
//分支结构的演示
public class IfDemo {
public static void main(String[] args) {
int num = 4;
switch(num){ //byte,short,char,int
case 1:
System.out.println(111);
break;
case 2: //以此为入口
System.out.println(222);
break; //跳出switch
case 3:
System.out.println(333);
break;
default: //所有case都没配上时执行
System.out.println(666);
}
int num = 5;
if(num%2==0){
System.out.println(num+"是偶数");
}else{
System.out.println(num+"是奇数");
}
System.out.println("over");
int num = 5;
if(num%2==0){
System.out.println(num+"是偶数");
}
System.out.println("over");
}
}
判断一个整数是否是奇数：
public boolean isOdd(int i)
方法一：
public boolean isOdd(int i) {
if (i % 2 == 1) {
return true;
} else {
return false;
}
}
方法二：
public boolean isOdd(int i) {
return i % 2 == 1 || i % 2 == -1;
}
并且在提示之后优化成这样：
public boolean isOdd(int i) {
return i % 2 != 0;
}
方法三：奇数和偶数转换成二进制有什么区别？”“奇数最后一位是1，偶数最后一位是0。”
public boolean isOdd(int i) {
return (i & 1) == 1;
}
& 与运算 :见0则0 0 & 0 = 0 0 & 1 = 0 1 & 0 = 0 1 & 1 = 1
案例：(常用来截取数据) 如下运算的逻辑意义：将n的后8位截取下来
n = 00100100 10100100 00111101 11010110(n = 0x24a43dd6)
m = 00000000 00000000 00000000 11111111(m = 0xff)
&----------------------------------------
i = 00000000 00000000 00000000 11010110(i = n & m; // i = 0xd6)
/*
*
* 1.变量的作用域/范围:
* 从变量的声明开始，到包含它最近的大括号结束
* 2.变量的重名问题:
* 变量作用域重叠时，变量不能同名
*/
int a=5;
if(a>2){
//int a=55; //编译错误，作用域重叠时不能同名
int b=8;
}else{
int b=88;
}
int a=5;
if(a>2){
int b=8;
System.out.println(a);
System.out.println(b);
}
System.out.println(a);
//System.out.println(b); //编译错误，b超出作用范围了
}
}
//while的演示
public class WhileDemo {
public static void main(String[] args) {
int num=1; //1
while(num<=9){ //2
System.out.println(num+"*9="+num*9);
num++; //3
}
System.out.println("over");
int count=0; //1.循环变量的初始化
while(count<10){ //2.循环的条件
System.out.println("行动是成功的阶梯");
count++; //3.循环变量的改变
}
System.out.println("over");
/*
* 执行过程:
* count=0 true 输出
* count=1 true 输出
* count=2 true 输出
* count=3 true 输出
* count=4 true 输出
* count=5 true 输出
* count=6 true 输出
* count=7 true 输出
* count=8 true 输出
* count=9 true 输出
* count=10 false while循环结束
* 输出over
*/
}
}
//for循环的演示
public class ForDemo {
public static void main(String[] args) {
int sum=0;
for(int num=1;num<=100;num++){
if(num%10!=3){
sum+=num;
}
}
System.out.println(“sum=”+sum);
int sum=0;
for(int num=1;num<=100;num++){
if(num%10==3){ //3,13,23,33...
continue; //跳过剩余语句而进入下一次循环(去到num++)
}
sum+=num;
}
System.out.println("sum="+sum);
/*
* num=1 sum=1
* num=2 sum=1+2
* num=3
* num=4 sum=1+2+4
*/
/** 死循环*/
for(;;){ //死循环
System.out.println("我要学习");
}
//求1到100的累加和 1+2+3+...+99+100=?
int sum=0; //和
for(int num=1;num<=100;num++){
sum+=num; //在本身基础之上操作
}
System.out.println("sum="+sum);
/*
* 执行过程:
* sum=0
* num=1 sum=1
* num=2 sum=1+2
* num=3 sum=1+2+3
* num=4 sum=1+2+3+4
* ...
* num=100 sum=1+2+3+4+...+100
* num=101 false for循环结束
*/
for(int count=0;count<10;count++){
System.out.println("行动是成功的阶梯");
}
System.out.println("over");
/*
* 执行过程:
* count=0 true 输出
* count=1 true 输出
* count=2 true 输出
* ....
* count=9 true 输出
* count=10 false for循环结束
* 输出over
*/
}
}
//数组的演示
public class ArrayDemo {
public static void main(String[] args) {
//1.数组的定义
int[] arr = new int[10];
//2.数组的初始化
int[] arr = new int[3]; //0,0,0
int[] arr1 = {1,3,5}; //1,3,5
int[] arr2 = new int[]{1,3,5}; //1,3,5
int[] arr3;
//arr3 = {1,3,5}; //编译错误，只能声明同时初始化
arr3 = new int[]{1,3,5}; //正确
int[] arr = new int[]{}：//创建一个int类型的数组,名字为arr但是里面没有任何东西,所以长度为0
//声明int型数组a，包含10个元素
//每个元素都是int型，默认值为0
int[] a = new int[10];
//声明double型数组d，包含20个元素
//每个元素都是double型，默认值为0.0
double[] d = new double[20];
//声明boolean型数组b，包含40个元素
//每个元素都是boolean型，默认值为false
boolean[] b = new boolean[40];
//3.数组的访问
int[] arr = new int[3];
System.out.println(arr.length); //3
arr[0] = 100; //给arr中第一个元素赋值为100
arr[1] = 200;
arr[2] = 300;
//arr[3] = 400; //数组下标越界异常
System.out.println(arr[arr.length-1]); //输出arr中最后一个元素的值
//4.数组的遍历
int[] arr = new int[10];
for(int i=0;i<arr.length;i++){ //遍历arr数组
arr[i] = (int)(Math.random()*100);
System.out.println(arr[i]);
}
//5.数组的复制
int[] a = {10,20,30,40,50};
//数组的扩容(创建一个新的数组)
a = Arrays.copyOf(a,a.length+1);
for(int i=0;i<a.length;i++){
System.out.println(a[i]);// 10,20,30,40,50 ,0
}
int[] a = {10,20,30,40,50};
//a:源数组
//a1:目标数组
//6:目标数组的长度
int[] a1 = Arrays.copyOf(a,6);
for(int i=0;i<a1.length;i++){
System.out.println(a1[i]);// 10,20,30,40,50 ,0
}
int[] a = {10,20,30,40,50};
int[] a1 = new int[6];
//a:源数组
//1:源数组的起始下标
//a1:目标数组
//0:目标数组的起始下标
//4:要复制的元素的个数
System.arraycopy(a,1,a1,0,4);
for(int i=0;i<a1.length;i++){
System.out.println(a1[i]);
}
//6.数组的排序
int[] arr = {23,45,4,27,5,87,9};
for(int i=0;i<arr.length-1;i++){ //控制轮数
for(int j=0;j<arr.length-1-i;j++){ //控制每轮比较的次数
if(arr[j]>arr[j+1]){ //每一次都是和它的下一个元素比
int t=arr[j]; //符合条件则交换
arr[j]=arr[j+1];
arr[j+1]=t;
}
//若前数大于后数则交换，保证前数小于后数--升序
//若前数小于后数则交换，保证前数大于后数--降序
}
}
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
int[] arr = {26,34,1,3,68};
Arrays.sort(arr); //对arr升序排列
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
}
//求数组中的最大值
public class MaxOfArray {
public static void main(String[] args) {
int[] arr = new int[10];
for(int i=0;i<arr.length;i++){
arr[i] = (int)(Math.random()*100);
System.out.println(arr[i]);
}
int max = arr[0]; //假设第1个元素为最大值
for(int i=1;i<arr.length;i++){ //遍历剩余元素
if(arr[i]>max){ //若剩余元素大于max
max=arr[i]; //修改max的值为较大的数
}
}
System.out.println("最大值为:"+max);
//数组的扩容(创建新的数组并将源数组的数据复制进去)
arr = Arrays.copyOf(arr,arr.length+1);
//将最大值max赋值给arr中的最后一个元素
arr[arr.length-1] = max;
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
/**
冒泡原理:
1)四个数冒3轮
2)每一轮都是从第1个元素开始比，
每一次都是和它的下一个元素比
若符合条件则交换
3)冒出来的数就不带它玩了
arr.length-1-i
i=0 比3次
i=1 比2次
i=2 比1次
int[] arr = {89,23,36,1}; //升序
第一轮:
89和23比，换，23,89,36,1
89和36比，换，23,36,89,1
89和1比， 换，23,36,1,89-----89冒出来了
第二轮:
23和36比，不换
36和1比， 换，23,1,36,89-----36冒出来了
第三轮:
23和1比， 换，1,23,36,89-----23冒出来了
*/
int[] arr = {89,23,36,1};
for(int i=0;i<arr.length-1;i++){ //控制轮
for(int j=0;j<arr.length-1-i;j++){ //控制每轮的次数
if(arr[j]>arr[j+1]){ //每次和它下一个元素比
int t=arr[j];
arr[j]=arr[j+1];
arr[j+1]=t;
}
}
}
}
}
public static void main(String[] args) {
int count = 0; //计数器
for(int num=2;num<=100;num++){
boolean flag = true; //1.假设是质数：质数定义为在大于1的自然数中，除了1和它本身以外不再被整除。
for(int i=2;i<=Math.sqrt(num);i++){ //2/3/4/…/9/
if(num%i0){
flag = false; //2.表示不是质数
break;
}
}
if(flag){ //3.判断得结论
count++; //有一个质数则个数增1
System.out.print(num+"\t");
if(count%100){ //每10个换一行
System.out.println();
}
}
}
}
//方法的演示
public class MethodDemo {
public static void main(String[] args) {
//say();
/*
//sayHi(); //编译错误，有参则必须传参
//sayHi(25); //编译错误，参数类型不匹配
sayHi("zhangsan"); //String name="zhangsan"
sayHi("lisi"); //String name="lisi"
sayHi("wangwu"); //String name="wangwu"
*/
//int a = getNum(); //getNum()的值就是return后的那个值
//System.out.println(a);
//double num = plus(5.5,6.6); //double a=5.5,double b=6.6
//System.out.println(num);
//a(); //方法的嵌套调用
/*
double num1=5.1;
double num2=5.2;
double ccccc=plus(num1,num2); //double a=5.1,double b=5.2
System.out.println(ccccc);
*/
System.out.println("over");
}
public static void a(){
System.out.println(111);
b(); //方法的嵌套调用
System.out.println(222);
}
public static void b(){
System.out.println(333);
}
//有参有返回值
public static double plus(double a,double b){
double c = a + b;
return c; //返回的是c里面那个数
//return a+b;
}
//无参有返回值
public static int getNum(){
//return; //编译错误，必须返回一个结果
//return 5.678; //编译错误，返回值类型不匹配
return 250; //1.结束方法的执行 2.返回250给调用方
}
//有参无返回值
public static void sayHi(String name){
System.out.println("大家好，我叫"+name);
}
//无参无返回值
public static void say(){
System.out.println("大家好，我叫WKJ");
return; //1.结束方法的执行
}
}
相关文章
- 暂无相关文章
用户点评