Java 0基础学java第一阶段

最新推荐文章于 2024-04-22 19:23:41 发布

在家啊太认真走

最新推荐文章于 2024-04-22 19:23:41 发布

阅读量797

点赞数 24

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_52374488/article/details/135382192

版权

1.算数运算符：==，！=， <, >, <=, >=;

一.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。大家想办法搭建，有时间的话我写一个搭建的博客。

简单的方式就是找到安装包和破译版哈哈哈。

在家啊太认真走

关注

24
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
Java 0基础学java第一阶段

用final来定义，形式就是为final int AGE = 34;一般我们用全大写来表示这个是常量。常量在程序运行时是不能被修改的，在 Java 中使用 final 关键字来修饰常量。public class constant {//常量//定义一个int型的局部常量AGE，值为34，大写。值不能改变。System.out.println("年龄为:"+AGE);有全局变量和局部变量，一开始做简单了解即可//全局变量格式，int age=23;
复制链接

扫一扫