目录
一.Java程序开发（编写、编译、运行）
public class StudyJava{
public static void main(String[] args){
System.out.println("study java is happy");
}
}
//这是固定的形式其中各参数含义如下：
main——入口方法名称；
args——命令行参数，这是一个String对象数组；
static——修饰符，说明main()是一个静态方法（类方法）；
public——修饰符，说明main()具有公有访问属性。
输出的格式固定
System.out.println("study java is happy");
System.out.println("输出值为"+age); //输出变量值加号必须写哈，但是位置不固定
System.out.println(age"+为输出值");
System.out.println(age+"-->"+age1); //加号必须写哈
二.Java数据类型
一共分为基本数据类型和引用数据类型
1.Java基本数据类型共有八种，基本数据类型可以分为三类：
字符类型char；
布尔类型boolean；
数值类型byte、short、int、long、float、double。
数值类型又可以分为整数类型byte、short、int、long，和浮点数类型float、double。
2.引用数据类型：类，接口，数组。
3.JAVA中的数值类型不存在无符号的，它们的取值范围是固定的，不会随着机器硬件环境或者操作系统的改变而改变。
三.Java各种数据类型代码编写
1.整数类型
整数类型含byte、short、int、long
package com.onlyone;
public class integer{//整数类型
public static void main(String[] args){
byte money=2;//注意范围，不能超过byte所规定的范围
short age=298;//定义一个short类型的变量age，变量值为298
int teacheAge=30;//定义一个int类型的变量teacheAge，变量值为30
long sales=123456;//定义一个long类型的变量sales，变量值为123456
System.out.println("byte型变量money的值："+money);
System.out.println("short型变量money的值："+age);
System.out.println("int型变量money的值："+teacheAge);
System.out.println("long型变量sales的值："+sales);
}
}2. 浮点类型
浮点数类型含float、double
package com.onlyone;
public class decimal{//浮点类型
public static void main(String[] args){
float money=1025453.96f;//定义一个float类型的变量money，变量值为1025453.96
double weight=58.123;//定义一个double类型的变量weight，变量值为58.123
System.out.println("资产为"+money);
System.out.println("体重为"+weight);
}
}
3. boolean型
package com.onlyone;
public class boo {//boolean型
public static void main(String[] args){
boolean boo = true;//只有true和false两种结果
System.out.println("boo的值为"+boo);
}
}
4.字符型
package com.onlyone;
public class character{//字符型
public static void main(String[] args) {
char sex='男';
System.out.println("性别为"+sex);
}
}
四.常量与变量及注释的用法
1.常量定义
用final来定义，形式就是为final int AGE = 34;一般我们用全大写来表示这个是常量。
常量在程序运行时是不能被修改的，在 Java 中使用 final 关键字来修饰常量。
package com.onlyone;
import java.security.AlgorithmParameterGenerator;
public class constant {//常量
public static void main(String[] args) {
final int AGE = 34;
//定义一个int型的局部常量AGE，值为34，大写。值不能改变。
System.out.println("年龄为:"+AGE);
}
}2.变量定义
有全局变量和局部变量，一开始做简单了解即可
static int Age=23;//全局变量格式，
int age=23;//局部变量必须手动赋值，因为局部变量用来临时保存数据（在类的方法中定义），只能在当前方法中使用，没有初始值，所以必须赋值，在该方法当中不可以出现拥有相同名称的局部变量
package com.onlyone;
public class variable {//变量
static int Age=23;//全局变量
public static void main(String[] args){
//定义一个表示年龄的变量age，值为23
int age=23;//局部变量必须手动赋值
//有实际意义
//改变变量age的值
age=31;
Age=24;
System.out.println("年龄为:"+age);
System.out.println("年龄为:"+Age);
}
}
3.注释写法
有两种写法
第一种可以写多行的，在/*与*/之间写注释，一般用在类、方法和变量上面，用来描述其作用。
第二种在//后面写注释
package com.onlyone;
/**
* @Aron 表示人名
* @since 2024.1.3 时间
* @version 版本
*/
public class explanatory {//注释的用法
public static void main(String[] args){
//定义一个变量age1，值为34；
byte age1=34;
//定义一个变量age2，值为22；
byte age2=22;//
/*
定义一个变量age1，值为34；
定义一个变量age2，值为22；
*/
}
}
五.算术运算符
包含+， -， * ，/ ，%， ++， --
全部运算综合到了一个代码中，大家可以看看
public class arithemetic {
public static void main(String[] args){
int num1=46;
int num2=23;
//求和运算
int num3=num1+num2;
System.out.println("两个数的和为:"+num3);
//求差运算
int num4=num1-num2;
System.out.println("两个数的差为:"+num4);
//求积运算
int num5=num1*num2;
System.out.println("两个数的积为:"+num5);
//求商运算
int num6=num1/num2;
System.out.println("两个数的商为:"+num6);
//取模运算
int num7=num1%num2;
System.out.println("两个数的余为:"+num7);
//自增++运算
int sum=11;
sum++;//自增1
System.out.println("sum的值为:"+sum);
//++运算，++在前在后
int sum2=++sum;//++在前：先赋值再++
System.out.println("sum2的值为:"+sum2);
int sum3=sum++;
System.out.println("sum3的值为:"+sum3);
//--运算，--在前在后
int sum4=--sum;
System.out.println("sum4的值为:"+sum4);
int sum5=sum--;
System.out.println("sum5的值为:"+sum5);
int a=11;
//综合运算
int b=--a + a++ + ++a + a--;
int c=--a + ++a + ++a + --a;
System.out.println("b的值为:"+b);
System.out.println("c的值为:"+c);
}
}
六. 关系运算符
1.算数运算符：==，！=， <, >, <=, >=;
public class RelationalOperator {//算数运算符
public static void main(String[] args){
int num1=23;//定义一个int型的变量，值为23
int num2=34;
/*
执行关系运算符
等值判断==
*/
boolean Result1=num1==num2;
System.out.println("==运算的结果为:"+Result1);
/*
执行关系运算符
不等判断!=
*/
boolean Result2=num1!=num2;
System.out.println("!=运算的结果为:"+Result2);
/*
执行关系运算符
大于>
*/
boolean Result3=num1>num2;
System.out.println(">运算的结果为:"+Result3);
/*
执行关系运算符
小于<
*/
boolean Result4=num1<num2;
System.out.println("<运算的结果为:"+Result4);
/*
执行关系运算符
大于>=
*/
boolean Result5=num1<num2;
System.out.println(">=运算的结果为:"+Result5);
/*
执行关系运算符
小于<=
*/
boolean Result6=num1<=num2;
System.out.println("<=运算的结果为:"+Result6);
}
}
2.逻辑运算符：&&, ||, !
public class LogicalOperator {//逻辑运算符
public static void main(String[] args){
int num1=12;
int num2=23;
int num3=31;
//&&运算：两个都为真结果才为真
boolean result1=num1<num2&&num3>num2;
System.out.println("&&运算的结果为:"+result1);
//||运算：只要有一个为真，则结果为真。且若第一个为真，则第二个不进行判断。
boolean result2=num1>num2||num3>num2;
System.out.println("||运算的结果为:"+result2);
//!运算:取反，非0的取！为0，0取！为1；只可能有两个结果1和0；
boolean result3=!(num1<num2);
System.out.println("!运算的结果为:"+result3);
//综合
boolean result4=!(num2<num3||num1>num2)&&num3>num2;
System.out.println("综合运算的结果为:"+result4);
}
}
3.位运算符：&， |
内部其实是转化为二进制数再进行比较的，最后也是内部把得到的二进制数再转化为十进制数再输出的。
public class BitwiseOperator {//位运算符
public static void main(String[] args){
int num1=7;//0111
int num2=9;//1001
//&运算,对应位置都为1，则结果为1；否则都为0。
int result1=num1&num2;
System.out.println("&运算的结果为:"+result1);
//|运算,对应位置都为0，则结果为0；否则都为1。
int result2=num1|num2;
System.out.println("|运算的结果为:"+result2);
//^运算,对应位置相等为0，不等为1
int result3=num1^num2;
System.out.println("^运算的结果为:"+result3);//1110=2+4+8=14
}
}
4.赋值运算符：=， <<=, >>=
<<=与>>=并不难理解，可以看看代码的注释。
举例：
8 << 1的值为8*2=16；
8<< 2的值为8*(2^2)=32；
8 << n的值为8*（2^n）。
public class Assignment {//赋值运算符
public static void main(String[] args){
int num=12;
int num1=12;
num1=num;//=赋值
System.out.println("num1的值为:"+num1);
int num2=12;
num2+=num;//+=赋值
System.out.println("num2的值为:"+num2);
int num3=12;
num3-=num;//-=赋值
System.out.println("num3的值为:"+num3);
int num4=12;
num4*=num;//*=赋值
System.out.println("num4的值为:"+num4);
int num5=12;
num5/=num;///=赋值
System.out.println("num5的值为:"+num5);
int num6=12;
num6%=num;//%=赋值
System.out.println("num6的值为:"+num6);
int num7=8;
int num8=2;
num7<<=num8;//num7=num7<<num8;
System.out.println("num7的值为:"+num7);
// x<<=3等于x=x<<3，x乘以2的3次方，再把值传给x
/*
8 << 1的值为8*2=16；
8 << 2的值为8*(2^2)=32；
8 << n的值为8*（2^n）。
*/
//左移为乘
int num9=8;
int num10=2;
num9>>=num10;//num7=num7>>num8;
System.out.println("num9的值为:"+num9);
//右移为除
/*
8 >> 1的值为8/2=4；
8 >>2的值为8/(2^2)=2；
8 >> n的值为8/（2^n）
*/
}
}
七.类型转换
1.自动类型转换
容量大类型转换不能直接转化到小类型，必须进行强制类型转换
低--------->高（低到高可直接转，高到低必须强制类型转化）
byte,short,char--->int--->long--->float---double
public class automatic {//自动类型转换
public static void main(String[] args) {
//定义一个byte类型的变量，变量值为10
byte by=10;
//定义一个short类型的变量，变量值为20
short sy=20;
//定义一个char类型的变量，变量值为B
char sc='B';
//上面的变量自动转换成int类型
int bi1=by;
int bi2=sy;
int bi3=sc;
System.out.println(bi1+"-->"+bi2+"-->"+bi3);
//上面的变量自动转换成long类型
long li1=by;
long li2=sy;
long li3=sc;
System.out.println(li1+"-->"+li2+"-->"+li3);
//上面的变量自动转换成float类型
float fi1=by;
float fi2=sy;
float fi3=sc;
System.out.println(fi1+"-->"+fi2+"-->"+fi3);
/*
1.boolean不能参与转换
2.容量大类型转换不能直接转化到小类型，必须进行强制类型转换
低--------->高（低到高可直接转，高到低必须强制类型转化）
byte,short,char--->int--->long--->float---double
3.转换过程中可能出现丢失精度或溢出
4.不能把对象类型转成不相关类的对象，不能把Cat类转成Dog类
*/
}
}2.强制类型转换
格式为 ：b = (想要的类型) a;
public class forced {//强制类型转换
public static void main(String[] args) {
//定义一个byte类型的变量，变量值为10
byte by = 10;
//定义一个int类型的变量，变量值为20
int sy = 20;
char cy='A';
int my=2;
by=(byte)sy;//强制类型转换
sy=(byte)cy;
my=cy;//cy为cahr自动转int然后赋值给my，不用强制类型转换。
System.out.println("by的值为"+by);
System.out.println("cy的值为"+cy);
System.out.println("sy的值为"+sy);//sy的值是：cy为cahr转byte，是强制转换，结果为65
System.out.println("my的值为"+my);//my的值是：my=cy，cy为cahr转int，是直接转换，结果为65；可以直接输出my=cy，不写 my=(int)cy;
float fe=123.456f;
double de;
de=(double)fe;
System.out.println("fe的值为"+fe);
System.out.println("de的值为"+de);
}
}3.转换其他注意事项
1.boolean不能参与转换
2.转换过程中可能出现丢失精度或溢出
3不能把对象类型转成不相关类的对象，不能把Cat类转成Dog类
八.结束语，环境的搭建的备注（无过程）
java的环境需要自行搭建jdk环境，下载idea和navicat并进行激活，步骤比较繁琐，自己激活的步骤太多，而且比较麻烦，尤其是激活navicat。大家想办法搭建，有时间的话我写一个搭建的博客。
简单的方式就是找到安装包和破译版哈哈哈。
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
