尚硅谷Java零基础入门教程——学习笔记1

尚硅谷Java零基础入门教程——学习笔记1

文章目录

• IT定律之计算机行业发展规律
• 常用的命令行指令
• Java语言概述
• Java基本数据类型转换
• • 基本数据类型转换
  • 强制类型转换
  • • 思考1
    • 思考2
• 运算符
• • “&”和“&&”的区别：
  • “|”和“||”的区别：
  • if()内赋值表达式的取值 true or false?
  • 三元运算符
• 程序流程控制
• • 三种基本流程结构
  • if和switch语句很像，具体什么场景下，应用哪个语句呢？
  • break 与 continue
• 数组
• • 一维数组
  • • 声明：
    • 初始化：
    • 隐式初始化
    • 存储
  • 多维数组
  • • 初始化
    • 存储
    • 练习：杨辉三角
  • Arrays工具类的使用
  • 数组使用中的常见异常

IT定律之计算机行业发展规律

摩尔定律： 当价格不变时，集成电路上可容纳的元器件的数目，约每隔18-24个月便会增加一倍，性能也将提升一倍。换言之，每一美元所能买到的电脑性能，将每隔18-24个月翻一倍以上。
安迪-比尔定律：描述了硬件厂商和软件厂商的关系。以微软为首的软件开发商吃掉硬件提升带来的全部好处，迫使用户更新机器让惠普和戴尔等公司收益，而这些整机生产商再向英特尔这样的半导体厂订货购买新的芯片、同时向外设厂购买新的外设。在这中间，各家的利润先后得到相应的提升，股票也随着增长。各个硬件半导体和外设公司再将利润投入研发，按照摩尔定律制定的速度，提升硬件的性能，为微软下一步更新软件、吃掉硬件性能做准备。
反摩尔定律：如果你反过来看摩尔定律，一个IT公司如果今天和18个月前卖掉同样多的、同样的产品，它的营业额就要降一半。反摩尔定律对于所有的IT公司来讲，都是非常可怕的，因为一个IT公司花了同样的劳动，却只得到以前一半的收入。反摩尔定律逼着所有的硬件设备公司必须赶上摩尔定律所规定的更新速度，而所有的硬件和设备生产厂活得都是非常辛苦的。

常用的命令行指令

进入d盘：d:
进入目录：cd / cd + 路径
退出目录：cd… / cd/
创建目录：mk 目录名
创建文件：echo >1.doc (创建1.doc文件)
删除文件： del 1.doc / del *.txt（删除txt格式的所有文件）
删除目录： rd 目录名(rd的保证目录是空的) / del 目录名(删除该目录下所有文件)

Java语言概述

Java是一个纯粹的面向对象的程序设计语言，它继承了C++语言面向对象技术的核心。Java舍弃了C语言中容易引起错误的指针（以引用取代）、运算符重载（operator overloading）、多重继承（以接口取代）等特性，增加了垃圾回收器功能用于回收不再被引用的对象所占据的内存空间。

Java基本数据类型转换 基本数据类型转换

1. 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
2. byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。
3. boolean类型不能与其它数据类型运算。
4. 当把任何基本数据类型的值和字符串(String)进行连接运算时(+)，基本数据类型的值将自动转化为字符串(String)类型。

强制类型转换

1. 将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符：()，但可能造成精度降低或溢出
2. 通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。如：

String a = “43”; int i = Integer.parseInt(a);

3. boolean类型不可以转换为其它的数据类型。

思考1

s = s + 2; 2是int型，s先转换为int型与2相加，相加结果为int型的3，然而，3不能赋值给short类型的s，因为容量大的数据类型不能自动转换为容量小的数据类型。
s += 2; 编译器自动将+=运算符后面的 *** 作数强制转换为前面变量的类型,所以s+=2不会报错.
同时类似的还有: -= *= /= %=
参考链接

思考2

为什么结果是32 而不是 31呢？
i++ 是i参与运算后，i的值自增1。
因此(n++)中的n参与运算后，扩号里的运算还剩自增运算，n = n+1，此时n=11;
因此，n = 10 + 10 + 12 = 32

运算符 “&”和“&&”的区别：

单&时，左边无论真假，右边都进行运算；
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。

“|”和“||”的区别：

单|时，左边无论真假，右边都进行运算；
双|时，如果左边为假，右边参与运算，如果左边为真，那么右边不参与运算。

if()内赋值表达式的取值 true or false?

赋0为假，非0为真。
true和false在int里分别对应非0和0
if(n = 1) 先执行将1赋值给n，再返回n，判断的是if(n) 为true

三元运算符

（条件表达式?表达式1：表达式2)；
条件表达式为true，运算后的结果是表达式1；为false，运算后的结果是表达式2.
表达式1和表达式2为同种类型。

程序流程控制 三种基本流程结构

1. 顺序结构
   程序从上到下逐行地执行，中间没有任何判断和跳转。
2. 分支结构
   根据条件，选择性地执行某段代码。
   有if…else和switch-case两种分支语句。
3. 循环结构
   根据循环条件，重复性的执行某段代码。
   有while、do…while、for三种循环语句。
   注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。

if和switch语句很像，具体什么场景下，应用哪个语句呢？

• 如果判断的具体数值不多，而且符合byte、short 、char、int、String、枚举等几
  种类型。虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高。
• 其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。
  也就是说，使用switch-case的，都可以改写为if-else。反之不成立。

break 与 continue

• break只能用于switch语句和循环语句中。
• continue 只能用于循环语句中。
• 二者功能类似，但continue是终止本次循环，break是终止本层循环。
• break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。

数组

• 数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
• 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
• 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。

一维数组 声明：

int a[];
int[] a1;
double b[];
String[] c; //引用类型变量数组

Java语言中声明数组时不能指定其长度(数组中元素的数)， 例如： int a[5]; //非法

初始化：

动态初始化：数组声明且为数组元素分配空间与赋值的 *** 作分开进行

int[] arr = new int[3];
arr[0] = 3;
arr[1] = 9;
arr[2] = 8;
//或者
String names[];
names = new String[3];
names[0] = “钱学森”;
names[1] = “邓稼先”;
names[2] = “袁隆平”;

静态初始化：在定义数组的同时就为数组元素分配空间并赋值。

int arr[] = new int[]{ 3, 9, 8};
//或
int[] arr = {3,9,8};
//或
String names[] = {“李四光”,“茅以升”,“华罗庚”}

隐式初始化

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

public class Test {
public static void main(String argv[]){
int a[]= new int[5];
System.out.println(a[3]); //a[3]的默认值为0
}
}

存储

由于数组是申请的一段连续的空间进行存储，只要知道数组的首地址，根据下标，就能找到后面元素的地址。数组的首地址即第一个元素的地址存放在栈里，其余地址存放在堆中。

多维数组

从数组底层的运行机制来看，其实没有多维数组。对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。

初始化

动态初始化：

int[][] arr = new int[3][2];
//或者
int[][] arr = new int[3][];
arr[0] = new int[3]; 
arr[1] = new int[1]; 
arr[2] = new int[2];
//注：
int[][]arr = new int[][3]; //非法

静态初始化：

int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};
/%
第一个一维数组 arr[0] = {3,8,2};
第二个一维数组 arr[1] = {2,7};
第三个一维数组 arr[2] = {9,0,1,6};
%/

注：

• 一维数组：int[] x 或者int x[]
• 二维数组：int[][] y 或者 int[] y[] 或者 int y[][]
• Java中多维数组不必都是规则矩阵形式(锯齿状)

存储

与一维数组一样。数组的首地址存放在栈中，其余地址存放在堆里。

练习：杨辉三角

package my.demo;
import java.util.*;

public class hello {
    public static void main(String[] args) {
        int a[][] = new int[10][];
        for(int i = 0; i < 10; i++) {
            a[i] = new int[i+1];
            for(int j = 0; j < i + 1; j++) {
                if(j == 0 || j == i) {
                    a[i][j] = 1;
                } else {
                    a[i][j] = a[i-1][j-1] + a[i-1][j];
                }
                System.out.print(a[i][j]+" ");
            }
            System.out.println();
        }
    }
 }

Arrays工具类的使用

java.util.Arrays类即为 *** 作数组的工具类，包含了用来 *** 作数组（比如排序和搜索）的各种方法。

1. boolean equals(int[] a,int[] b) 判断两个数组是否相等。
2. String toString(int[] a) 输出数组信息。
3. void fill(int[] a,int val) 将指定值填充到数组之中。
4. void sort(int[] a) 对数组进行排序。
5. int binarySearch(int[] a,int key) 对排序后的数组进行二分法检索指定的值。

数组使用中的常见异常

1. 数组脚标越界异常(ArrayIndexOutOfBoundsException)

int[] arr = new int[2];
System.out.println(arr[2]);
System.out.println(arr[-1]);
//访问到了数组中的不存在的脚标时发生。

2. 空指针异常(NullPointerException)

int[] arr = null;
System.out.println(arr[0]);
//arr引用没有指向实体，却在 *** 作实体中的元素时。