Java技术之程序设计环境

Linux系统

从Java技术笔记下的"资料下载"中下载jdk-8u241-linux-x64.tar.gz
然后上传至服务器

1.如果/usr/lib/下没有java目录,则创建一个
cd /usr/lib
mkdir java
cd /usr/lib/java/
2.移动jdk-8u241-linux-x64.tar.gz至/usr/lib/java/目录下,然后重命名为jdk1.8.0_241.tar.gz
cd
mv jdk-8u241-linux-x64.tar.gz /usr/lib/java/ #移动到java目录
cd /usr/lib/java/
mv jdk-8u241-linux-x64.tar.gz jdk1.8.0_241.tar.gz # 重命名
3.如果没有tar软件,那么先安装
yum install -y tar
4.解压
tar -zxvf jdk1.8.0_241.tar.gz
5.如果没有vim编辑器,则先安装
yum install -y vim
6.编辑器编辑环境变量
vim /etc/profile

# 新增如下内容
export JAVA_HOME=/usr/lib/java/jdk1.8.0_241
export JRE_HOME=${JAVA_HOME}/jre
export CLASSPATH=.:${JAVA_HOME}/lib:${JRE_HOME}/lib
export PATH=${JAVA_HOME}/bin:$PATH

7.执行source命令
source /etc/profile

8.验证java
java
javac
java -version #正常输出版本号,以及上面两个语句不会提示无效命令即可

Windows系统

从Java技术笔记下的"资料下载"中下载jdk-8u241-windows-x64.exe
然后下载至本地电脑任意位置

1.文件的扩展名需要显示出来
Win7设置方式
我的电脑-属性 "隐藏已知文件类型的扩展名"去除选勾

Win10设置方式
此电脑-查看-文件扩展名-勾选

2.先安装软件jdk1.8.0_241.exe

jre的安装可以中断,无需继续安装
确定完整安装路径为C:\Program Files\Java\jdk1.8.0_241
          C:\Program Files\Java\jdk1.8.0_241

3.配置环境变量JAVA_HOME

Win7配置方式
我的电脑-高级系统属性-环境变量

Win10配置方式
此电脑-高级系统属性-环境变量

JAVA_HOME:C:\Program Files\Java\jdk1.8.0_241

4.配置环境变量PATH

Win7配置方式
%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;

Win10配置方式
注意win10是不需要";"间隔
%JAVA_HOME%\bin
%JAVA_HOME%\jre\bin

5.JDK1.6及其以上无需配置CLASS_PATH
6.验证java
win+r #弹出并输入cmd运行
java
javac
java -version #查看jdk版本

Win10/Linux系统执行方式

Win10/Linux系统执行方式
首先验证java环境是否正常,cmd命令执行java和javac命令,以保证能正常使用java环境
1.创建一个txt文件,命名为Note.txt,存放在任意位置,例如存放在C:\java目录下
2.更改文件后缀为java,即Note.java
3.写代码
public class Note {
  public static void main(String[] args) {
    System.out.println("欢迎来到二次猿的世界");
  }
}

4.执行程序
win10系统 使用win+r输入cmd打开cmd命令
Linux系统 shell界面或远程软件使用shell命令

使用编译器编译文件产生字节码文件 javac Note.java
使用JVM读取字节码文件执行程序 java Note

我们可以形象的把编译器比喻成翻译机,翻译成计算机能理解的信息
我们可以形象的把JVM比喻成工厂,翻译后的信息进行加工打包,最后生成最终产品

5.乱码问题

Win10系统 默认文件是ANSI编码,所以需要编辑器也编辑为ANSI编码,例如Notepad++编辑器选择编码-使用ANSI编码
Linux系统 默认文件是UTF-8编码,所以需要编辑器也编辑为UTF-8编码,例如notepadqq编辑器选择编码-使用UTF-8编码

6.解读代码

* public class Note 
public class是固定写法,其中public和class叫关键字,是不能被改变的,Note是类名,必须和文件名一模一样

* public static void
public static void也是固定写法,同理,public和static,void都是关键字,不能被改变

* main
main是方法名,可以自定义,但不考虑重载情况下方法名不能重复,而且在java中默认main方法固定作为程序的入口,所以main也是固定写法,但不是关键字

* String[] args 
String[]是参数类型,args是参数值,一个参数类型对应一个参数值,所以当前main方法的参数个数只有一个

* System.out.println("欢迎来到二次猿的世界");

System.out.println是不能被改变的,是用于输出和打印指定的内容,因此当前要打印的内容为"欢迎来到二次猿的世界"

; 分号用于结束一个完整的Java语句,因此System.out.println("欢迎来到二次猿的世界") 是一个完整的语句
";"也称语句结束符


关于重载和参数类型,参数值的概念,笔记中后面的知识点有介绍
因此我们当前只要知道以下三点
本例中有且只有一个参数类型和对应的参数值
本例中方法名不会重复,有且只有一个main的方法名作为程序的入口
java区分大小写,关键字都是小写,方法名main固定使用

7.Note{...}  main(String[] args){...}


Note{...}  类名后面紧随的"{"作为程序的开始和使用"}"作为程序的结束,类似这种类名后面的完整方括号,我们称为类块

main(String[] args){...} 方法名后面紧随的"{"作为方法的开始和使用"}"作为方法的结束,类似这种方法名后面的完整方括号,我们称为方法块

方括号开始"{“和结束”}"组成块(block),例如类块和方法块

注释

• 单行注释(行注释) //

• 多行注释(块注释) /**…/

• 文档注释 (javadoc注释)/**…*/

/**
 * 文档注释
 *
 * @author  twoapes
 */
public class Circular {//类块开始

    /**
     * 文档注释
     *
     * @param args args参数
     */
    public static void main(String[] args) {//方法块开始
        //单行注释
        /*
       多行注释
        */
        /*
        根据数学逻辑已知公式如下
        已知半径 r
        C=2*π*r Math.PI
        S=π*r*r
        已知直径 d
        C=π*d
        S=π* (d/2)*(d/2)
        d 和 r 的关系
        d=2*r
         */

        double d = 6;//定义一个圆的直径
        double r = d / 2;//定义一个圆的半径
        System.out.println("园的直径d:" + d);//6
        System.out.println("圆的半径r:" + r);//3
        System.out.println("圆的直径和半径关系:d=2*r (" + (d == 2 * r) + ")");//d=2*r 6=2*(6/2)
        final double PI = Math.PI; //π的值,它是-一个常数, final不能写在double后面,定义此值为定值,不能改变
        System.out.println("圆的周长C:" + 2 * PI * r); //2πr
        System.out.println("圆的周长C:" + PI * d);//πd
        System.out.println("圆的面积S:" + PI * r * r); //π*r*r .
        System.out.println("圆的面积S:" + PI * (d / 2) * (d / 2));//π* (d/2)* (d/2)
    }//方法块结束
}//类块结束

通过代码,得到如下信息

- Circular类执行的是一个圆的周长和面积的计算

- r为半径3

- 周长为C,C通过公式计算

- 面积为S,S通过公式计算

通常的

- 文档注释用于类,接口和方法的备注,注解或说明等,适用于javadoc命令生成html信息,多个html使用"chm"格式打包,例如jdk的api文档就是这样生成的

- 单行注释可以在类和方法中使用

- 多行注释可以在类和方法中使用

 注意:单行和多行注释唯一的区别是单行只能注释一行,多行可以注释多行,文档注释是多行注释功能的基础上,用于方法和类的使用说明或备注

包

import java.util.Scanner;

/**
 * 在程序中,为了区分同命名的类,引入包的概念,类似于系统中的文档(文件夹)的概念
 *
 * @author twoapes
 */
public class Note {
    /*
    明确导入:某类单独放在import语句中,例如 import java.util.Scanner; //既单独指定Scanner
    通配导入:是指导入一个包下所有的类,例如 import java.util.*; //既指定util包下所有的类
    隐式导入:java.lang.*或指定的类都是可以不需要显示书写的(这是因为所有的对象的父类都是Object,也就是java.lang.Object,程序中会默认引用)
    无论那种方式导入,都不影响性能
    */

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println(scanner.next());
    }
    
    /*
    indi    个体项目
    包名为indi.发起者名.项目名.模块名....
    onem    单人项目
    包名为onem.发起者名.项目名.模块名....
    pers    个人项目
    包名为pers.个人名.项目名.模块名....
    priv    私有项目
    包名为priv.个人名.项目名.模块名....
    team    团队项目
    包名为team.团队名.项目名.模块名....
    com     公司项目
    包名为com.公司名.项目名.模块名....
     */
}

块的风格

行尾风格

public class Note {
    public static void main(String[] args) {
      System.out.println("hello");
    }
}

次行风格

public class Note 
{
    public static void main(String[] args) 
    {
      System.out.println("hello");
    }
}

项目中两个取其中一个,不要同时使用,idea工具中默认使用的是行尾风格
Java API和项目中一般使用行尾风格,C#项目中常使用次行风格,这点要注意

程序设计错误

语法错误

在程序编译时的出错,称为编译错误(compiler error)或语法错误(synetx error)

i=30;//编译出错:ShowSyntaxErrors.java: The program contains syntax errors
System.out.println("i:"+i) ;//未声明变量直接使用,此行也会编译报错
//通常一个错误会导致后续的错误,所以必须要规范使用变量

运行错误

//ShowRuntimeErrors.java: Program contains runtime errors
int i=1;
i=1/0;//by /zero
//分母不能为0,程序执行后如果除数为0会报错 

逻辑错误

逻辑错误也叫小虫子(bug),查找和纠正的过程称为调试(debugging)

int r=3;
int S=(int) (Math.PI*r*r);//计算圆的面积,此方式不会编译报错也不会运行报错,但很明显,面积只能得到一个整数,当然这不是我们想要的结果

调试

调试可以手动跟踪(hand trace),一般采用缩减问题范围,最终确定问题根源
手动跟踪也就是说读懂代码,读透代码意思,然后分析问题所在,也可以通过打印语句的方式

工具会自带调试,大部分较困难,手动跟踪无果的情况下才会去使用,简单的都可以通过手动跟踪去排查和分析问题

public class Note {
    public static void main(String[] args) {
        //通过工具的行号间隙位置左击鼠标,左侧标签便出现断点,我们再通过运行Debug的图标的按钮执行调试
        //常使用F8快捷键一步一步调试
        //例如以下代码中输出面积的结果是错误的,通常可以通过手动跟踪,即代码分析,修复此问题,也可以通过工具的调试功能判断哪一步的问题
        double d = 6.3;
        double r = d / 2;
        final double PI = Math.PI;
        System.out.println("圆的面积S:" + PI * r * r);
        //System.out.println("圆的面积S:" + PI * d * r / 4);
        //通过上面代码明显下面的PI * d * r / 4结果不正确
        //我们通过PI*直径*直径/4,直径为d,所以判断上面语句是误把r当成了直径,所以我们做如下修改
        System.out.println("圆的面积S:" + PI * d * d / 4);//把半径r修改成直径d,然后执行,此时如果确保没问题,那么可以放开断点
        //结果正确,此整个过程就是代码的调试
    }
}

Java版本

JSE,JDK,JRE

Java SE(Java Standard Edition）

Java开发工具包(Java Development Toolkit,JDK)

Java运行环境(Java Runtime Environment)

Java虚拟机(Java Virtual Machine)

版本

Java标准版(Java Standard Edition,Java SE)

Java企业版(Java Enterprise Edition,Java EE)

Java微型版(Java Micro Edition,Java ME)

简单代码实现

1.打印"欢迎学习Java技术之程序设计环境章节"

public class Note {
    public static void main(String[] args) {
        System.out.println("欢迎学习Java技术之程序设计环境章节");//欢迎学习Java技术之程序设计环境章节
    }
}

2.计算1+2+3+4+5+6+7+8+9的结果

public class Note {
    public static void main(String[] args) {
        System.out.println(1+2+3+4+5+6+7+8+9);//45
    }
}

3.证明π=(1-1/3+1/5-1/7+1/9-1/11+1/13+…)

public class Note {
    public static void main(String[] args) {
        //π=4*(1-1/3+1/5-1/7+1/9-1/11+1/13+...)
        //π=3.1415926535897...
        double PI = 4.0 * (1.0 - 1.0 / 3.0 + 1.0 / 5.0 - 1.0 / 7.0 + 1.0 / 9.0 - 1.0 / 11.0 + 1.0 / 13.0);
        //4.0*(1.0-1.0/3.0) 2.666666666666667
        //4.0*(1.0-1.0/3.0+1.0/5.0) 3.466666666666667
        //4.0*(1.0-1.0/3.0+1.0/5.0-1.0/7.0) 2.8952380952380956
        //4.0*(1.0-1.0/3.0+1.0/5.0-1.0/7.0+1.0/9.0) 3.3396825396825403
        //4.0*(1.0-1.0/3.0+1.0/5.0-1.0/7.0+1.0/9.0-1.0/11.0) 2.9760461760461765
        //4.0*(1.0-1.0/3.0+1.0/5.0-1.0/7.0+1.0/9.0-1.0/11.0+1.0/13.0) 3.2837384837384844
        //.....PI会越来越接近于3.1415926535897...
        System.out.println(PI);

        double sum = 0;
        int index = 0;
        //4.0 * (1.0 - 1.0 / 3.0 + 1.0 / 5.0 - 1.0 / 7.0 + 1.0 / 9.0 - 1.0 / 11.0 + 1.0 / 13.0)  3.2837384837384844
        //假设我们从1.0 - 1.0 / 3.0 + 1.0 / 5.0 - 1.0 / 7.0 + 1.0 / 9.0 - 1.0 / 11.0 + 1.0 / 13.0...+1/999999997-1/999999999 3.141592651589258
        //3.1415926535897与3.141592651589258 相当接近,所以π=4*(1-1/3+1/5-1/7+1/9-1/11+1/13+...)
        //999999999
        for (double i = 1; i <= 999999999; i += 2) {
            index++;
            int fh = index % 2 == 0 ? -1 : 1;
            sum += 1 / i * fh;
            if(i==999999999)
            System.out.println(1 + "/" + i + "*" + fh);
        }

        System.out.println(4 * sum);
    }
}