Java 0 我发4这是最后一次从头Java

作者: 反复练习的阿离很笨吧 | 来源:发表于2019-01-29 21:38 被阅读0次

Java 0 我发4这是最后一次从头Java
从0基础学java，我历经四个月完美蜕变
文章总目录
0基础学java？我用4个月从小白到月薪9000元
Maven打Jar包
Java先驱者发布最新Java全栈面试“秘籍”，助力你吃透Jav
在Alibaba广受喜爱的“Java突击宝典”简直太牛了
SpringBoot项目搭建
0基础学Java，我在尚学堂获得了新的生命力
Java黑魔法之Java Agent[译]

1 计算

1.1 环境

https://eclipse.org
Eclipse是用Java写的，为了能运行Eclipse，还需要Java的运行环境——JRE。这个JRE是从Oracle的网站下载的。
https://www.oracle.com/
workbench进来。
new一个project。
在src里new一个class，class名通常大写。勾上public static void main。
快捷键Alt+/：自动补全代码
System.out.println("我发4这是最后一次从头Java");

1.2 变量

1.2.1 输入

要读到程序的用户的输入，需要先构建一个Scanner的对象，然后让它来做各种形式的读的动作。

package hello;
import java.util.Scanner;
public class Hello {
    public static void main(String[] args) {
        System.out.println("复读机");
        Scanner in=new Scanner(System.in);
        System.out.println(in.nextLine());
    }
}

程序运行结束后，Console里会显示<terminated>
如果程序没有运行结束又新开一个程序，可以在display selected console中看到：

display selected console

有两个hello正在运行
System.out.println("echo"+in.nextLine());用+连接两个字符串
shift 上下键选中
快捷键 Ctrl+/ 注释/取消注释
System.out.println("2+3="+5);
System.out.println("2+3="+(2+3));

1.2.2 变量

然后用变量做各种计算，将结果直接输出或者保存到变量中。

package hello;
import java.util.Scanner;
public class Hello {
    public static void main(String[] args) {
        System.out.println("calcular");
        Scanner in=new Scanner(System.in);
        System.out.println("100-"+in.nextLine()+"="+(100-in.nextInt()));
    }
}
--------------------
calcular
23
23
100-23=77
notice：
1 要输入2个23
2 in.nextLine()和in.nextInt()

1.2.3 赋值

要保存读到的内容，就需要定义各种变量。
int price=in.nextInt();
int price, amount = 100, age;其中price和age未被初始化
final int amount=100;amount将amount定义为常量

package hello;
import java.util.Scanner;
public class Hello {
    public static void main(String[] args) {
        System.out.println("calcular");
        Scanner in=new Scanner(System.in);
        int amount;
        int price;
        amount=in.nextInt();
        price=in.nextInt();
        System.out.println(amount+"-"+price+"="+(amount-price));
    }
}
--------------------
calcular
24 4
24-4=20

1.3 浮点数计算

浮点数
整数和浮点数之间做转换
运算符优先级

2 判断

计算机的智能是建筑在规则的基础上的，让计算机能够判断，就具备了基本的智能。

2.1 比较

package hello;
import java.util.Scanner;
public class Hello {
    public static void main(String[] args) {
//      初始化
        Scanner in=new Scanner(System.in);
        System.out.print("请投币：");
        int amount=in.nextInt();
//      打印车票
        System.out.println("**************");
        System.out.println("***JAVA铁路线***");
        System.out.println("****票价10元****");
        System.out.println("**************");
//      计算并打印找零
        System.out.println("找零："+(amount-10));
    }   
}
--------------------
请投币：5
**************
***JAVA铁路线***
****票价10元****
**************
找零：-5
票价是10，这时候不应该给车票，也不应该找零奇怪的-5

能做判断的基础，是能对数据做比较，比较就是关于两个数据是否相等、谁大谁小的结论。
关系运算：对两个数据之间的关系的计算。
Java提供了六个关系运算符：== != > >= < <=

/*判断两个浮点数的大小应注意*/
        double a;
        double b;
        a=1.0;
        b=0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1;
        System.out.println(a==b);
        System.out.println("a="+a+";b="+b);
        System.out.println(Math.abs(a-b)<1e-6);
--------------------
false
a=1.0;b=0.9999999999999999
true

2.2 判断

if语句，if-else语句
debug：
双击或右键设置断点。点debug小虫，输入input，确定switch到debug界面。
可以看到程序停在断点语句，为绿色标亮。
按step over一句句执行。
右上回到Java界面。
System.exit(0);

2.3 分支

2.3.1嵌套的if

if()
{
  if()
    {
    }
}

else总和最近的那个if匹配

2.3.2 级联的if

if(exp0)
  stl0;
else if(exp1)
  stl1;
else
  stl2;

2.3.3 多路分支

switch(){
case 常量:
  语句
  ...
case 常量:
  语句
  ...
default:
  语句
  ...
}

switch-case：

控制表达式只能是整数型的结果
常量可以是常数，也可以是常数计算的表达式
根据表达式的结果，寻找匹配的case，并执行case后面的语句，一直到break为止
如果所有的case都不匹配，那么就执行default后面的语句；如果没有Default，那么就什么都不做

        Scanner in=new Scanner(System.in);
        int type=in.nextInt();
        switch(type)
        {
        case 1:
        case 2:
            System.out.println("hello");
            break;
        case 3:
            System.out.println("good evening");
        case 4:
            System.out.println("bye");
            break;
        default:
            System.out.println("What?");
            break;

break:

switch语句可以看作是一种基于计算的跳转，计算控制表达式的值后，程序会跳转到相匹配的case（分支标号）处。
分支标号只是说明 switch内部位置的路标，在执行完分支中的最后一条语句后，如果后面没有break，就会顺序执行到下面的case里去，直到遇到一个break，或者switch结束为止。

2.4 判断语句常见错误

忘了大括号
if后面不要加分号
==和=
风格是三观

3 循环

3.1 循环

之前的买票小程序只能买一次程序就结束了，和我们平时使用的买票程序还有很大差距，这时可以用循环语句，可以不断买票。并且加入balance，可以记下投入的金额。

/*自动售票机重复售票*/
package hello;
import java.util.Scanner;
public class Hello {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int balance=0;
        while(true)
        {
            System.out.print("请投币：");
            int amount=in.nextInt();
            balance+=amount;
            if(balance>=10)
            {
                System.out.println("**************");
                System.out.println("***JAVA铁路线***");
                System.out.println("****票价10元****");
                System.out.println("**************");
    
                System.out.println("找零："+(balance-10));
                balance=0;
            }
        }
    }   
}

while条件为TRUE（非0值）时，执行循环体。
while就是循环的if。

/*计算整数的位数*/
package hello;
import java.util.Scanner;
public class Hello {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int amount=in.nextInt();
        int count=0;
        while(amount>0)
        {
            amount/=10;
            count+=1;
        }
        System.out.println("该数字共有"+count+"位");
    }   
}

调试的方法：

用手列表，列出变量的值。
每次做循环的时候都输出一下变量的值。
System.out.println("amount"+amount+"count"+count);
debug。没有前两种直观。

验证：

测试程序常使用边界数据，如有效范围两端的数据、特殊的倍数等
个位数；✔
10；✔
0；//用do-while，先do，会得到一个count=1
负数。//将while(amount>0)改为while(amount!=0)

do-while循环和while循环很像，唯一的区别是我们在循环体执行结束的时候才来判断条件。也就是说，无论如何，循环都会执行至少一遍，然后再来判断条件。
与while循环相同的是，条件满足时执行循环，条件不满足时结束循环。

package hello;
import java.util.Scanner;
public class Hello {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int amount=in.nextInt();
        int count=0;
        do
        {
            amount/=10;
            count+=1;
        }while(amount!=0);
        System.out.println("该数字共有"+count+"位");
    }   
}
注意小细节：do-while结尾时的分号。

3.2 循环的例子

计数循环

/*猜数字游戏*/
package hello;
import java.util.Scanner;
public class Hello {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int number=(int)(Math.random()*100)+1;//[0,1)-->[0,100)-->[1,100]
        int count=0;
        int a;//用户的猜测
        do
        {
            a=in.nextInt();
            count+=1;
            if(a>number)
            {
                System.out.println("偏大");
            }
            else if(a<number)
            {
                System.out.println("偏小");
            }
        }while(a!=number);
        System.out.println("共尝试"+count+"次");
    }   
}

4 循环控制

4.1 for循环

写一个程序：
变量-->算法-->程序

4.2 循环控制

凑硬币：如何用1元、5元、10元和20元凑出给定的金额。-->多重循环

package hello;
import java.util.Scanner;
public class Hello {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int a=in.nextInt();
        OUT:
        for(int one=0;one<=a;one++)
        {
            for(int five=0;five<=a/5;five++)
            {
                for(int ten=0;ten<=a/10;ten++)
                {
                    for(int twenty=0;twenty<=a/20;twenty++)
                    {
                        if(one+five*5+ten*10+twenty*20==a)
                        {
                            System.out.println(one+"张1元，"+five+"张5元，"+ten+"张10元，"+twenty+"张20元");
                            break OUT;                      
                        }
                    }
                }
            }
        }               
    }   
}
退出多重循环的方法：
首先在循环的前面放一个标号来标识循环 label：
带标号的break和continue对那个循环起作用

优先级

4.3 循环的例子

计算1-1/2+1/3-1/4...

package hello;
import java.util.Scanner;
public class Hello {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        double sum=0;
        int sign=1;
        for(int i=1;i<=n;i++)
        {
            sum+=sign*1.0/i;
            sign=-sign;
        }
        System.out.println(sum);
        System.out.printf("%.2f",sum);
    }   
}

也可以分奇偶数来加，也是很简便的方法。
也可以把sign=-sign;写到for(int i=1;i<=n;i++)里：
for(int i=1;i<=n;i++,sign=-sign)其中,在()里用","分隔。
辗转相除法：
1.如果b等于0，计算结束，a就是最大公约数
2.否则，计算a除以b的余数，让a等于b，而b等于那个余数；
3.回到第一步。

package hello;
import java.util.Scanner;
public class Hello {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int a=in.nextInt();
        int b=in.nextInt();
        int aa=a;
        int bb=b;
        while(b!=0)
        {
            int r=a%b;
            System.out.println(a+","+b+","+r);
            a=b;
            b=r;
        }
        System.out.println(aa+"和"+bb+"的最大公约数是"+a);
    }   
}

5 数组

数据可以存放在变量里，每一个变量有一个名字，有一个类型，还有它的生存空间。如果我们需要保存一些相同类型、相似含义、相同生存空间的数据，我们可以用数组来保存这些数据，而不是用很多个独立的变量。数组是长度固定的数据结构，用来存放指定的类型的数据。一个数组里可以有很多个数据，所有的数据的类型都是相同的。

5.1 数组

package hello;
import java.util.Scanner;
public class Hello {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int x=in.nextInt();
        int[] numbers=new int[100];
        double sum=0;
        int cnt=0;
        while(x!=-1)
        {
            numbers[cnt]=x;
            sum+=x;
            cnt++;
            x=in.nextInt();
        }
        if(cnt>0)
        {
            double average=sum/cnt;
            for(int i=0;i<cnt;i++)
            {
                if(numbers[i]>average)
                {
                    System.out.println(numbers[i]);
                }
            }
            System.out.println(sum/cnt);
        }
        
    }   
}

数组是一种容器（放东西的东西），特点是:

其中所有的元素具有相同的数据类型；
一旦创建，不能改变大小
数组中的每个数据叫做元素

定义数组变量
<类型>[] <名字>=new <类型>[元素个数]
int[] grades = new int[100];
double[] averages = new double[20];

·元素个数必须是整数
·元素个数必须给出
·元素个数可以是变量✔

length: 每个数组有一个内部成员length，会告诉你它的元素的数量。

5.2 数组计算

直接初始化数组：

new创建得到的数组会得到默认的0值。
直接用大括号给出数组的所有元素的初始值 int[] scores={87,98,65};（可以用length得到数组的大小）

数组变量：
·数组变量是数组的管理者而非数组本身
·数组必须创建出来然后交给数组变量来管理
·数组变量之间的赋值是管理权限的赋予
·数组变量之间的比较是判断是否管理同一个数组

复制数组
·必须遍历源数组将每个元素逐一拷贝给目的数组

遍历数组

for(int i=0;i<data.length;i++)
{
  if(x==data[i])
    {
      loc=i;
      break;
    }
}

for-each

for(<类型><变量>:<数组>){
  ...
}

素数的例子

5.3 二维数组

int[][] a=new int[3][5]
通常理解为a是一个三行五列的矩阵。

二维数组的遍历
for(int i=0;i<3;i++) {
    for(int j=0;j<5;j++) {
        a[i][j]=i*j;
    }
}

a[i,j]并不存在。

二维数组的初始化
每行一个{}，逗号分隔
int[][] a={
    {1,2,3,4},
    {1,2,3},//最后的逗号可以存在；省略则补零
}

6 使用对象

6.1 字符类型

字符类型char
字母和数字在Unicode表中是顺序排列的，因此可以：

字符计算字符可以做加减
大小写转换 'a'-'A'可以得到两段之间的距离
字符大小比较

6.2 包裹类型

对于基本数据类型，Java提供了对应的包裹(wrap)类型。这些包裹类型将一个基本数据类型的数据转换成对象的形式，从而使得它们可以像对象一样参与运算和传递。下表列出了基本数据类型所对应的包裹类型：

基本类型	包裹类型
boolean	Boolean
char	Character
byte	Byte
short	Shor
int	Integer
long	Long
float	Float
double	Double

除了int和char以外，包裹类型就是把基本类型的名字的第一个字母大写。在Java的系统类库中，所有第一个字母大写的，都是类的名字。

Integer可以像int一样Integer i=1;，也可以Integer i=new Integer(1);，
包裹会自动打包解包。

当需要让一个类或者对象做事情的时候，用.运算符。
Integer.MIN_VALUE
Integer.MAX_VALUE

6.3 字符串

字符串变量String和数组变量类似，它并不存放字符串，不是字符串的所有者，它是字符串的管理者。

Java的字符串还是一种特殊的“不可变”对象，所有的字符串操作都是产生一个新的字符串，而不是对原来的字符串的修改。对这一点的理解颇为重要。

new=创建
String s= new String("a string");
创建了一个String对象，用a string初始化这个对象，创建管理这个对象的变量s，让s管理这个对象。

初始化字符串变量
String s="hello";
编译器帮你创建一个String类的对象交给s来管理。

字符串连接
用加号(+)可以连接两个字符串。
若加号(+)一边是字符串一边不是字符串，会将一边转换成字符串然后做连接。

输入字符串
in.next();读入一个单词（单词的标志是空格，空格包括空格、tab和换行）
in.nextLine();读入一整行

比较两个String（同一个还是相同）

比较是否同一个
if(input=="bye"){
  ...
}

比较内容是否相同
if(input.equals("bye")){
  ...
}

字符串运算

7 函数

7.1 函数定义与调用

Java的函数必须定义在类的内部，成为类的成员。定义一个函数，要像这样写：

<返回类型> <方法名称>(<参数表>) {
    <方法体>
}

返回类型是这个函数运行结束时要返回给调用者的数据的类型，函数可以返回基本数据类型、对象或者void。返回void表示这个函数不返回任何值。函数名称是一个Java名字，一样要遵循和变量一样的命名规则。参数表是0个或1个或多个参数定义，用逗号’,’分隔。

在这个阶段，我们要在所有的函数的返回类型前面加上关键字“static”。static表示这个函数属于这个类，而不属于这个类的任何对象，因此我们才可以不制造这个类的对象，而直接从main()函数中调用它。

7.2 函数参数与函数内的变量

REF：
数组的使用

Java 0 我发4这是最后一次从头Java
1 计算 1.1 环境 https://eclipse.orgEclipse是用Java写的，为了能运行Eclip...
从0基础学java，我历经四个月完美蜕变
从0基础学java，我历经四个月完美蜕变在尚学堂4个月的学习中，作为一个0基础学java的学生，我这完全是一次蜕...
文章总目录
@TOC 文章总目录 ✂ 【java】 ✳ java基础 java基础--(0)--常用命令 java基础--(0...
0基础学java？我用4个月从小白到月薪9000元
0基础学java？我用4个月从小白到月薪9000元 0基础学java？时间匆匆而过，在尚学堂的培训时间已经结束，难...
Maven打Jar包
0、工程样例新建一个如下的Module。 Compute.java： App.java： log4j.prope...
Java先驱者发布最新Java全栈面试“秘籍”，助力你吃透Jav
Java开发圈流传着这样一句话“新款任你发，我用Java8”，Java第八代作为Java历史长河中的一次重大的历史...
在Alibaba广受喜爱的“Java突击宝典”简直太牛了
0-1年：夯实基础 1.Java基础（Java异常分类及处理+Java反射+Java注解+Java内部类+Java...
SpringBoot项目搭建
引言这是笔者第一次使用Spring Boot创建Java Web后台服务，所以会将我从头到尾完成这个项目的过...
0基础学Java，我在尚学堂获得了新的生命力
0基础学Java，我在尚学堂获得了新的生命力现在很多人都对0基础学Java有看法，我只想说0基础学Java怎么了...
Java黑魔法之Java Agent[译]
1. 介绍在这最后一篇教程中我们将来介绍Java agent，这是普通Java开发者的黑魔法。Java agen...