java基础
1、java的jdk中的文件
bin 存放可执行文件，java.exe javac.exe（java的编译工具）
db 小型数据库
jre java的运行环境，包括java的虚拟机，运行时类包等
include 由于java是由C/C++编写的，需要引入一些C语言的头文件
lib library的意思 库文件 开发工具的归档包
src.zip 存放java的源代码
2、第一个java程序（详细解释）
//public 全局的含义 class 定义一个类 hello表示类名（随意定义 首字母大写）
public class hello{
//public和上面的意思相同
//static静态
//void没有返回值
//main表示程序的入口 方法名
//从main开始进行执行 括号中的字符是方法的参数
public static void main(String[] args){
//在控制台上打印hello world
System.out.println("hello world");
}
}
3、定义类
定义类有两种方式
public class 类名和文件名一定要一致
class 文件名和类名可以不一致
class helloworld{
public static void main(String[] args) {
System.out.println("hello world");
}
}
生成的class文件名和java文件名没有关系，和类名是有关系的
一个文件中可以声明多个类，但是只能声明一个public class 且类名必须和文件名一致
每一个定义类，都会生成一个class文件
4、Java的关键字
5、标志符
数字、字母、下划线和$符号构成，其他符号不可以且必须以字母、下划线和$开头
定义标志符不可以使用关键字
区分大小写
6、变量
在程序执行的过程中，在某个范围内其值可以发生改变
如何定义变量：
数据类型 变量名 = 变量值；
数据类型 变量名；
变量名 = 变量值；
package test;
public class VarTest01 {
public static void main(String[] args) {
int i = 10;
int j;
j = 20;
System.out.println(i);//10
i = 18;
System.out.println(i);//18
}
}//在同一个域中 变量名不能重复 所有变量初始化
7、基本数据类型
byte float
short double
int char
long boolean
long的正确使用 在给long赋值时，需要在后面加“L”
程序会默认的把整型的字面值当做int类型
自动类型转换：当数据小的时候 编译器自动将数据类型进行转换
强制类型转换：long l2 = 12323; int b = (int)l2; 容量大的转换为容量小的 可能会损失精度
Float在编译时编译器会将float转换为double可能会损失精度，所以在定义时再后面加上F
float i = 1.2F;
Boolean的取值只有两个 true false
boolean flag = true;
if(flag) {
System.out.println("true");
}else {
System.out.println("false");
}
Char类型可以存储字母，汉字 只能存储一个
char c1 = '你';
System.out.println(c1);
如果存储的是数字 输出出来是数组对应的ASCII码的字符
转义字符
char c2 = '\'';//转义字符\
System.out.println(c2);
\t制表符 \n换行符
println会自动加上换行 print就不会自动换行
在进行整数运算的时候，会先将整数转换为int类型，如果不进行强制类型转换的话，最后输出的也是int类型，如果接受的变量不是int类型，则需要进行强制类型转换。
关于基本数据类型转换规则
1、8种基本数据类型除boolean之外都可以相互转换
2、小容量到大容量转换叫做自动类型转换
3、byte short char进行运算时，各自都先转换为int类型进行运算
4、大容量向小容量为强制类型转换，需要加强制类型转换符，编译虽然通过，但是可能会损失精度
5、多种数据类型运算时，先转换为容量最大的那个数据类型，再进行运算。
8、运算符
与或非（逻辑版） & | ！ 这个只是一个运算符 需要在两个boolean变量之间进行运算
与或非（短路机制） && || ！！ 这个有短路机制 如果前面的已经决定了结果，怎后面的不进行运算
三目运算符
package test;
public class text6 {
public static void main(String[] args) {
System.out.println("PI = " + 3.14);
int a = 10;
int b = 20;
int z = (a > b) ? a : b;
System.out.println(z);//20
int c = 30;
int temp = (a > b) ? a : b;
int max = (c > temp) ? c : temp;
System.out.println(max);//30
}
}
字符串组合
package test;
public class test8 {
public static void main(String[] args)
{
System.out.println(5 > 3);//true
System.out.println(5 == 5);//true
System.out.println("a" + "b");//ab
System.out.println('a' + 'n');//207 通过ascii进行运算
System.out.println("a" + 3.14);//a3.14
}
}
位运算 适合进行数字间运算和逻辑的不太一样
& 位与
| 位或
! 位非
~ 位异或
package test;
public class text7 {
public static void main(String[] args)
{
System.out.println(6 & 3);//2
System.out.println(6 | 3);//7
System.out.println(6 ^ 3);//5
System.out.println(~3);//-4
System.out.println("-----------");
System.out.println(12 >> 1);//12/2=6
System.out.println(12 >> 2);//12/4=3
System.out.println(12 >> 3);//12/8 =1 向右移n位，则除以2的n次方
System.out.println(12 << 1);//12*2=24
System.out.println(12 << 2);//12*4=48
System.out.println(12 << 3);//12*8=96 向左移n位，则乘以2的n次方
//^的特点：一个数据对另一个数据位异或2次，则这个数据本身不变
System.out.println("-----------");
System.out.println(12 ^ 5 ^ 12);//5
/*
1、请实现两个整数变量的交换(不能使用第三方变量)
2、最有效率的算出2 * 8的结果
*/
//方法一
/*
int a = 8;
int b = 6;
a = a + b;//a=14 b=6
b = a - b;//b=8
a = a - b;//14-8=6
有缺点，如果a+b超出了int类型的取值范围，则有可能损失精度
*/
//方法二
int a = 8;
int b = 6;
a = a ^ b;
b = a ^ b;//a ^ b ^ b，b=a
a = a ^ b;//a ^ b ^ a, a=b
System.out.println(2 << 3);//2 * (2*2*2)
}
}
9、控制语句 if-else
package test;
public class ifelse {
public static void main(String[] args)
{
boolean ifsuccess = true;
if(ifsuccess) {
System.out.println("login success");
}
else {
System.out.println("login fale");
}
if(ifsuccess)
System.out.println("login success");
else
System.out.println("login fale");//如果if else中只有一条语句时可以省略大括号
int x = 1;
if(x == 0) {
System.out.println("我喜欢踢足球");
}else if(x == 1) {
System.out.println("我喜欢打篮球");
}else {
System.out.println("我喜欢打排球");
}
}//login success
}
10、控制语句 switch
package test;
public class Switch_1 {
public static void main(String[] args) {
int a = 1;
switch(a) {
case 1:
System.out.println("basketball");
break;
case 2:
System.out.println("football");
break;
default:
System.out.println("Exit");
}
int m = 6;
switch(m) {
case 2:
case 3:
case 4:
System.out.println("春季");
break;
case 5:
case 6:
case 7:
System.out.println("夏季");
break;
case 8:
case 9:
case 10:
System.out.println("秋季");
break;
case 11:
case 12:
case 1:
System.out.println("冬季");
break;
default:
System.out.println("输入错误");
// switch后面的括号中可以填写byte、short、char、int类型，即能够自动转换为int类型的都可以，在jdk7版本之后可以填写String类型。
// case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
}
}
}
11、控制语句 for
package test;
public class for_1 {
public static void main(String[] args)
{
for(int i = 0;i<10;i++)
{
System.out.println("hello world + " + i);
}
}
}
99乘法表
package test;
public class for_1 {
public static void main(String[] args)
{
for(int i = 1;i<=9;i++)
{
for(int j = 1;j<=i;j++)
{
System.out.print(i + "*" + j + "=" +i*j + "\t");
}
System.out.print("\n");
}
}
}
12、while循环
package test;
public class while_1 {
public static void main(String[] args) {
int i = 100;
while(i > 0) {
System.out.println(i);
i--;
}
}
}
13、break和continue
Break结束距离它最近的循环
Return结束类方法
Continue结束本次循环进行下一次循环
结束循环
通过控制里层或者外层的for循环，来结束循环
package test;
public class break_continue {
public static void main(String[] args) {
for(int i = 0;i<5;i++)
{
System.out.println(i);
if(i == 5) {
break;
}
}
// 0
// 1
// 2
// 3
// 4
outFor:for(int i = 0;i<10;i++) {
innerFor:for(int j = 0;j < i;j++) {
System.out.print(j+",");
if(j == 2)
break outFor;结束指定的一个循环
}
System.out.print("\n");
// 0,
// 0,1,
// 0,1,2,
}
for(int i = 0;i<10;i++)
{
if(i == 5)
continue;
System.out.println(i);//不会输出5
}
}
}
14、方法的定义和作用
定义函数
package test;
public class func_1 {
public static void main(String[] args) {
funcAdd(10,20);
funcAdd(10,15);
}
public static void funcAdd(int a,int b) {
int sum = 0;
sum = a + b;
System.out.println(sum);
}
}
main方法是程序的入口 其他程序的函数定义的main之外 使用的时候在main中调用
没有函数返回值，使用void 有返回值使用具体的修饰符
将方法定义在其他类中 在main函数中调用
package test;
public class func_1 {
public static void main(String[] args) {
m1();//=func_1.m1()
func_2.m1();//调用第二个类中的m1函数
}
public static void m1() {
System.out.println("func_1.m1");
}
}
class func_2{//只能有一个public
public static void m1() {
System.out.println("func_2.m1");
}
}
方法的执行顺序
从main方法中从上向下执行
return 会结束方法 所以在return后面的语句不会被执行
15、方法的重载
首先可以定义不同的函数名 但是内部实现的功能大体一致
package method;
public class method01 {
public static void main(String[] args) {
System.out.println(sumInt(10,20));
System.out.println(sumLong(100000L,200000L));
System.out.println(sumFloat(1.0F,2.0F));
System.out.println(sumDouble(10.24,20.48));
}
public static int sumInt(int a,int b) {
return a + b;
}
public static long sumLong(long a,long b) {
return a + b;
}
public static float sumFloat(float a,float b) {
return a + b;
}
public static double sumDouble(double a,double b) {
return a + b;
}
}
在这种是否就可以使用方法的重载
package method;
//方法的重载overload
public class method02_01 {
public static void main(String[] args) {
System.out.println(sum(10,20));
System.out.println(sum(100000L,200000L));
System.out.println(sum(1.0F,2.0F));
System.out.println(sum(10.24,20.48));
}
public static int sum(int a,int b) {
return a + b;
}
public static long sum(long a,long b) {
return a + b;
}
public static float sum(float a,float b) {
return a + b;
}
public static double sum(double a,double b) {
return a + b;
}
//重载的条件
// 1、在同一个类中
// 2、方法名相同
// 3、参数列表不同（参数类型、个数、顺序）只要有一个不同就可以
// 4、重载和返回值类型没有关系
// 5、重载和修饰符类型没有关系 重载参数有关系
}
16、递归运算
package method;
//递归计算
public class digui {
public static void main(String[] args) {
System.out.println(sumAdd(100));
}
public static int sumAdd(int n)
{
if(n == 1)
return 1;
else {
return n + sumAdd(n - 1);
}
}
}
这些方法在编译器中，是以指针的方式，按照在main方法中的顺序进行压栈，在执行阶段以出栈的方式按照顺序调用对应内存中保存的代码进行执行
浙公网安备 33010602011771号