自学Java从开始到现在(分段0)
本文档面对人群:自学编程者,且已掌握了基础的语言环境配置和基础的eclipse/idea使用.目的:督促自己学习同时结交更多朋友.
第一章节 初识编程语言
在自学Java四个月后,打算写一下年终汇总(正好也到年尾了),虽然说只学Java四个月,但是之前了解其他的编程语言也有一小段的时间了.从开始的HTML到PHP都只是皮毛,(HTML不包括js的话基本上是掌握标签,而逻辑性的交互性的东西很少,交互的东西全在Javascript里面).
<!DOCTYPE html>
<html>
<head>
<title>你好</title>
</head>
<body>
<p>都说冰糖葫芦儿酸,可酸里面它裹着甜.</p>
</body>
</html>
当然,在head中间还有一些插入的meta,js,css.当使用编辑器编辑时(如DW,WebStorm),会自动生成脚手架(类似上方代码没有填充起来的.)在WebStorm中空的html页面输入html:xt然后按TAB即可以生成.
在html中,标签是不难学的,总之是一个熟练的过程,当你打开编辑器,输入那些标签,从陌生变得不耐烦...然后当你研究js后,发现原来前段还可以做那么多事.
后来之所以接触到Java,完全是为了迎合市场需要,虽然年龄大了,但学习编程的心还是很坚定.所以开始了漫漫的自学路,很高兴在这之后遇到了一些同样自学Java的好朋友(有现实中的,有网络上的),
Java中不再仅仅是标签了,内容多而杂,我这里先就整理一些基础.
像PHP和C#语言中一样,输出一句"hello world!"可能是最基础的教程了.
用编辑器新建一个java程序,格式为HelloWorld.java.内容如下:
//class用来定义类,类定义了java中的基本单位
class HelloWorld
{
//main方法(程序入口)
public static void main(String[] args)
{
//输出语句
System.out.println("hello world!");
}
}
当看到这个做为阅读者的你可能觉得难,或者是简单,如果觉得难的话,你就想,这个看起来像公式类的东东,其实是要学习的东西里面最简单最基础的了.所以,你如果还是不懂里面是什么意思,没关系,用最笨的方法去记住它.克服了陌生也就克服了恐惧. 当然你觉得简单,这真是再好不过的,然后如果你对语法有了基础的认识,那最好的办法就是自己去做一下.
把你的这个HelloWorld.java文件放在一个熟悉的硬盘位置,然后使用javac HelloWorld.java去先编译它,后而在同目录下生成了.class文件,而后再使用命令java HelloWorld去执行.
相信之上内容对你来说不算困难,那真是wonderful了.else if 你觉得很困难,是很困难的话,建议你看一下其他入门java的书籍.
第二章 Java史诗
Java是怎么来的?包括"Java"这个名字?
了解一个事物的历史是对这个事物在脑海中建立印象和看法的很重要的手段.
- Java这个名字是Oak更名来的.Oak是之前取的名字.
- 一个叫詹姆斯,高斯林的人和其团队开发了Oak.
- 具体历史enter link description here
这里我们不再深究名字的由来,但可能很有好奇心的朋友会问:"编程语言又是如何来的呢?"这个问题非常棒,"谁是发明了第一句编程语言的人?"诸如此类的问题,我们不再去描述,希望你用Google或百度去解答内心的疑惑!
后来的后来,在人类历史的长河里,诞生了许多对现代计算机贡献出巨大成就的人,例如-图灵.强烈建议大家去了解下图灵到底是何许人物,那么你也就知道,计算机的诞生经历了多么多无法用语言描述的历史.
@(Java相关-Java的出现淘汰了一部分陈旧的编程语言,其很多备受喜爱的特性使之一直延续到现在2017年12月28日 09:27:06)当然Java8中lambda表达式的加入让其更加具备了竞争能力.
什么是Lambda?
关于Lambda表达式在Java8时加入,有人做了测试,速度其实不如老方法快,差距甚至有5倍,而有人觉得这样的"函数式"编程节约了开发时间,但增加了维护成本.(因为Lambda并不是那么易读).
这里我只讨论最适合应用的基础要点.不管Lambda将来会优化还是怎样,总之,要学是必须的,因为在C或者Scale中都存在这么个表达式.
还有一些版本的迭代呢?查看官方的微博.https://blogs.oracle.com/java/
不管是计算机的发展历史还是Java编程语言的发展历史,都是时代进步的产物,当越来越多的年轻人上大学念计算机系,百度阿里巴巴腾讯充斥着你的生活,我们不得不承认,时代变幻得太快.
第三章 怎样去学习Java这门语言?
这里我们讨论的是自学,而在我自学Java(或其它语言)的这段时间,感受颇多.
- 合理安排时间
时间是个坏东西,当你想留住一段美好时光时,往往它走得那么快.在安排好作息时间后,要合理安排学习的时间.虽然学习不能直接给你收入,但投入和回报总会有的.
不要再抱怨"我哪儿有那么多时间学啊!?" - 毅力&恒心&平常心
说起来也怪,单纯去学习一门计算机语言,还要看看西点军校的校规.其实这些是对于面临一些学习上的困难来说的,总觉得自己难以学成,难以理解或者学习资源少.但这些都可能是不存在的.
尤其拿学习资源少这个问题来说,基本上不存在,现在网络上随便搜搜都有一大堆学习资料,而且有成套成套的视频教程.而如果说难以理解或难以学成,首先要自己立志,其次这些问题我们下面会有方法. - 整理自己的学习路线和方法
这一点说起来太重要了,笼统点说就是给自己规划一下学习Java该怎么学,如果你觉得自己找的方向挺适合自己,那最好不过.
路线上来说,从入门的话肯定是走基础的,不管在网上或是java入门书籍上看目录就一清二楚了.
方法呢看自己的学习习惯,简单概括起来就是,"多看,多想,多做,多记".
我学习的时候把这8个汉字写在了一个记录本上,不写这篇PDF都快不知道当时是咋开始学的Java了.一定要记住,又直接又简单的口诀心法:多看,多想,多做,多记. - 多看,多想,多做,多记
重要的事情说三遍,现在剖析下这句口诀:
多看: 看什么?我一般觉得看成品书比较好,尤其纸质版,而且有的书自带视频教学光盘.不过我学的时候看的入门书是一个好同事的<<Java从入门到精通>>第3版,虽然书带光盘,可惜同事给弄丢了.不过我之前学HTML的时候也都早已在各个学习网上找视频查资料过了.所以很多教编程的网站都有资料和视频(B站上面居然很多全套编程视频)
而看视频也好,看书也罢,一定要循序渐进.除非自己早已掌握其中有些技巧.
多想: 除了感叹编程的美妙功能之外,大脑一定要用来思考这句程序是如何执行的,是怎么跟其他的语句配合的.为什么程序规定了这样的写法?怎样才能用更加简练的语句去编写?你肯定很惊讶,做为Java语言的发明者詹姆斯.高斯林曾经也会对<< Effective Java >>这本书情有独钟吧?因为即使他(和其团队)发了这门语言,但有些情况下,他也需要一些更加系统的文字来整理自己的编程思路,唤醒自己的设计构想.
多做: 勤能补拙,熟能生巧,对于锻炼大脑寻找思路一样,想和做往往粘贴在一起才能发挥其最大效用.我做题那会儿经常遇到难解答的时候,然后隔一段儿时间,或者多掌握一些方法技巧,也能慢慢去揭开迷雾,做题除了能真切体会到编程的美妙,更重要的是能培养自己的自信,解决一道难题所掌握的技巧,去攻克另一道难题,如果攻克不了,还要继续了解更多的要点知识.
多记: 上学那会儿老师经常说的一句话"好脑子不如烂笔头",意思是什么大家很明白,这里一定要跟上面三项联系紧密起来,在"看","想","做"的时候要找准一些记忆的标签,段落,感想,去记录.同样的,我这篇文章除了分享学习编程乐趣和经验之外,还可以回顾以往知识,填空补漏.而在代码上,推荐大家使用在线的文档记录模式,例如印象笔记,博客园.一是打字比手写的快,二是手机上也可以浏览,(Ipad,平板等看起来更好).
第四章 8种基本数据类型
作为一门高级程序语言,Java是很健壮和安全的,但没有什么是绝对的.
Java的标签是"面向对象编程",很多的教材里都讲到面向对象怎样和面向过程区分开来,又或者面向对象怎样比面向过程要好得多,其实在我看来,各有所长,Java现在既然取代不了C语言,那C语言肯定有它过人之处,虽然只接触过C#,一星半点那种接触,我们既然要选择学习Java,就不要瞻前顾后老在那里思考什么语言才是最好的,就像一句广告"没有最好,只有更好".
现在看一段代码:
//声明一个int类型的数值10赋值给变量a.
int a = 10;
//声明...int..................b.
int b = 4;
//声明int类型的变量c的值为变量(a+b).
int c = a+b;
作为Java基本数据中整数类型中的代表int,代表了数字类型的数据.
int的取值范围是32位二进制数表示的最小和最大值.这里我们不再讲什么是进制和位数关系了.
这里贴一张图来说明二进制:http://on-img.com/chart_image/5a3d37e3e4b0909c1aa07f47.png
当时做得这个图既绕又繁琐,总之一句话,位数越多的二进制表示的数值的范围越大.
8种基本数据类型
| byte 8位,byte数据类型是8位、有符号的，以二进制补码表示的整数；
| short 16位,short数据类型是16位、有符号的以二进制补码表示的整数;
| int 32位,int数据类型是32位、有符号的以二进制补码表示的整数；
| long 64位,long数据类型是64位、有符号的以二进制补码表示的整数；
| float 32位,float数据类型是单精度、32位、符合IEEE 754标准的浮点数；
| double 64位,double数据类型是双精度、64位、符合IEEE 754标准的浮点数；
| char 16位,char类型是一个单一的16位Unicode字符；
| boolean 没有准确位数指出,这种类型只作为一种标志来记录true/false情况；
具体表示数值最小和最大值可参考这篇博客:http://www.cnblogs.com/ukzq/p/7533164.html 或看下面代码:
public class TestCast
{
public static void main(String[] args)
{
//测试数据类型
//byte short int(Integer) long float double char(Character)
System.out.println("基础类型byte:
"+"二进制位数:"+Byte.SIZE+"
"+"最大值"+Byte.MAX_VALUE+"
"+"最小值"+Byte.MIN_VALUE+"
____");
System.out.println("基础类型short:
"+"二进制位数:"+Short.SIZE+"
"+"最大值"+Short.MAX_VALUE+"
"+"最小值"+Short.MIN_VALUE+"
____");
System.out.println("基础类型int:
"+"二进制位数:"+Integer.SIZE+"
"+"最大值"+Integer.MAX_VALUE+"
"+"最小值"+Integer.MIN_VALUE+"
____");
System.out.println("基础类型long:
"+"二进制位数:"+Long.SIZE+"
"+"最大值"+Long.MAX_VALUE+"
"+"最小值"+Long.MIN_VALUE+"
____");
System.out.println("基础类型float:
"+"二进制位数:"+Float.SIZE+"
"+"最大值"+Float.MAX_VALUE+"
"+"最小值"+Float.MIN_VALUE+"
____");
System.out.println("基础类型double:
"+"二进制位数:"+Double.SIZE+"
"+"最大值"+Double.MAX_VALUE+"
"+"最小值"+Double.MIN_VALUE+"
____");
System.out.println("基础类型char:
"+"二进制位数:"+Character.SIZE+"
"+"最大值"+(int)Character.MAX_VALUE+"
"+"最小值"+(int)Character.MIN_VALUE+"
____");
}
}
博客里和上面代码输出数据的最小和最大值采用了包装类.
Java中类把方法与数据连接在一起,构成了自包含式的处理单元.但在Java中不能定义基本类型对象,为了能将基本类型视为对象进行处理操作,并能连接相关的方法,Java为每个基本类型都提供了包装类,这样便可以把这些基本类型转换为对象来处理了.
Java中可以直接处理基本数据类型,但有些情况需要将其作为对象来处理,这时就需要将其转换为包装类了.
- java.lang 包中 Integer类,Long类,Short类, 分别将基本数据类型 int, long 和 short 封装成一个类. 由于这些类都是 Number 的子类,区别就是分装不同的数据类型, 其包含的方法基本相同.
- Boolean类 将基本类型为 boolean 的值包装在一个对象中.一个 Boolean 类型的对象只包含一个类型为 Boolean 的字段. 此外, 此类还为 boolean 和 String 的相互转换提供了许多方法, 并提供了处理 boolean 时非常有用的其他一些常量和方法.
- Byte类 将基本类型为 byte 的值包装在一个对象中. 一个 Byte类型 的对象只包含一个类型为 byte 的字段. 此外, 该类还为 byte 和 String 的相互转换提供了方法, 并提供了其他一些处理 byte 时非常有用的常量和方法.
- Character类 在对象中包装一个基本类型为 char 的值. 一个 Character类型 的对象只包含类型为 char 的单个字段. 该类提供了几种方法, 以确定字符的类别(大写字母,数字等). 并将字段从大写转换成小写, 反之亦然.
- Double 和 Float 包装类 是对 double, float 基本类型的封装, 它们都是 Number 类的子类, 又都是对小数进行操作, 所以常用方法基本相同. 同样, 该类们还提供多个方法, 可以将 double,float 转换为 String, 将 String 转换为 double,float ,也提供了其他一些处理 double,float 时有用的常量和方法.
- 此外,抽象类Number 是 BigDecimal, BigInteger, Byte, Double, Float, Integer, Long 和 Short 类的父类, Number 的子类必须提供将表示的数值转换为 byte , double , float , int , long 和 short 的方法.例如, doubleValue() 方法返回双精度值, floatValue() 方法返回浮点值.
第五章 变量
在第四章中,我们接触了数据类型,当声明一个数据类型的值时要使用变量.
比如 int number = 123; 这里面int是声明类型, 123是声明的值, 变量名则是number.
java中,变量命名有一定规范.
- 变量采用驼峰命名方法,比如thisNumber, firstNumber, secondVariable, myFirstName.
- 杜绝阿拉伯数字开头,如 int 2 = 2 就是错误的变量命名.中间禁止空格.
- 限制性使用下划线 _ 和 美元字符开头 $ .虽然不报错,但是不是那么友好.
- 可以使用中文,但不提倡. String 你好世界 = "你好世界"; 会有歧义,虽不报错.
//正确的变量命名
int firstNumber = 123;
int mySalary = 6000;
String username = "ukzz";
String myName = "冷锋";
//错误的变量命名
int 2hello = 43;
int h x d = 99;
String 9 = "九";
//不提倡的变量命名方式
int _22 = 22;
int $2 = 332;
String 逗你玩 = "马三立";
变量分为局部和成员变量,还有类变量.
局部变量
- 局部变量声明在方法,构造方法或者语句块中;
- 局部变量在方法,构造方法,或者语句块被执行的时候创建,当它们执行完成后,变量将会被销毁;
- 访问修饰符不能用于局部变量;
- 局部变量只在声明它的方法,构造方法或者语句块中可见;
- 局部变量是在栈上分配的.
- 局部变量没有默认值,所以局部变量被声明后,必须经过初始化,才可以使用.
局部变量实例: (在以下实例中 age 是一个局部变量, 定义在pupAge()方法中,它的作用域就限制在这个方法中.)
public class Test
{
public void pupAge()
{
int age = 0;
age = age + 7;
System.out.println("Puppy age is : " + age);
}
public static void main(String[] args)
{
Test test = new Test();
test.pupAge();
}
}
以上实例编译运行结果为: Puppy age is : 7
实例2( 下面的例子中 age 变量没有初始化, 所以编译时出错)
public class Test
{
public void pupAge()
{
int age;
age = age + 7;
System.out.println("Puppy age is :" + age);
}
public static void main(String[] args)
{
Test test = new Test();
test.pupAge();
}
}
实例变量/同(成员变量)
能够使用private成员变量的地方: 成员函数, 成员初始化赋值.
成员变量一般都声明为private,除非有特殊需求.
- 实例变量声明在一个类中,但在方法,构造方法和语句块之外;
- 当一个对象被实例化之后,每个实例变量的值就跟着确定;
- 实例变量在对象创建的时候创建, 在对象被销毁的时候销毁;
- 实例变量的值应该至少被一个方法,构造方法或者语句块引用, 使得外部能够通过这些方式获取实例变量信息;
- 实例变量可以声明在使用前或者使用后;
- 访问修饰符可以修饰实例变量;
- 实例变量对于类中的方法,构造方法或者语句块是可见的. 一般情况下应该把实例变量设为私有. 通过使用访问修饰符可以使实例变量对子类可见;
- 实例变量具有默认值,数值型变量的默认值是 0, 布尔型变量的默认值是 false, 引用类型变量的默认值是 null, 变量的值可以在声明时指定, 也可以在构造方法中指定.
- 实例变量可以直接通过变量名访问. 但在静态方法以及其他类中, 就应该使用完全限定名 : ObjectReference.VariableName .
实例变量案例:
package com.ykmimi.markgo;
public class Employee {
//这个成员变量对子类可见
public String name;
//私有变量,仅在该类可见
private double salary;
//在构造器中对name赋值
public void setName(String name) {
this.name = name;
}
//设定salary的值
public void setSalary(double salary) {
this.salary = salary;
}
//打印信息
public void printEmp() {
System.out.println("name: " + name);
System.out.println("salary: " + salary);
}
public static void main(String[] args) {
//声明实例对象
Employee empOne = new Employee();
//进行方法调用
//传String 姓名
empOne.setName("ukyo");
//传double 工资
empOne.setSalary(20000);
//打印输出
empOne.printEmp();
}
}
类变量/静态变量
- 类变量也称静态变量,在类中以static关键字声明, 但必须在方法, 构造方法和语句块之外.
- 无论一个类创建了多少个对象, 类只拥有类变量的一份拷贝.
- 静态变量除了被声明为常量外很少使用. 常量是指声明为 public / private , final 和 static 类型的变量. 常量初始化后不可改变.
- 静态变量存储在静态存储区. 经常被声明为常量, 很少单独使用static声明变量.
- 静态变量在程序开始时创建, 在程序结束时销毁.
- 与实例变量具有相似的可见性. 但为了对类的使用者可用, 大多数静态变量声明为 public 类型.
- 默认值和实例变量相似. 数值型变量默认值是0,布尔型默认值是false,引用类型默认值是null. 变量的值可以在声明的时候指定, 也可以在构造方法中指定. 此外, 静态变量还可以在静态语句块中初始化.
- 静态变量可以通过: ClassName.VariableName的方式访问.
- 类变量被声明为public static final类型时, 类变量名称必须使用大写字母. 如果静态变量不是public和final类型, 其命名方式与实例变量以及局部变量的命名方式一致.
静态变量实例:
package com.ykmimi.markgo;
public class Employee2 {
//salary是静态的私有变量
private static double salary;
//DEPARTMENT是一个常量(部门,)
public static final String DEPARTMENT = "Development";
public static void main(String[] args) {
salary = 10000;
System.out.println(DEPARTMENT+" average salary: "+salary);
}
}
注意: 如果其他类想要访问该变量, 可以这样访问: Employee2.DEPARTMENT .
第六章 修饰符
It is only when you are pursued that you become swift.
唯有再被追赶的时候,你才能真正的奔跑.
Java语言提供了很多修饰符,主要分两类:
- 访问修饰符
- 非访问修饰符
修饰符用来定义类, 方法 或 变量, 通常放在语句的最前端.
package com.ykmimi.markgo;
public class ClassName {
// ...
private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 59;
public static void main(String[] args) {
//方法体
}
}
访问控制修饰符
结合上面代码来了解,Java中,可以使用访问控制符来保护对类, 变量, 方法 和 构造方法的访问.
Java支持4种不同的访问权限.
- 默认的,也称为default或friendly, 即不使用任何修饰符.
- 私有的,以private修饰符指定, 在同一类内可见.
- 共有的,以public修饰符指定, 对所有类可见.
- 受保护的,以protected修饰符指定, 对同一包内的类和所有子类可见.
1. 默认访问修饰符-不使用任何关键字
使用默认访问修饰符声明的变量和方法, 对同一包内的类是可见的. 接口里的变量都隐式声明为public static final, 而接口里的方法默认情况下访问权限为 public .
如下示例,变量和方法的声明可以不使用任何修饰符:
String version = "1.91";
boolean isOrder()
{
return true;
}
2. 私有访问修饰符-private
私有访问修饰符是最严格的访问级别, 所以被声明为private的方法, 变量 和 构造方法只能被所属类访问, 并且类和接口不能声明为private.
声明为私有访问类型的变量只能通过类中公共的getter方法被外部类访问.
private访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据.
如下示例,使用了私有访问修饰符:
public class Logger
{
//私有变量format
private String format;
//获取format
public String getFormat()
{
return this.format;
}
//设置format
public void setFormat(String format)
{
this.format = format;
}
}
上面代码中,Logger类中的format变量为私有变量,所以其他类不能直接得到和设置该变量的值, 为了使其他类能够操作该变量, 定义了两个 public 方法: getFormat() 返回format的值 ,和 setFormat(String) 设置format的值.
3.共有/公共访问修饰符-public
被声明为public的类, 方法, 构造方法 和 接口能够被任何其他类访问.
如果几个相互访问的public类分布在不同的包中, 则需要导入相应public类所在的包. 由于类的继承性, 类所有的公有方法和变量都能被其子类继承.
如下示例,使用了公有访问控制:
public static void main(String[] args)
{
//是的,这就是一个main方法 ^^
}
Java程序的main()方法必须设置成公有的,否则, Java解释器将不能运行该类.
4.受保护的访问修饰符-protected
被声明为protected的变量, 方法 和 构造器能被同一个包中的任何其他类访问,也能够被不同包中的子类访问.
protected访问修饰符不能修饰类和接口, 可声明为protected的为方法和成员变量,但是接口的成员方法和成员变量不能声明为protected.
子类能访问protected修饰符声明的方法和变量, 这样就能保护不相关的类使用这些方法和变量导致混乱和BUG.
如下示例父类使用protected访问修饰符, 子类(教程里是重载,应该是重写吧^^)重写了父类的openSpeaker()方法:
class AudioPlayer
{
//父类的openSpeaker(Speaker)
protected boolean openSpeaker(Speaker sp)
{
//实现细节
}
}
class StreamingAudioPlayer
{
//子类的openSpeaker(Speaker)
boolean openSpeaker(Speaker sp)
{
//实现细节
}
}
如果把openSpeaker()方法声明为private, 那么除了AudioPlayer之外的类将不能访问该方法. 如果把openSpeaker()声明为public , 那么所有类都能访问该方法. 如果我们只想让该方法对其所在类的子类可见, 则将该方法声明为 protected .
图中'子父类'应为 子孙类
几句话构建理解:
共有的，全世界共享；
默认的，只属于美国这个地域，权限收缩；
保护的，属于美国这个地域，当然全世界到处跑的美国公民也可以随时使用；
私有的，不好意思，只属于每个美国人民的；
访问控制和继承
请注意以下方法继承的规则:
- 父类中声明为public的方法在子类中也必须为public .
- 父类中声明为protected的方法在子类中要么声明为protected, 要么声明为public , 不能声明为private .
- 父类中默认修饰符声明的方法, 能够在子类中声明为private .
- 父类中声明为private的方法, 不能够被继承.
非访问修饰符
为了实现一些其他的功能,Java也提供了许多非访问修饰符.
- static修饰符, 用来创建类方法和类变量.(静态方法和静态变量)
- final修饰符, 用来修饰类, 方法和变量, final修饰的类不能够被继承, 修饰的方法不能被继承的类重写, 修饰的变量为常量,不可修改.
- abstract修饰符, 用来创建抽象类和抽象方法.(现除了用显性default实现抽象类,其他必须由子类继承且必须实现)
- synchronized和volatile修饰符, 主要用于线程的编程.
static修饰符
- 静态变量:
static关键字用来声明独立于对象的静态变量,无论一个类实例化多少对象, 它的静态变量只有一份拷贝. 静态变量也被称为类变量. 局部变量不能被声明为 static 变量. - 静态方法:
static关键字用来声明独立于对象的静态方法,静态方法不能使用类的非静态变量. 静态方法从参数列表得到数据, 然后计算这些数据.
对类变量和方法的访问可以直接使用classname.variablename和classname.methodname的方式访问.
即类名丶变量名 or 类名丶方法名 (丶 must be . )
如下示例,static修饰符用来创建类方法和类变量:
package com.ykmimi.markgo;
public class InstanceCounter {
private static int numInstances = 0;
protected static int getCount() {
return numInstances;
}
private static void addInstance() {
numInstances++;
}
InstanceCounter() {
InstanceCounter.addInstance();
}
public static void main(String[] args) {
System.out.println("Starting with " +
InstanceCounter.getCount() + "instances");
for (int i = 0; i < 500; i++) {
new InstanceCounter();
System.out.println("Created" + InstanceCounter.getCount() + "instances");
}
}
}
final修饰符
- final变量:
final变量能被显式地初始化并且只能初始化一次. 被声明为final的对象的引用不能指向不同的对象。但是final对象里的数据可以被改变。也就是说final对象的引用不能改变，但是里面的值可以改变。
final修饰符通常和static修饰符一起使用来创建类常量.
示例:
public class Test
{
final int value = 10;
//下面是声明常量的实例
public static final int BOXWIDTH = 6;
static final String TITLE = "Manager";
public void changeValue()
{
value = 12; //将输出一个错误
}
}
- final方法:
类中的final方法可以被子类继承,但是不能被子类修改.
声明final方法的主要目的是防止该方法的内容被修改.
示例:
public class Test
{
public final void changeName()
{
//方法体
}
}
- final类:
final类不能被继承, 没有类能够继承final类的任何特性.
示例:
public final class Test
{
//类体
}
abstract修饰符
抽象类:
抽象类不能用来实例化对象, 声明抽象类的唯一目的是为了将来对该类进行扩充.
一个类不能同时被abstract和final修饰. 如果一个类包含抽象方法, 那么该类一定要声明为抽象类,否则将出现编译错误.
抽象类可以包含抽象方法和非抽象方法.
示例:
abstract class Caravan
{
private double price;
private String model;
private String year;
public abstract void goFast(); //抽象方法
public abstract void changeColor();
}
抽象方法:
抽象方法是一种没有任何实现的方法,该方法的具体实现由子类提供. 抽象方法不能被声明成final和static.
任何继承抽象类的子类必须实现父类的所有抽象方法, 除非该子类也是抽象类.
如果一个类包含若干个抽象方法, 那么该类必须声明为抽象类. 抽象类可以不包含抽象方法.
抽象方法的声明以分号结尾, 例如: public abstract sample();
示例:
public abstract class SuperClass
{
abstract void m(); //抽象方法
}
class SubClass extends SuperClass
{
//实现抽象方法
void m()
{
//...
}
}
synchronized修饰符
synchronized关键字声明的方法同一时间只能被一个线程访问. synchronized修饰符可以应用于四个访问修饰符.
synchronized关键字声明的方法同一时间只能被一个线程访问. synchronized修饰符可以应用于四个访问修饰符.
示例:
public synchronized void showDetails()
{
//...
}
volatile修饰符
volatile修饰的成员变量在每次被线程访问时,都强迫从共享内存中重读该成员变量的值. 而且,当成员变量发生变化时, 强迫线程将变化值回写到共享内存. 这样在任何时刻, 两个不同的线程总是看到某个成员变量的同一个值. 一个volatile对象引用可能是null.
示例:
public class MyRunnable implements Runnable
{
private volatile boolean active;
public void run()
{
active = true;
while(active) //line 1
{
//代码
}
}
public void stop()
{
active = false; // line 2
}
}
一般地,在一个线程中调用run()方法,在另一个线程中调用stop()方法.如果line 1中的active位于缓冲区的值被使用, 那么当把line 2中的active设置成false时, 循环也不会停止.
transient修饰符
序列化的对象包含被transient修饰的实例变量时, java虚拟机(JVM)跳过该特定的变量.知道springboot中@Transient注解的变量有什么不同了吧?
该修饰符包含在定义变量的语句中, 用来预处理类和变量的数据类型.
示例:
public transient int limit = 55; //will not persist
public int b; //will persist
自学Java从开始到现在(分段1)
在今天这个时刻! 列举一下现在学习的状态:
- Eclipse打算弃了,改使用IDEA.
看着IDEA新的界面和使用新的创建编辑等方式模式.百感交集之中不仅找了一大堆IDEA的博客教程. - 注册与登录demo的Ajax后端验证与js的RegExp前端验证版.
当做出RegisterAndLogin的demo后,宝宝心里开心,但宝宝内心深处也知道,这个demo太简陋,连开设自己个人博客都不够用.所以要把js的RegExp前端表单验证和Ajax的后端数据验证加入进去.并将数据库表扩展(性别/生日/个人头像/注册时间/最后登录/......发表的博客/粘贴的图片/) - 一些更好的想法!更好的实践!
刚刚又花了７９大洋买了马克飞象的一年使用,之前一写完mark飞象就习惯ctrl+s,而且编辑页面让人爱不释手...
第七章 Java运算符
这两天把JavaScript简单了解了一下,而这章也将结合JavaScript一起讲述.因为当初网景公司开发JavaScript时()原名livescript),与SUN公司合作开发,最终决定取名叫JavaScript,当然内置的一些关键字与方式方法与java也很多类似之处(不完全相同).
首先我们使用名不见经传的JavaScript(下简称js)做成的两个数相加的代码:
<p>js中的计算 实现加法运算</p>
<p>注意js中小数的计算并不精准!</p>
<script>
function doMath() {
var a = document.getElementById("numberA");
var b = document.getElementById("numberB");
//注意js中小数的计算并不精准!
var A = parseFloat(a.value, 10);
var B = parseFloat(b.value, 10);
var Ai = parseInt(a.value,10);
var Bi = parseInt(b.value,10);
var resultf = A+B;
var resulti = Ai + Bi; //+ 运算符
document.getElementById("demo1").innerHTML = resultf;
document.getElementById("demo2").innerHTML = resulti;
}
</script>
<input type="text" id="numberA">+
<input type="text" id="numberB">
<br/>
<p id="demo1">浮点数计算结果</p>
<p id="demo2">整数计算结果</p>
<button onclick="doMath()">js中的计算</button>
我们看到其中有个注释叫//+ 运算符,实现的就是+法运算,在js与java中,表示算术运算符跟数学课本上的几乎无异:
算术运算符:
实例
下面的简单示例程序演示了算术运算符。复制并粘贴下面的Java程序并保存为Test.java文件，然后编译并运行这个程序：
public class Test {
public static void main(String args[]) {
int a = 10;
int b = 20;
int c = 25;
int d = 25;
System.out.println("a + b = " + (a + b) );
System.out.println("a - b = " + (a - b) );
System.out.println("a * b = " + (a * b) );
System.out.println("b / a = " + (b / a) );
System.out.println("b % a = " + (b % a) );
System.out.println("c % a = " + (c % a) );
System.out.println("a++ = " + (a++) );
System.out.println("a-- = " + (a--) );
// 查看 d++ 与 ++d 的不同
System.out.println("d++ = " + (d++) );
System.out.println("++d = " + (++d) );
}
}
以上实例编译运行结果如下：
a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
a++ = 10
b-- = 11
d++ = 25
++d = 27
关系运算符
下表为Java支持的关系运算符
表格中的实例整数变量A的值为10，变量B的值为20：
实例
下面的简单示例程序演示了关系运算符。复制并粘贴下面的Java程序并保存为Test.java文件，然后编译并运行这个程序：
public class Test {
public static void main(String args[]) {
int a = 10;
int b = 20;
System.out.println("a == b = " + (a == b) );
System.out.println("a != b = " + (a != b) );
System.out.println("a > b = " + (a > b) );
System.out.println("a < b = " + (a < b) ); System.out.println("b >= a = " + (b >= a) );
System.out.println("b <= a = " + (b <= a) ); } }
以上实例编译运行结果如下：
a == b = false
a != b = true
a > b = false
a < b = true b >= a = true
b <= a = false
位运算符
Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。
位运算符作用在所有的位上，并且按位运算。假设a = 60，和b = 13;它们的二进制格式表示将如下：
A = 0011 1100
B = 0000 1101
-----------------
A&b = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011
下表列出了位运算符的基本运算,假设整数变量A的值为60和变量B的值为13：
实例
下面的简单示例程序演示了位运算符。复制并粘贴下面的Java程序并保存为Test.java文件，然后编译并运行这个程序：
public class Test {
public static void main(String args[]) {
int a = 60; /* 60 = 0011 1100 */
int b = 13; /* 13 = 0000 1101 */
int c = 0;
c = a & b; /* 12 = 0000 1100 */
System.out.println("a & b = " + c );
c = a | b; /* 61 = 0011 1101 */
System.out.println("a | b = " + c );
c = a ^ b; /* 49 = 0011 0001 */
System.out.println("a ^ b = " + c );
c = ~a; /*-61 = 1100 0011 */
System.out.println("~a = " + c );
c = a << 2; /* 240 = 1111 0000 */ System.out.println("a << 2 = " + c ); c = a >> 2; /* 215 = 1111 */
System.out.println("a >> 2 = " + c );
c = a >>> 2; /* 215 = 0000 1111 */
System.out.println("a >>> 2 = " + c );
}
}
以上实例编译运行结果如下：
a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240 a >> 15
a >>> 15
逻辑运算符
下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假.
实例
下面的简单示例程序演示了逻辑运算符。复制并粘贴下面的Java程序并保存为Test.java文件，然后编译并运行这个程序：
public class Test {
public static void main(String args[]) {
boolean a = true;
boolean b = false;
System.out.println("a && b = " + (a&&b));
System.out.println("a || b = " + (a||b) );
System.out.println("!(a && b) = " + !(a && b));
}
}
以上实例编译运行结果如下：
a && b = false
a || b = true
!(a && b) = true
赋值运算符
下面是Java语言支持的赋值运算符：
实例
面的简单示例程序演示了赋值运算符。复制并粘贴下面的Java程序并保存为Test.java文件，然后编译并运行这个程序：
public class Test {
public static void main(String args[]) {
int a = 10;
int b = 20;
int c = 0;
c = a + b;
System.out.println("c = a + b = " + c );
c += a ;
System.out.println("c += a = " + c );
c -= a ;
System.out.println("c -= a = " + c );
c *= a ;
System.out.println("c *= a = " + c );
a = 10;
c = 15;
c /= a ;
System.out.println("c /= a = " + c );
a = 10;
c = 15;
c %= a ;
System.out.println("c %= a = " + c );
c <<= 2 ; System.out.println("c <<= 2 = " + c ); c >>= 2 ;
System.out.println("c >>= 2 = " + c );
c >>= 2 ;
System.out.println("c >>= a = " + c );
c &= a ;
System.out.println("c &= 2 = " + c );
c ^= a ;
System.out.println("c ^= a = " + c );
c |= a ;
System.out.println("c |= a = " + c );
}
}
以上实例编译运行结果如下：
c = a + b = 30
c += a = 40
c -= a = 30
c *= a = 300
c /= a = 1
c %= a = 5
c <<= 2 = 20 c >>= 2 = 5
c >>= 2 = 1
c &= a = 0
c ^= a = 10
c |= a = 10
条件运算符/三元/三目运算符（?:）
条件运算符也被称为三元运算符/三目运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。
variable x = (expression) ? value if true : value if false
实例
public class Test {
public static void main(String args[]){
int a , b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " + b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
}
以上实例编译运行结果如下：
Value of b is : 30
Value of b is : 20
instanceOf 运算符
该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。
instanceof运算符使用格式如下：
( Object reference variable ) instanceOf (class/interface type)
如果运算符左侧变量所指的对象，是操作符右侧类或接口(class/interface)的一个对象，那么结果为真。
下面是一个例子：
String name = 'James';
boolean result = name instanceOf String; // 由于name是Strine类型，所以返回真
如果被比较的对象兼容于右侧类型,该运算符仍然返回true。
看下面的例子：
class Vehicle {}
public class Car extends Vehicle {
public static void main(String args[]){
Vehicle a = new Car();
boolean result = a instanceof Car;
System.out.println( result);
}
}
以上实例编译运行结果如下：
true
在js中也有instanceof操作符,不过注意区别of和Of(java中)的大小写.
js中instanceof博客:https://www.cnblogs.com/SourceKing/p/5766210.html
Java运算符优先级
当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中，运算符优先级不同会导致最后得出的结果差别甚大。
例如，（1+3）＋（3+2）*2，这个表达式如果按加号最优先计算，答案就是 18，如果按照乘号最优先，答案则是 14。
再如，x = 7 + 3 * 2;这里x得到13，而不是20，因为乘法运算符比加法运算符有较高的优先级，所以先计算3 * 2得到6，然后再加7。
下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。
第八章 流程语句(循环结构/分支结构)
关于流程语句部分其实是我最喜欢的,因为在没有掌握构造啊,maven啊,spring这些高大上的东西之前,唯一能显得像是你在编程并且挺展示你逻辑性的就是逻辑流程语句了.
关于这部分还有一些流程图,比如:
首先了解下分支结构:
分支结构基本就是if else组成的.包括:
- if
- if, else
- if, else if ,else
- switch
看字母的翻译就能知道,if是如果的意思,else是其余的意思,总体用中文理解就是:如果这样,执行什么操作,不然的话,就执行什么操作.switch是选择开关一样的作用,具体再看下面实例:
if语句的语法如下:
if(布尔表达式)
{
//如果布尔表达式为true将执行的语句
}
上面的代码块很好理解,if(如果)满足了布尔表达式中的判定(true),则执行接下来的语句("{}"括号内).
if...else语句
if语句后面可以跟else语句，当if语句的布尔表达式值为false时，else语句块会被执行。
if(布尔表达式){
//如果布尔表达式的值为true
}else{
//如果布尔表达式的值为false
}
上面的代码就像之前说的,如果if后面的判定为true,则执行它(if)后面的语句,否则(为false时,if后面不成立时),执行else后面的语句块内容.
if...else if...else
if语句后面可以跟elseif…else语句，这种语句可以检测到多种可能的情况。
使用if，else if，else语句的时候，需要注意下面几点：
- if语句至多有1个else语句，else语句在所有的else if语句之后。
- If语句可以有若干个else if语句，它们必须在else语句之前。
- 一旦其中一个else if语句检测为true，其他的else if以及else语句都将跳过执行。
语法:
if(布尔表达式 1){
//如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
//如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
//如果布尔表达式 3的值为true执行代码
}else {
//如果以上布尔表达式都不为true执行代码
}
上面的代码块比较if else语法又多了好多 else if, 而这些 else if 必须在最后的 else 之前.
最后,这些if, if else, if else if else.... 还可以嵌套起来使用.
比如有一个int型数值为10. 对它进行逻辑判断:
int x = 10;
//首先if判断如果x大于0,则进入语句块.
if (x>0)
{
System.out.println("x is bigger than 0.");
//语句块内,再次判定如果x大于5的话,执行语句块内容.
if(x>5)
{
System.out.println("x is bigger than 5.");
}
//如果x等于5...
else if(x==5)
{
System.out.println("x is equal to 5.");
}
//其余(x不等于5,不大于5.即小于5时)
else
{
System.out.println("x is smaller than 5.");
}
}
上面的语句在第一层的if里面嵌套了一组if, else if, else.用来判断x是大概什么范围,当然如果想更准确一些,可以多加一些else if,不过这肯定会是很消耗程序计算时间和内存的,因为要每行去解析else if中的条件.不过幸好在java里好心的Sun公司开发人员给我们提供了switch这个语法.
switch语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
语法:
switch(expression)
{
case value :
//语句
break; //可选
case value :
//语句
break; //可选
//你可以有任意数量的case语句
default : //可选
//语句
}
switch语句有如下规则：
- switch语句中的变量类型只能为byte、short、int或者String,char。
- switch语句可以拥有多个case语句。每个case后面跟一个要比较的值和冒号。
- case语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
- 当变量的值与case语句的值相等时，那么case语句之后的语句开始执行，直到break语句出现才会跳出switch语句。
- 当遇到break语句时，switch语句终止。程序跳转到switch语句后面的语句执行。case语句不必须要包含break语句。如果没有break语句出现，程序会继续执行下一条case语句，直到出现break语句。
- switch语句可以包含一个default分支，该分支必须是switch语句的最后一个分支。default在没有case语句的值和变量值相等的时候执行。default分支不需要break语句。
实例:
public class Test {
public static void main(String args[]){
//char grade = args[0].charAt(0);
char grade = 'C';
System.out.print("你的等级是:");
switch(grade)
{
case 'A' :
System.out.print("优秀");
break;
case 'B' :
case 'C' :
System.out.print("良好");
break;
case 'D' :
System.out.print("及格");
case 'F' :
System.out.print("你需要继续努力");
break;
default :
System.out.print("无效等级");
}
}
}
上面的代码会输出什么呢?仔细想一下,对的没错.因为被switch判定的grade是'C',而判定的case会输出';良好',最后的输出为:
你的等级是:良好
而且,当grade为'B'时,也会输出同样的结果,因为在case 'B' :的后面是没有break的,这种情况被叫做"case穿透".而有些严谨的switch下是要防范这种case穿透的,需要在每个case后面加上break防止出现错误.
我们再来了解下Java 循环结构
顺序结构的程序语句只能被执行一次。如果您想要同样的操作执行多次,，就需要使用循环结构。
Java中有三种主要的循环结构：
- while循环
- do…while循环
- for循环
- 在Java5中引入了一种主要用于数组的增强型for循环。
@(我的第一个笔记本)
while是最基本的循环,它的结构为:
while( 布尔表达式 )
{
//循环内容
}
上面代码,与基本的if结构分支语句不同的是,如果布尔表达式(条件)为true时,则括号中的语句块会一直执行下去...直至计算机内存耗尽或语句中设定退出方式.
举个比较贱的例子:
long a = 10000;
long b = 500000;
while(a>0)
{
a += b;
System.out.println(a);
}
上面代码,因为条件会一直满足,循环将不会停止,且数值占用内存比较多,机器差点的不久后就会内存耗尽然后挂掉.如果想在内存耗尽前让程序停止,可以这样做:
{
a += b;
System.out.println(a);
break; //利用break打破循环 跳出循环语句块
}
do…while循环
- 对于while语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
- do…while循环和while循环相似，不同的是，do…while循环至少会执行一次。
语法:
do
{
//代码语句
}while(布尔表达式);
//执行一次后才进行布尔表达式判定,为false则不再进入循环,为true则继续循环.
注意：布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为true，则语句块一直执行，直到布尔表达式的值为false。
举个栗子
int a = 100;
int b = 20;
do
{
a -= b;
System.out.println(a);
}while(a>100);
上面代码中,会输出一个80,因为do先执行了{}中代码块,而执行到条件(a>100)后会停止do...while循环.
for循环
- 虽然所有循环结构都可以用while或者do...while表示，但Java提供了另一种语句 —— for循环，使一些循环结构变得更加简单。
- for循环执行的次数是在执行前就确定的。
语法格式：
for(初始化; 布尔表达式; 步进){
//代码语句
}
关于for循环有以下几点说明：
- 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
- 然后，检测布尔表达式的值。如果为true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
- 执行一次循环后，更新步进循环控制变量。
- 再次检测布尔表达式。循环执行上面的过程。
实例:
int[] array = {1,5,6,3,2,1,11,45};
for(int i=0;i<array.length;i++)
{
System.out.print(array[i]+" ");
}
以上代码会输出: 1 5 6 3 2 1 11 45
而,还有一个增强for循环也正好适用这种输出,且比使用for循环要简便:
for(声明语句 : 表达式)
{
//代码句子
}
声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
表达式：表达式是要访问的数组名，或者是返回值为数组的方法。
int[] array = {1,5,6,3,2,1,11,45};
for(int everyInt : array)
{
System.out.print(everyInt+" ");
}
上面代码同样输出的是数组array中的每个值,但这个增强for循环与普通for循环是结果相同但用法不同的.因为使用增强for循环时,并不能对数组的内部进行增改.
如下,更换两种for循环的位置,结果是不同的.
int[] array = {1,5,6,3,2,1,11,45};
//增强for循环
for(int everyInt : array)
{
everyInt+=1;
System.out.print(everyInt+" ");
}
System.out.println();
//普通for循环
for(int i=0;i<array.length;i++)
{
array[i]+=1;
System.out.print(array[i]+" ");
}
结果为:
2 6 7 4 3 2 12 46
2 6 7 4 3 2 12 46
变更位置:
int[] array = {1,5,6,3,2,1,11,45};
//普通for循环
for(int i=0;i<array.length;i++)
{
array[i]+=1;
System.out.print(array[i]+" ");
}
System.out.println();
//增强for循环
for(int everyInt : array)
{
everyInt+=1;
System.out.print(everyInt+" ");
}
结果为:
2 6 7 4 3 2 12 46
3 7 8 5 4 3 13 47
本章最后说明一下在分支和循环结构中的两个关键字的用法:
即 break 和 continue
break关键字
break主要用在循环语句或者switch语句中，用来跳出整个语句块。
break跳出最里层的循环，并且继续执行该循环下面的语句。
continue关键字
continue适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
在for循环中，continue语句使程序立即跳转到更新语句。
在while或者do…while循环中，程序立即跳转到布尔表达式的判断语句。
先概览下两者的不同,下面放出实例(每次自己做一些实例来增加自己的复习力度棒棒的)
break: 上面有一个无法停止的循环,我们采取的是使用break,这里加深一下理解.
boolean bl = true;
int count = 0;
while(bl)
{
System.out.print("[循环循环]"+count);
count++;
if(count==5)
{
break;
}
}
上面代码如果不加入break,则会一直输出[循环循环],而加入计数器限制后,只会执行5次循环.对此,我还在IDEA中进行了断点调试,因为count为0时,是会执行第一次:
count=0,输出d1句,count++
count=1,输出d2句,count++
count=2,输出d3句,count++
count=3,输出d4句,count++
count=4,输出d5句,count++,count==5,break打破循环不再输出
注意:这里想更好去理解的话,可以把count初始化为1,在if(count==6)时,break,也就是前5句是输出成功的.
continue: 一句话理解,仅不执行continue在的那次循环.
下面上代码理解:
int[] numbers = {1,3,5,10,12,22,7};
for (int i=0;i<numbers.length;i++)
{
if(numbers[i]%2 == 0)
{
continue;
}
System.out.print(numbers[i]+" ");
}
上面的代码中,声明一个整型数组,有奇数(odd)有偶数(even),我们做了一个if判断来把偶数祛除掉.结果只输出奇数:
1 3 5 7
而,想再单独输出偶数怎么办呢?
int[] numbers = {1, 3, 5, 10, 12, 22, 7};
//声明一个动态数组
ArrayList<Integer> evenNumbers = new ArrayList();
for (int i = 0; i < numbers.length; i++)
{
if (numbers[i] % 2 == 0)
{
evenNumbers.add(numbers[i]);
continue;
}
//循环输出了奇数
System.out.print(numbers[i] + " ");
}
System.out.println();
//遍历输出了偶数
for (int even : evenNumbers)
{
System.out.print(even+" ");
}
结果为:
1 3 5 7
10 12 22
关于break和continue还可以配合标签使用,实现跳转功能,因为不太符合java的本来面目,这里不再记录了!
可以参照这几个博客了解领会:break continue其他用途 | java中continue配合标签进行继续循环
自学Java从开始到现在(分段2)
第九章 包装类
所有的基本类型，都有对应的类类型
比如int对应的类是Integer
这种类就叫做包装类/封装类.
数字封装类有
Byte,Short,Integer,Long,Float,Double
这些类都是抽象类Number的子类
Java Number类
一般地，当需要使用数字的时候，我们通常使用内置的数据类型，如：byte，int，long，double等。
实例：
int i = 5000;
float gpa = 13.65;
byte mask = 0xaf;
然而,在实际开发过程中,我们经常会遇到需要使用对象,而不是内置数据类型的情形.为了解决这个问题,Java语言为每一个内置数据类型提供了对应的包装类.
所有的包装类( Integer, Long, Byte, Double, Float, Short )都是抽象类Number的子类.
这种由编译器特别支持的包装称为装箱,所以当内置数据类型被当作对象使用的时候,编译器会把内置类型装箱为包装类. 相似的,编译器也可以把一个对象拆箱为内置类型. Number类属于java.lang包.
下面是一个装箱与拆箱的例子:
public class Test{
public static void main(String args[]){
Integer x = 5; //装箱为一个Integer对象
x = x + 10; //拆箱Integer为int数据
System.out.println(x);
}
}
以上实例编译运行结果如下:
15
当x被赋为整型值时,由于x是一个对象,所以编译器要对x进行装箱.然后,为了使x能进行加运算,所以要对x进行拆箱.
Number类的成员方法
下面的表中列出的是Number类的方法:
| 序号 | 方法与描述 |
|---|---|
| 1 | xxxValue() 将number对象转换为xxx数据类型的值并返回. |
| 2 | compareTo() 将number对象是否与参数相等. |
| 3 | equals() 判断number对象是否与参数相等. |
| 4 | valueOf() 返回一个Integer对象指定的内置数据类型. |
| 5 | toString() 以字符串形式返回值. |
| 6 | parseInt() 将字符串解析为int类型. |
| 7 | abs() 返回参数的绝对值. |
| 8 | ceil() 对整型变量向左取整,返回类型为double型. |
| 9 |