7-14的学习之路

只强

于 2024-07-14 19:39:36 发布

阅读量482

点赞数 8

文章标签：学习

本文链接：https://blog.csdn.net/anduhongchen/article/details/140418904

版权

一.JDK的配置

配置环境：（环境变量）JAVA_HOME:JDK根路径 Path：系统执行文件所在地址 classpass（现在不需要）右键（此电脑）---属性---高级系统设置--环境变量 java-version

具体操作步骤：这两个是

JDK java开发工具包 java语言开发环境

JRE java程序运行环境只需要运行程序是，可以只安装JRE

JVM java程序虚拟机

我们来操作一下：先找到此电脑，右键属性，找到高级系统设置，这时候会看到用户变量和系统变量，我们先看系统变量，找到原先的JAVA_HOME,然后把他删掉，新建一个JAVA_HOME，变量名是JAVA_HOME,变量值是放JDK的路径。

然后看系统变量中的path，

选中path，点编辑，找到蓝色部分这一条：没有这一条的可以不删，有的话删掉

找到这一条，删掉：

新建一个%JAVA_HOME%\bin,并把它一直上移到最顶端：

然后一直确定就行了。

我们摁开始+r键，输入cmd 输入java -version，如果是以下图片，说明你的jDK配置好了：

我们在写文件的时候，一定要有文件扩展名：

我们把.txt改成.java,并且写一个代码：

按照此操作，会看到：

javac 编译将.java文件编译成.class文件 class文件又叫做字节码文件

java 类名运行指定类 JVM解析字节码文件编程系统（WINS）指令

java跨平台性:JVM将字节码内容解析成系统执行和系统交互，在不同的系统上交互，在不同的系统上安装不同版本的虚拟机，就可以执行字节码文件。

二.下载idea或eclipse

三.变量，常量，命名规范，基本数据类型

class 类名{} 类结构
一个.java文件中只能有一个public外部类
这个public类必须和文件名一样
注释：
// 单行注释    只能注释单行的内容
/* 多行注释
 *注释内容
 */
/** */这种是文档注释
声明变量
声明变量的名字和类型
变量：在程序运行阶段，可以发生变化的量
常量：在程序运行阶段，不可以发生变化的量
给变量赋值   初始化：给变量第一次赋值，就叫做初始化
未初始化：从来没有给这个变量赋值 未初始化的变量不可使用
关键字：开发语言中已经内定一些单词，并且赋予了特殊的作用，开发人员只能按照指定的语法进行使用
java中的关键字所有的字母都是小写
标识符：变量名，类名，方法名，参数名，常量名
标识符命名规范:标识符只能有字母，数字，下划线，$和下划线_组成，首字符不能是数字(中文语法上是通过的，但是不允许)
标识符不能是关键字,static不行,_static行
包名：全部小写 类名：首字母大写 常量名：全部大写
尽量使用驼峰命名法，（单词首字母大写）
所有的表示都要见名只意，标识符可以缩写，如果影响到见名知意，就不要缩写

package com.easy;

public class EasyB {
    public static void main(String[] args){
        //java里面的类型，基本数据类型
        /*
        整数类型：byte short int long 默认值为0
        浮点型：float double 默认值是0.0f 0.0
        字符型：char 默认值是
        布尔型：boolean 默认值是false
        整数类型的取值范围（负数二进制算值要反码加1）:
        byte 1个字节
        1个byte里面有8个bit，第一个是符号，后七个是数，对于符号位，0是正数，1是负数   -2^7~2^7-1    -128~127
        short 2个字节 16个二进制位 -2^15~2^15-1
        int 4个字节 32个二进制位 -2^31~2^31-1
        long 8个字节 64个二进制位 -2^63~2^63-1
         */
        /*
        是的，‌二进制负数是用补码表示的。‌在计算机内部，‌负数是通过补码的形式来表示的。‌补码表示法是一种将负数转换为二进制形式的方法，‌它涉及到对正数二进制表示的反转并加1的过程。‌例如，‌-1在计算机中的表示是通过其补码形式，‌即1111 1111。‌这种表示方法不仅适用于-1，‌也适用于所有负数。‌具体来说，‌一个数的原码（‌即其真实的二进制表示）‌通过取反（‌即将每一位上的0变为1，‌1变为0）‌得到反码，‌然后加1得到补码，‌从而实现了负数在计算机中的二进制表示12。‌
这种补码表示法的应用是基于计算机内部对数字的处理方式，‌它允许计算机能够以统一的方式处理正数和负数，‌简化了加减运算的实现。‌通过补码表示法，‌计算机可以更容易地执行加法和减法操作，‌因为减法可以通过加上一个数的补码来实现2。‌
         */
        /*
        float 单精度浮点型 4个字节
        double 双精度浮点型 8个字节 浮点型的默认型
        float,double都比int，long大
         */
        /*
        char 2个字节  0~65535 FFFF
         */
        char c='a';
        /*
        boolean 1/4个字节 true/false 默认值是false，数组按整型保存，不可以和其他类型转换
         */
        boolean b=true;
        boolean[] b_arr={true,false};
        byte num_byte=127;
        short num_short=12;
        int num_int=-23;
        long num_long=23L;//可以表示这是long类型，这加不加都可以
        float num_float=12.3F;
        num_float=(float)12.4;
        double num_double=123.00006;
        //java的基本数据类型
    }

}

四.数据类型转换：

package com.easy;

public class EasyC {
    public static void main(String[] args) {
        //java基本数据类型之间的转换
        //数据类型的转换
        //隐式转换（程序员会自动完成的转换）
        byte numByte=12;
        int numInt=numByte;
        //取值范围小的类型可以自动转换为取值范围大的类型的值
        numInt=128;
        //numByte=numInt;  java: 不兼容的类型: 从int转换到byte可能会有损失
        numByte=(byte)numInt;//这是一种强制类型转换
        System.out.println(numByte);
        //强制类型转换，转换不了的，可以进行一刀切
        //强制类型转换
        float numFloat=12L;//Long也可以
        numFloat=numInt;
        long numLong=1222222222;
        numFloat=numLong;
        numInt=(int) numFloat;
        //强制类型转换，转换不了的，可以进行一刀切
        //整数和字符之间的转换
        numInt='a';
        char numChar=65535;
        numChar='\u0000';//这些零是十六进制
        numChar='\uFFFF';
        //这个反斜线被称为转义符
        numChar='\t';
        numChar='\\';//第一个是转义符，第二个是反斜线
        //boolean类型的值不能和其他类型的值转换
        //numInt=(int)true;强制也不行
        //进制
        //int a=111;这是十进制
        int a=0B111;//这是二进制
        System.out.println(a);
        int b=0111;//这是八进制
        System.out.println(b);
        int c=111;//这是十进制
        int d=0X111;//这是十六进制
        System.out.println(d);
        System.out.println();//这可以无参数，有换行
        System.out.print(12);//这里面必须要有参数
        System.out.print(" ");
        System.out.print(12);
    }
}

这是上面代码的运行结果：

五.数据类型转换的输入输出，扫描器对象

package com.easy;

import java.util.Scanner;

public class EasyD {
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        //扫描器对象
        //System.in 输入流，对象
        System.out.println("请输入一个整数");
        int a=scan.nextInt();
        System.out.println("请输入下一个整数");
        int b=scan.nextInt();
        System.out.println("两个整数之和是："+(a+b));
        scan.close();
    }
}

这是上面代码的运行结果：

到了这里，我们出个题练练：编写一个测试类，在主方法中编写程序在控制台输入一个整数，将这个整数转换成一个字符，然后打印出来（字符）

package com.easy;

import java.util.Scanner;

public class EasyE {
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        int b=scan.nextInt();
        System.out.println(b);
        char e=(char)b;
        char c='b';
        int o=c;
        System.out.println(o);
        char f=66;
        System.out.println(e);
        System.out.println(f);
        scan.close();
    }
}

运行结果：

六.运算符

package com.easy;

public class EasyF {
    public static void main(String[] args) {
        //运算符
        // +-*/%
        int a=12;
        int b=23;
        System.out.println(a+b);
        int c=a+b;
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/b);
        System.out.println(a%b);
        //整数与整数的运算得到的结果是整数（int），除非有long类型的参与得到的结果是long类型
        System.out.println("-------------------");
        //%的结果正负，A%B得到的结果正负号和A一样
        System.out.println(12%23);
        System.out.println(12%-23);
        System.out.println(-12%23);
        //a++;a--;++a;--a;一元运算符
        a=12;
        a++;//类似于a=a+1;
        System.out.println();
        byte d=1;
        c=d++;
        System.out.println(c);
        //d=d+1; java: 不兼容的类型: 从int转换到byte可能会有损失.整数与整数的运算得到的结果是整数(int)
        //a++在a变量原始基础上加1
        //a--在a变量原始基础上减1
        c=a+b;
        c=a++;
        //a++ ++a
        System.out.println(a);
        System.out.println(c);
        System.out.println("--------------");
        a=12;
        System.out.println(c);
        System.out.println(a);
        c=a++;//a++ 是属于后++，先将a的值付给表达式，然后a的值加1。
        c=++a;//++a 是属于前++，先a+1，再将a的值付给表达式。
        System.out.println(c);
        System.out.println(a);
    }
}

运行结果：

这里要注意细节：1.整数与整数的运算得到的结果是整数（int），除非有long类型的参与得到的结果是long类型。

2.%的结果正负，A%B得到的结果正负号和A一样。

我出个题考考大家：

/*
int i=1, j=2;
int k = i++ + ++i +j++ + ++j;
以上代码执行完成后，i,j,k分别是多
*/

package com.easy;

public class EasyG {
    public static void main(String[] args) {
        int i=1, j=2;
        int k = i++ + ++i +j++ + ++j;
        System.out.println(i);
        System.out.println(j);
        System.out.println(k);
    }
}

这些是一些逻辑运算符：

package com.easy;

import com.sun.corba.se.impl.encoding.CDROutputObject;

public class EasyH {
    public static void main(String[] args) {
        //比较运算
        //< > >= <= == !=
        System.out.println(12>23);
        System.out.println(12<23);
        //==在基本数据类型中比较的值是否一样,类型就不管了
        System.out.println(12==23);
        System.out.println(12.5==12.5f);
        System.out.println(12!=23);
        /*逻辑运算符 && || !
        &&逻辑与运算符
        ||逻辑或运算符
        !逻辑非运算符
        短路现象
         */
        boolean result=12>23 && 23<45;
        //A&&B A和B都为true结果才为true
        result=12<23||23>34;
        //A||B A和B有一个为true结果就为true
        result=!true;
        //短路现象 多个表达式运算，前面的表达式已经可以明确整个表达式的结果，
        //后面的不需要在运行了
        result=12>23&&23<45;
        int a=0;
        int b=0;
        result=a++>0&&b++>0;
        System.out.println(a+"------"+b);
        a=0;
        b=0;
        result=a++>=0||b++>0;
        System.out.println(a+"------"+b);
    }
}

运行结果：

这里面注意：有一个短路现象，前面的一旦满足，那后面的就不会进行计算了。

七.总结：

Java语言特点(跨平台★):一次编译到处执行,JVM

JDK安装与环境变量配置:JAVA_HOME Path javac(编译器) java 手撕HelloWorld

程序运行过程★★ 源码--javac--字节码文件---java---系统指令

创建Java项目源文件夹 src 包

关键字系统中内定一些特殊含义的单词

标识符(规则和规范★)

变量常量 final 声明类型变量名初始化未初始化

数据类型★ 基本数据类型引用类型

基本数据类型的转换★ 隐式转换强制类型转换

输入输出 Scanner 注意close()

注释单行// 多行/**/ 文档注释/** */

运算符和表达式

算术运算符(前置后置★) +-*/% %正负号优先级 () =

比较运算符(==!=★) ==基本数据类型比较的是值

逻辑运算符(短路★) && || !

至于运算符的优先级，我来给大家来张图：

只强

关注

8
点赞
踩
20

收藏

觉得还不错? 一键收藏
1
评论
7-14的学习之路

我们来操作一下：先找到此电脑，右键属性，找到高级系统设置，这时候会看到用户变量和系统变量，我们先看系统变量，找到原先的JAVA_HOME,然后把他删掉，新建一个JAVA_HOME，变量名是JAVA_HOME,变量值是放JDK的路径。配置环境：（环境变量）JAVA_HOME:JDK根路径 Path：系统执行文件所在地址 classpass（现在不需要）右键（此电脑）---属性---高级系统设置--环境变量 java-version。选中path，点编辑，找到蓝色部分这一条：没有这一条的可以不删，有的话删掉。
复制链接

扫一扫