Java基础学习

https://www.sxt.cn/Java_jQuery_in_action/Java_Multiple_selection_structure.html

inteliJ idea 怎么建立java.class

project–new–module–src–new–javaclass

2.7.3 关系运算符

    关系运算符用来进行比较运算。关系运算的结果是布尔值：true/false；

运算符 含义 示例
== 等于 a==b
!= 不等于 a!=b

大于 a>b
< 小于 a<b
大于或等于 a>=b
<= 小于或等于 a<=b

注意事项

=是赋值运算符，而真正的判断两个操作数是否相等的运算符是==。

==、!= 是所有（基本和引用）数据类型都可以使用

、>=、 <、 <= 仅针对数值类型（byte/short/int/long, float/double。以及char）

逻辑运算符

“+”运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换为字符串然后再进行连接。
int a=12;
System.out.println(“a=”+a);//输出结果: a=12

x ? y : z
其中 x 为 boolean 类型表达式，先计算 x 的值，若为true，则整个运算的结果为表达式 y 的值，否则整个运算结果为表达式 z 的值。
int score = 80;
int x = -100;
String type =score<60?“不及格”:“及格”;
int flag = x > 0 ? 1 : (x == 0 ? 0 : -1);
System.out.println("type= " + type);
System.out.println("flag= "+ flag);

大家不需要去刻意的记优先级，表达式里面优先使用小括号来组织！！

逻辑与、逻辑或、逻辑非的优先级一定要熟悉！（逻辑非>逻辑与>逻辑或）

double x = 3.14;
int nx = (int)x; //值为3
char c = ‘a’;
int d = c+1;
System.out.println(nx);
System.out.println(d);
System.out.println((char)d);

int money = 1000000000; //10亿
int years = 20;
//返回的total是负数，超过了int的范围
int total = moneyyears;
System.out.println(“total=”+total);
//返回的total仍然是负数。默认是int，因此结果会转成int值，再转成long。但是已经发生//了数据丢失
long total1 = moneyyears;
System.out.println(“total1=”+total1);
//返回的total2正确:先将一个因子变成long，整个表达式发生提升。全部用long来计算。
long total2 = money*((long)years);
System.out.println(“total2=”+total2);

使用Scanner获取键盘输
import java.util.Scanner;
public class TestScanner {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println(“请输入名字：”);
String name = scanner.nextLine();
System.out.println(“请输入你的爱好：”);
String favor = scanner.nextLine();
System.out.println(“请输入你的年龄：”);
int age = scanner.nextInt();

    System.out.println("###############");
    System.out.println(name);
    System.out.println(favor);
    System.out.println("来到地球的天数："+age*365);
    System.out.println("离开地球的天数："+(72-age)*365);
     
}

}

System.out.println(“请输入传递的四位数据：”);
int num = scanner.nextInt(); //获得四位数字
int units = num % 10; //求出个位数字
int tens = (num % 100) / 10; //求出十位上的数字
int hundreds = (num % 1000) / 100; //求出百位数字
int thousands = num / 1000; //求出千位数字
本章开始我们需要学习流程控制语句，流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。控制语句分为三类：顺序、选择和循环。
主要的选择结构有：if选择结构和switch多选择结构。有如下结构：

if单选择结构

if-else双选择结构

if-else if-else多选择结构

switch结构

if(布尔表达式){
语句块
}

if(布尔表达式){
语句块1
}else{
语句块2
}

if(布尔表达式1) {
语句块1;
} else if(布尔表达式2) {
语句块2;
}……
else if(布尔表达式n){
语句块n;
} else {
语句块n+1;
}

switch (表达式) {
case 值1:
语句序列1;
[break];
case 值2:
语句序列2;
[break];
… … … … …
[default:
默认语句;]
}

循环结构分两大类，一类是当型，一类是直到型。

当型：

  当布尔表达式条件为true时，反复执行某语句，当布尔表达式的值为false时才停止循环，比如：while与for循环。

直到型：

  先执行某语句， 再判断布尔表达式，如果为true，再执行某语句，如此反复，直到布尔表达式条件为false时才停止循环，比如do-while循环。

while (布尔表达式) {
循环体;
}


while:先判断后执行
dowhile:先执行后判断

for循环

1、语法结构

for (初始表达式; 布尔表达式; 迭代因子) {
      循环体;
}

for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for循环在第一次反复之前要进行初始化，即执行初始表达式;随后，对布尔表达式进行判定，若判定结果为true，则执行循环体，否则，终止循环;最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。

  A. 初始化部分设置循环变量的初值

  B. 条件判断部分为任意布尔表达式

  C. 迭代因子控制循环变量的增减

  for循环在执行条件判定后，先执行的循环体部分，再执行步进。

public class Test10 {
    public static void main(String args[]) {
        int sum = 0;
        //1.求1-100之间的累加和
        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        System.out.println("Sum= " + sum);
        //2.循环输出9-1之间的数
        for(int i=9;i>0;i--){
            System.out.print(i+"、");
        }
        System.out.println();
        //3.输出90-1之间能被3整除的数
        for(int i=90;i>0;i-=3){
            System.out.print(i+"、");
        }
        System.out.println();
    }
}

Java里能用到逗号运算符的地方屈指可数，其中一处就是for循环的控制表达式。在控制表达式的初始化和步进控制部分，我们可以使用一系列由逗号分隔的表达式，而且那些表达式均会独立执行。

public class Test11 {
    public static void main(String[] args) { 
        for(int i = 1, j = i + 10; i < 5; i++, j = i * 2) {
            System.out.println("i= " + i + " j= " + j); 
        } 
    }
}

1. 无论在初始化还是在步进部分，语句都是顺序执行的。

2. 尽管初始化部分可设置任意数量的定义，但都属于同一类型。

3. 约定:只在for语句的控制表达式中写入与循环变量初始化，条件判断和迭代因子相关的表达式。

   初始化部分、条件判断部分和迭代因子可以为空语句，但必须以“;”分开。

public class Test12 {
    public static void main(String[] args) { 
        for ( ; ; ) {    // 无限循环: 相当于 while(true)
            System.out.println("北京尚学堂");
        }
    }
}

编译器将while(true)与for(;;)看作同一回事，都指的是无限循环。
在for语句的初始化部分声明的变量，其作用域为整个for循环体，不能在循环外部使用该变量。

// 用while循环分别计算100以内的奇数及偶数的和，并输出。

public class ketang1 {
    public static void main(String[] args) {
        int i = 1;
        int sum1 = 0;
        int sum2 = 0;
        while (i <= 100) {
            if (i % 2 != 0) {
                sum1 += i;
            }else{
                sum2 += i;
            }
            i++;
        }
        System.out.println("奇数的和为："+sum1);
        System.out.println("偶数的和为："+sum2);
    }
}

2. 用while循环或其他循环输出1-1000之间能被5整除的数，且每行输出5个。

public class ketang2 {
    public static void main(String[] args) {
        int i = 1;
        int j = 0;
        while(i<=1000){
            if(i%5==0) {
                System.out.print(i + "\t");
                j++;
                if (j % 5 == 0) {
                    System.out.println();
                }
            }
            i++;
        }
    }
}

嵌套循环

在一个循环语句内部再嵌套一个或多个循环，称为嵌套循环。while、do-while与for循环可以任意嵌套多层。

public class Test14 {
    public static void main(String args[]) {
        for (int i=1; i <=5; i++) {
            for(int j=1; j<=5; j++){
                System.out.print(i+"  ");
            }
            System.out.println();
        }
    }
}

使用嵌套循环实现九九乘法表

public class Test15 {
    public static void main(String args[]) {
        for (int i = 1; i < 10; i++) { // i是一个乘数
            for (int j = 1; j <= i; j++) { // j是另一个乘数
                System.out.print(j + "*" + i + "=" + (i * j < 10 ? (" " + i * j) : i * j) + "  ");
            }
            System.out.println();
        }
    }
}

break语句和continue语句

在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。

public class Test16 {
    public static void main(String[] args) {
        int total = 0;//定义计数器
        System.out.println("Begin");
        while (true) {
            total++;//每循环一次计数器加1
            int i = (int) Math.round(100 * Math.random());
            //当i等于88时，退出循环
            if (i == 88) {
                break;
            }
        }
        //输出循环的次数
        System.out.println("Game over， used " + total + " times.");
    }

continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。
注意事项

1. continue用在while，do-while中，continue 语句立刻跳到循环首部，越过了当前循环的其余部分。
2. continue用在for循环中，跳到for循环的迭代因子部分。
   ontinue语句：把100~150之间不能被3整除的数输出，并且每行输出5个

public class Test17 {
    public static void main(String[] args) {
        int count = 0;//定义计数器
        for (int i = 100; i < 150; i++) {
            //如果是3的倍数，则跳过本次循环，继续进行下一次循环
            if (i % 3 == 0){
                continue;
            }
            //否则（不是3的倍数），输出该数
            System.out.print(i + "、");
            count++;//没输出一个数，计数器加1
            //根据计数器判断每行是否已经输出了5个数
            if (count % 5 == 0) {
                System.out.println();
            }
        }
    }
}

带标签break和continue：控制嵌套循环跳转(打印101-150之间所有的质数)

public class Test18 {
    public static void main(String args[]) {
        outer: for (int i = 101; i < 150; i++) {
            for (int j = 2; j < i / 2; j++) {
                if (i % j == 0){
                    continue outer;
                }
            }
            System.out.print(i + "  ");
        }
    }
}

语句块(有时叫做复合语句)，是用花括号扩起的任意数量的简单Java语句。块确定了局部变量的作用域。块中的程序代码，作为一个整体，是要被一起执行的。块可以被嵌套在另一个块中，但是不能在两个嵌套的块内声明同名的变量。语句块可以使用外部的变量，而外部不能使用语句块中定义的变量，因为语句块中定义的变量作用域只限于语句块。

public class Test19 {
    public static void main(String[] args) {
        int n;
        int a;
        {
            int k;
            int n; //编译错误：不能重复定义变量n
        } //变量k的作用域到此为止
    }
}

方法就是一段用来完成特定功能的代码片段，类似于其它语言的函数。

方法用于定义该类或该类的实例的行为特征和功能实现。 方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。
[修饰符1 修饰符2 …] 返回值类型 方法名(形式参数列表){
Java语句；… … …
}
方法的调用方式：

  对象名.方法名(实参列表)

  方法的详细说明

  1. 形式参数：在方法声明时用于接收外界传入的数据。

  2. 实参：调用方法时实际传给方法的数据。

  3. 返回值：方法在执行完毕后返还给调用它的环境的数据。

  4. 返回值类型：事先约定的返回值的数据类型，如无返回值，必须显示指定为为void。

public class Test20 {
    /** main方法：程序的入口 */
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 20;
        //调用求和的方法：将num1与num2的值传给add方法中的n1与n2
        // 求完和后将结果返回，用sum接收结果
        int sum = add(num1, num2);
        System.out.println("sum = " + sum);//输出：sum = 30
        //调用打印的方法：该方法没有返回值
        print();
    }
    /** 求和的方法 */
    public static int add(int n1, int n2) {
        int sum = n1 + n2;
        return sum;//使用return返回计算的结果
    }
    /** 打印的方法 */
    public static void print() {
        System.out.println("北京尚学堂...");
    }
}

注意事项

  1. 实参的数目、数据类型和次序必须和所调用的方法声明的形式参数列表匹配。

  2. return 语句终止方法的运行并指定要返回的数据。

  3. Java中进行方法调用中传递参数时，遵循值传递的原则(传递的都是数据的副本)：

  4. 基本类型传递的是该数据值的copy值。

  5. 引用类型传递的是该对象引用的copy值，但指向的是同一个对象。

方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。 调用时，会根据不同的参数自动匹配对应的方法。

雷区

重载的方法，实际是完全不同的方法，只是名称相同而已!
构成方法重载的条件：

  1.不同的含义：形参类型、形参个数、形参顺序不同

  2.只有返回值不同不构成方法的重载

public class Test21 {
    public static void main(String[] args) {
        System.out.println(add(3, 5));// 8
        System.out.println(add(3, 5, 10));// 18
        System.out.println(add(3.0, 5));// 8.0
        System.out.println(add(3, 5.0));// 8.0
        // 我们已经见过的方法的重载
        System.out.println();// 0个参数
        System.out.println(1);// 参数是1个int
        System.out.println(3.0);// 参数是1个double
    }
    /** 求和的方法 */
    public static int add(int n1, int n2) {
        int sum = n1 + n2;
        return sum;
    }
    // 方法名相同，参数个数不同，构成重载
    public static int add(int n1, int n2, int n3) {
        int sum = n1 + n2 + n3;
        return sum;
    }
    // 方法名相同，参数类型不同，构成重载
    public static double add(double n1, int n2) {
        double sum = n1 + n2;
        return sum;
    }
    // 方法名相同，参数顺序不同，构成重载
    public static double add(int n1, double n2) {
        double sum = n1 + n2;
        return sum;
    }
    //编译错误：只有返回值不同，不构成方法的重载
    public static double add(int n1, int n2) {
        double sum = n1 + n2;
        return sum;
    }
    //编译错误：只有参数名称不同，不构成方法的重载
    public static int add(int n2, int n1) {
        double sum = n1 + n2;         
        return sum;
    }  
}

递归是一种常见的解决问题的方法，即把问题逐渐简单化。递归的基本思想就是“自己调用自己”，一个使用递归技术的方法将会直接或者间接的调用自己。

利用递归可以用简单的程序来解决一些复杂的问题。比如：斐波那契数列的计算、汉诺塔、快排等问题。

递归结构包括两个部分：
1.定义递归头。解答：什么时候不调用自身方法。如果没有头，将陷入死循环，也就是递归的结束条件。
2.递归体。解答：什么时候需要调用自身方法。

public class Test22 {
    public static void main(String[] args) {
        long d1 = System.currentTimeMillis();  
        System.out.printf("%d阶乘的结果:%s%n", 10, factorial(10));
        long d2 = System.currentTimeMillis();
        System.out.printf("递归费时：%s%n", d2-d1);  //耗时：32ms
    }
    /** 求阶乘的方法*/
    static long  factorial(int n){
        if(n==1){//递归头
            return 1;
        }else{//递归体
            return n*factorial(n-1);//n! = n * (n-1)!
        }
    }
}

递归的缺陷

简单的程序是递归的优点之一。但是递归调用会占用大量的系统堆栈，内存耗用多，在递归调用层次多时速度要比循环慢的多，所以在使用递归时要慎重。
比如上面的递归耗时558ms。但是用普通循环的话快得多，如示例3-23所示。

public class Test23 {
    public static void main(String[] args) {
        long d3 = System.currentTimeMillis();
        int a = 10;
        int result = 1;
        while (a > 1) {
            result *= a * (a - 1);
            a -= 2;
        }
        long d4 = System.currentTimeMillis();
        System.out.println(result);
        System.out.printf("普通循环费时：%s%n", d4 - d3);
    }
}

注意事项

任何能用递归解决的问题也能使用迭代解决。当递归方法可以更加自然地反映问题，并且易于理解和调试，并且不强调效率问题时，可以采用递归;

在要求高性能的情况下尽量避免使用递归，递归调用既花时间又耗内存。
面向过程(Procedure Oriented)和面向对象(Object Oriented,OO)都是对软件分析、设计和开发的一种思想,它指导着人们以不同的方式去分析、设计和开发软件。早期先有面向过程思想，随着软件规模的扩大，问题复杂性的提高，面向过程的弊端越来越明显的显示出来，出现了面向对象思想并成为目前主流的方式。两者都贯穿于软件分析、设计和开发各个阶段，对应面向对象就分别称为面向对象分析(OOA)、面向对象设计(OOD)和面向对象编程(OOP)。C语言是一种典型的面向过程语言，Java是一种典型的面向对象语言。

面向对象

面向过程思想思考问题时，我们首先思考“怎么按步骤实现?”并将步骤对应成方法，一步一步，最终完成。 这个适合简单任务，不需要过多协作的情况下。比如，如何开车?我们很容易就列出实现步骤：

1. 发动车 2. 挂挡 3.踩油门 4. 走你

面向过程适合简单、不需要协作的事务。 但是当我们思考比较复杂的问题，比如“如何造车?”，就会发现列出1234这样的步骤，是不可能的。那是因为，造车太复杂，需要很多协作才能完成。此时面向对象思想就应运而生了。

面向对象(Object)思想更契合人的思维模式。我们首先思考的是“怎么设计这个事物?” 比如思考造车，我们就会先思考“车怎么设计?”，而不是“怎么按步骤造车的问题”。这就是思维方式的转变。

一、面向对象思想思考造车，发现车由如下对象组成：

1. 轮胎

2. 发动机

3. 车壳

4. 座椅

5. 挡风玻璃

为了便于协作，我们找轮胎厂完成制造轮胎的步骤，发动机厂完成制造发动机的步骤;这样，发现大家可以同时进行车的制造，最终进行组装，大大提高了效率。但是，具体到轮胎厂的一个流水线操作，仍然是有步骤的，还是离不开面向过程思想!

因此，面向对象可以帮助我们从宏观上把握、从整体上分析整个系统。 但是，具体到实现部分的微观操作(就是一个个方法)，仍然需要面向过程的思路去处理。

我们千万不要把面向过程和面向对象对立起来。他们是相辅相成的。面向对象离不开面向过程!

·面向对象和面向过程的总结

1、都是解决问题的思维方式，都是代码组织的方式。

2、解决简单问题可以使用面向过程

3、解决复杂问题：宏观上使用面向对象把握，微观处理上仍然是面向过程。

· 面向对象思考方式

遇到复杂问题，先从问题中找名词，然后确立这些名词哪些可以作为类，再根据问题需求确定的类的属性和方法，确定类之间的关系。

建议

1.面向对象具有三大特征：封装性、继承性和多态性，而面向过程没有继承性和多态性，并且面向过程的封装只是封装功能，而面向对象可以封装数据和功能。所以面向对象优势更明显。

2.一个经典的比喻：面向对象是盖浇饭、面向过程是蛋炒饭。盖浇饭的好处就是“菜”“饭”分离，从而提高了制作盖浇饭的灵活性。饭不满意就换饭，菜不满意换菜。用软件工程的专业术语就是“可维护性”比较好，“饭” 和“菜”的耦合度比较低。

类：我们叫做class。 对象：我们叫做Object,instance(实例)。以后我们说某个类的对象，某个类的实例。是一样的意思。

总结

1.对象是具体的事物;类是对对象的抽象;

2.类可以看成一类对象的模板，对象可以看成该类的一个具体实例。

3.类是用于描述同一类型的对象的一个抽象概念，类中定义了这一类对象所应具有的共同的属性、方法。

数组

数组的定义

数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引(下标)来访问它们。数组的三个基本特点：

  1. 长度是确定的。数组一旦被创建，它的大小就是不可以改变的。

  2. 其元素必须是相同类型，不允许出现混合类型。

  3. 数组类型可以是任何数据类型，包括基本类型和引用类型。

数组的声明方式有两种(以一维数组为例)
type[] arr_name; //（推荐使用这种方式）
type arr_name[];

创建基本类型一维数组

public class Test {
    public static void main(String args[]) {
        int[] s = null; // 声明数组；
        s = new int[10]; // 给数组分配空间；
        for (int i = 0; i < 10; i++) {
            s[i] = 2 * i + 1;//给数组元素赋值；
            System.out.println(s[i]);
        } 
    }
}

创建引用类型一维数组

class Man{
    private int age;
    private int id;
    public Man(int id,int age) {
        super();
        this.age = age;
        this.id = id;
    }
}
public class AppMain {
    public static void main(String[] args) {
        Man[] mans;  //声明引用类型数组； 
        mans = new Man[10];  //给引用类型数组分配空间；
         
        Man m1 = new Man(1,11);
        Man m2 = new Man(2,22);  
         
        mans[0]=m1;//给引用类型数组元素赋值；
        mans[1]=m2;//给引用类型数组元素赋值；
    }
}

数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。下面针对这三种方式分别讲解。

1. 静态初始化

int[] a = { 1, 2, 3 };// 静态初始化基本类型数组；
Man[] mans = { new Man(1, 1), new Man(2, 2) };// 静态初始化引用类型数组；

2.动态初始化

  数组定义与为数组元素分配空间并赋值的操作分开进行

int[] a1 = new int[2];//动态初始化数组，先分配空间；
a1[0]=1;//给数组元素赋值；
a1[1]=2;//给数组元素赋值；

3.数组的默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

int a2[] = new int[2]; // 默认值：0,0
boolean[] b = new boolean[2]; // 默认值：false,false
String[] s = new String[2]; // 默认值：null, null

数组拷贝

public class Test {
    public static void main(String args[]) {
        String[] s = {"阿里","尚学堂","京东","搜狐","网易"}; 
        String[] sBak = new String[6];
        System.arraycopy(s,0,sBak,0,s.length);
        for (int i = 0; i < sBak.length; i++) {
            System.out.print(sBak[i]+ "\t");
        }
    }
}

JDK提供的java.util.Arrays类，包含了常用的数组操作，方便我们日常开发。Arrays类包含了：排序、查找、填充、打印内容等常见的操作。

import java.util.Arrays;
public class Test {
    public static void main(String args[]) {
        int[] a = { 1, 2 };
        System.out.println(a); // 打印数组引用的值；
        System.out.println(Arrays.toString(a)); // 打印数组元素的值；
    }
}

数组元素的排序

import java.util.Arrays;
public class Test {
    public static void main(String args[]) {
        int[] a = {1,2,323,23,543,12,59};
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

二分法查找

import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        int[] a = {1,2,323,23,543,12,59};
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);   //使用二分法查找，必须先对数组进行排序;
        System.out.println(Arrays.toString(a));
        //返回排序后新的索引位置,若未找到返回负数。
        System.out.println("该元素的索引："+Arrays.binarySearch(a, 12)); 
    }
}

面向对象思考方式

遇到复杂问题，先从问题中找名词，然后确立这些名词哪些可以作为类，再根据问题需求确定的类的属性和方法，确定类之间的关系。

类的定义方式

// 每一个源文件必须有且只有一个public class，并且类名和文件名保持一致！
public class Car { 
}
class Tyre { // 一个Java文件可以同时定义多个class
}
class Engine {
}
class Seat {
}

上面的类定义好后，没有任何的其他信息，就跟我们拿到一张张图纸，但是纸上没有任何信息，这是一个空类，没有任何实际意义。所以，我们需要定义类的具体信息。对于一个类来说，一般有三种常见的成员：属性field、方法method、构造器constructor。这三种成员都可以定义零个或多个

public class SxtStu {
    //属性（成员变量）
    int id;
    String sname;
    int age;  
    //方法
    void study(){
        System.out.println("我正在学习！");
    }  
    //构造方法
   SxtStu(){
   }
}