栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

【哈工大软件构造】学习笔记四 数据类型与类型检验

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

【哈工大软件构造】学习笔记四 数据类型与类型检验

数据类型:一组值以及可以对其执行的操作。分为基本数据类型(小写字母开头)和对象数据类型(大写字母开头)

Object是所有类的父类,有时只能使用可变的数据类型(例如容器中使用.valueOf方法),基本类型对应的对象数据类型如下:

Integer, Long, Byte, Short, Character, Float, Double, Boolean,一般情况下避免使用,会降低性能。

类型转换例子:

int a = (int) 18.7; //a = 18
double a = (double) 2/3; //a = 0.6666...
int a = 18.7; //ERROR
String n = 1; //ERROR
double a = 2/3; //a = 0.0

Java是一种静态类型语言,Python是一种动态类型语言。这里一定要弄清楚它俩的概念,不然容易与动态检查与静态检查弄混。

静态类型语言是指所有的变量在编译时已知,所以编译器能推导出表达式类型,所以就可以在编译阶段进行类型检查的语言。例如a和b都被声明为int,那么编译器知道a + b的类型也是int。

动态类型语言是在运行阶段才进行类型检查的。

静态检查是指在运行前检查bug(最好的检查),动态检查是指在运行时检查bug。还有一种就是不检查。

静态检查:语法错误,类名/函数名错误,参数数目错误,参数类型错误,返回值类型错误。检查静态类型语言时,会进行类型和语法错误的检查,不考虑值;检查动态类型语言时,只检查是否有语法错误。

动态检查:非法的参数值,非法的返回值,越界,空指针。关于值的检查

浮点类型数的特殊值:NaN, POSITIVE_INFINITY, NEGATIVE_INFINITY

下面举几个错误的例子:

		int n = 5;
		if (n)
			n = n + 1;

编译会出现这样的错误:

error: incompatible types: int cannot be converted to boolean
        if (n)
            ^

这就属于静态错误。

        int big = 200000;
		big = big * big;
		System.out.println(big);

这个不仅编译不会报错,运行的时候也不会报错,但是输出的结果是不对的,因为它溢出了,计算机无法检测出来。

		int sum = 0;
		int n = 0;
		int average = sum / n;

 这是0除以0,是很明显的错误,编译阶段依然可以通过,而运行时才会报错,可见静态检查只是对类型的检查,不会检查值是什么,符合就可以。而动态检查就是对值的检查。

下面的例子是一个比较令人困惑的例子。

		double sum = 7;
		double n = 0;
		double average = sum / n;
		System.out.println(average);

 把例子换成了double类型的变量,结果就不同了,原因就在于浮点数中的0在计算机中表示的是无限接近于它的极小的数,所以除以得到无穷。

可变类型和不可变类型的区别在于能否改变变量的值,也就是能否改变变量指向的存储空间中的值。

改变一个变量的意思是把这个变量指向别的存储空间。

而在定义变量时,前面加上关键字final的作用就是使这个变量不可变,由此我们也能够知道,对于不可变类型,例如int,当用final修饰它的时候,在它的作用域之内就是真的不可变了,无法改变值,也不能令它指向其它空间。但用final修饰Integer这种可变类型变量的话,仍然可以改变它的值。

final修饰class的话,就表明这个类无法派生子类;

final修饰一个方法的话,在这个类的子类中,这个方法就无法被重写。

对于不可变的String的更改如下所示

String s = "a";
s = s.concat("b");

对于可变的StringBuilder如下所示:

StringBuilder sb = new StringBuilder("a");
sb.append("b");

通过以上分析,能够看出,不可变类型进行更改时会指向新的存储空间(如果原来的存储空间没有变量指向时,就会被回收),而可变类型会在原来的存储空间内改变值。对于一个存储空间只有一个引用时,这两种方法没有区别,但是如果是有多个引用指向同一空间,差异就出现了。

String s = "a";
s = s.concat("b");
StringBuilder sb = new StringBuilder("a");
sb.append("b");

String t = s;
t = t + "c";
StringBuilder tb = sb;
tb.append("c");

这段代码对应的快照图如下:

以上可以看出,当对t进行更改时,会创建新的拷贝,所以s指向的值不会改变,而对于可变类型,对tb进行更改,由于sb和tb指向同一内存空间,所以引用sb时,它的值也发生了改变。

 所以相对于不可变类型,可变类型至少有以下几条优点:

1. 当频繁修改时,不会产生大量的临时拷贝,就不需要进行垃圾回收,通过最小化拷贝,能够提高效率。

2. 相当于全局变量,它更适合在多个模块之间共享数据

再看一段代码:

String s = " Hello ";
s += " World ";
s.trim();
System.out.println(s);

trim()方法是返回一个去掉空格的副本,通过以上不可变类型的知识可知,s指向的存储空间是不会受到影响的,整个过程产生两个垃圾需要回收,所以快照图如下。

 正所谓我们应当辩证地去看待事物,可变类型同样有很大的缺点:它的安全性很差,比如我们本地的变量如果泄露出去的话,外部模块对其进行更改,我们本地进行引用时同样会改变。同时多个引用交错使用,会让我们更难理解程序的真实意图是什么,也就更难实现规约。

 下面看两个例子

(1)先看这段代码:

public static int sum(Listlist){
    int sum = 0;
    for(int x : list)
        sum += x;
    return sum;
}


public static int sumAbsolute(List list) {
// let's reuse sum(),because DRY,so first we take absolute values 
    for(int i= 0; imyData=Arrays.asList(-5,-3,-2);
    System.out.println(sumAbsolute(myData));
    System.out.println(sum(myData));
}

单独看计算和方法和计算绝对值之和方法都没有任何问题,但是一旦先调用了计算绝对之和方法,其中的Math.abs()方法会把里面的元素改为它的绝对值,并且仍然放在其中,这就导致main函数中的mydata发生改变,进而之后再对其进行其他操作就会出错。这是一个潜在的错误,编译和运行阶段都不会报错,我们很难跟踪与发现。所以在今后的设计中我们尽量不要传递可变对象。

再看另一个例子。首先说明Date是Java中内置的类,是可变类型的。

		
		public static Date startofSpring() {
			if(groundhogAnswer == null) groundhogAnswer = askGroundhog();
			return groundhogAnswer;
		}
		private static Date groundhogAnswer = null;
		// somewhere else in the code... 
		public static void partyPlanning(){
		// let's have a party one month after spring starts!
			Date partyDate = startOfSpring();
			partyDate.setMonth(partyDate.getMonth()+ 1);
			//... uh-oh. what just happened?
		}

由于startofSpring把现在的日期直接返回给了partyDate变量,这样,当改变partyDate时,groundhogAnswer就也被改变。当以后再访问startofSpring,就会返回April而不是March。快照图如下:

想要使上述问题不在出现,可以通过防御式拷贝,返回给客户端全新的Date对象,这样当客户端对其进行修改时,就不会导致方法出现问题。

return new Date(groundhogAnswer.getTime());

但实际上很多时候客户端不会修改得到的数,这就会造成大量的内存浪费,所有更好的解决办法还是使用不可变类型,这样就不再需要防御式拷贝了。我们应该选择安全地使用可变类型,让它作为局部变量,只有一个引用,不涉及进行共享,这样就解决安全问题。

在这里说一下快照图的概念,它是用来描述程序运行某一时刻的内部状态的图,便于程序员之间的交流,便于刻画各类变量随时间变化,便于解释设计思路。

对于基本类型的值就直接是箭头指向,如下:

如果是对象类型的值,如果指向可变类型,需要用一个椭圆包起来,然后里面的各个域再指向其对应的值,例如一个Point类型的snapshot如下:

如果指向一个不可变类型,椭圆就需要用双线的

除此之外,在以上的基础上,如果是一个不可变的引用,那么就需要采用双线箭头

 

复杂数据类型:数组和容器

数组:

定长数组:

int[] a = new int[100];

动态数组:不能放入基本类型。.get(index), .set(index, value), .size()

List list = new ArrayList<>();

相对于List,Set接口保存的是无序且互异的集合。.contanins(e), .containsAll(s2), .removeAll(s2)

Map接口类似于字典。.put(key, value), .get(key), .containsKey(key), .remove(key)。快照图如下:

 对于List, Set, Map的实现:ArrayList, LinkedList, HashSet, HashMap

并行修改的错误,在遍历时,同时修改index并且删除里面的元素,可能会出现错误,可以使用迭代器的.remove()方法。

不可变的数据类型:基本类型及其封装对象类型,BigInteger,BigDecimal, LocalDateTime, Instant

对于容器类型防止安全泄露的方法,除了防御式拷贝,还可以使用

//分别作为List, Set, Map类型的返回值
Collections.unmodifiableList(list);
Collections.unmodifiableSet(set); 
Collections.unmodifiableMap(map);

这是一种包装器的方法,使得传输出去的容器(注意不是它的副本)只能被看。但缺点是这种“不可变”是在运行阶段获得的,编译阶段无法据此进行静态检查。

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/946334.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号