Java从入门到精通

在编写Java代码时，需要特別注意下列几个关健点：
    (1） Javs中的程序代码可分为结构定义语句和功能执行语句，其中，结均定
   义语句用于声明一个类或方法，功能执行语句用于实现具体的功能。每条功
   能执行语句的最后都必须用分号（；）结束

（2）Java语言严格区分大小写。

（3）出于可读性考虑，编写的程序代码，整齐美观，层次清晰。

（4）一句连续的字符串不能分开两行写

Java中的注释

在编写程序时，为了使代码易于阅读，通常会在实现功能的同时为代码加一些注释。
注释是对程序的某个功能或者某行代码的解释说明，它只在java源文件中有效。在编译程序时编译器会忽略这些注释信息，不会将其编译到class字节码文件中去。
3、java中的标识符

在编程过程中，在程序中定义一些符号来标记一些名称。如，包名、类名、方法名、参数名、 变量名等，这些符号称为标识符。
＞标识符可以由任意顺序的大小写字母、数字、下划线（）和美元符号（$）组成，但不能以数字开头，不能是java中的关健字

＞建议在定义标识符时还应该遵循以下規则：

•1包名所有字母一律小写。
•2类名和接口名每个单词的首字母都要大写。
•3常量名所有字母都大写，单词之间用下划线连接。
• 4变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写。
•5在程序中，应该尽量使用有意义的英文单调来定义标识符。使得程序便于阅读。

4、java中的关键字

 是事先定义好并赋予了特殊含义的单词 

Java中的常量

常量是在程序中固定不变的值，是不能改变的数据。

常量包括，整形常量，浮点型常量，布尔常量，字符常量等。

（1）整形常量： 二进制：由0和1组成的数字序列

                             八进制：以0开头并且其后由0~7范围内的整数组成的数字序列

                             十进制：由数字0~9范围内的整数组成的数字序列，第一位不能是0

                             十六进制：以0x或者0X开头并且其后由0~9、A~F、组成的数字序列

（2）浮点数常量： 单精度浮点float、双精度浮点double

                                单精度浮点数以F或f结尾

                                双精度浮点数以D或d结尾

                               也可以用指数表达

（3）字符常量： 用于表示一个字符，要用' '引起来

                              可以是英文字符、数字、标点符号、转义序列

（4）字符串常量： 用于表示一连串的字符，要用" "引起来

                                        可以包含一个或多个字符，也可以不包含任何字符

（5）布尔常量:两个值：true和false

  (6）null常量:只有一个值null，表示对象的引用为空。
2.变量
1、变量的定义
在程序运行期间，随时可能产生一些临时数据，应用程序会将这些数据保存在一些内存单元中，每个内存单元都用一个标识符来标识。这些内存单元我们称之为变量，定义的标识符就是变量名，
内存单元中存储的数据就是变量的值。整数类型变量
用来存储整数数值，即没有小数部分的值。
整数类型分为4种不同的类型：字节型 （bvte）、短整型 (short)、整型 （int）和长整型 （long)
占用空间指的是不同类型的变量分别占用的内存大小
取值范围是变量存储的值不能超出的范围2、浮点数类型变量：

（1）浮点数类型变量用来存储小数数值。

（2）浮点数类型分为两种：单精度浮点数 (float）、双精度浮点数(double）， double型所表示的浮点数比float型更精确。

（3）在取值范围中，E表示以10为底的指数，E后面的“+”号和“”号代表正指数和负指数，例如1.4E-45表示1.4*10 45.

 3、字符类型变量
＞用于存储一个单一字符，在Java中用char表示。
＞每个char类型的字符变量都会占用2个字节。
＞赋值时，要用英文半角格式的单引号("）把字符括起来，如'a’，
＞也可以赋值为0~65535范围内的整数，计算机会自动将这些整数转
化为所对应的字符。

4、布尔类型变量
＞布尔类型变量用来存储布尔值，在Java中用boolean表示，该类型
的变量只有两个值，即true 和false。

3、变量的类型转换
  当把一种数据类型的值赋给另一种数据类型的变量时，需要进行数据类型转换

  分为：自动类型转换、强制类型转换

（1）自动类型转换：也叫隐式类型转换

        两种数据类型在转换的过程中不需要显式地进行声明

       需要满足两个条件：两种类型彼此兼容  目标类型的取值范围大于原类型的取值范围

强制类型转换

强制类型转换也叫显式类型转换，指的是两种数据类型之间的转换需要进行显式地声明。
当两种类型彼此不兼容，或者目标类型取值范国小于源类型时，自动类型转换无法进行，这时就需要进行强制类型转换

算术运算符(1)在进行自增(++)和自减 (--)的运算时，如果运算符放在操作数的前面则是先进行自增 或自减运算，再进行其它运算。反之，如果运算符放在操作数的后面则是先进行其它运算再进行自增或自减运算。

（2）在进行除法运算时，当除数和被除数都为整数时，得到的结果也是一个整数。如果 除法运算有小数参与，得到的结果会是一个小数。

（3）在进行取模《%)运算时，运算结果的正负取决于被模数(%左边的数)的符号，与模数(%右边的数)的符号无关

2、赋值运算符

String类
 声明字符串
在Java语言中，字符串必须包含在一堆双引号（"")之内。

例如："23.23"、"ABCDE"、"你好"

可以通过以下语法格式莱声明字符串变量：

String str;

String:指定该变量为字符串类型。

str:任意有效的标识符，表示字符串变量的名称。

使用“+”运算符可实现连接多个字符串的功能。“+”运算符可以连接多个String对象并产生一个新的String对象。

sort(object)

binarySearch(Object[ ] a,Object key)

指定区间内查询

冒泡排序

直接排序

反转排序

面向对象概述
对象：
世间万物都是对象；通常划分为两个部分：动态属性和静态属性动态属性就是对象可执行的动作静态属性就是不能动的部分，这个部分被称为属性，任何对象都会具备其自身属性

类，是同一类事物的统称类实质上就是封装对象属性和行为的载体类是对象的设计图面向对象具有封装性，继承性和多态性的特点

封装
是面向对象编程的核心，将对象的属性和行为封装起来，载体是类。封装保证了类内部数据结构的完整性，使用类的用户不能轻易的直接操作类的数据结构，只能执行类允许公开的数据，避免了外部操作对内部数据的影响，提高了系统的可维护性。

继承
继承性主要利用特定对象的共有属性，子类可以继承父类所有的属性，子类还可以衍生子类，但最末尾的类依然能继承父类所有的属性父类和子类存在一种关系，一个类在继承中它即可以是其他类的父类，为其他类提供属性和行为，也可以是其他类的子类。例如：三角形是图形类的子类也是等边三角形的父类。

多态
其实就是父类对象应用于子类的特征就是多态，多态就是继承父类的所有但又会有不属于父类也不同于其他子类的属性就相当于它的个性。

子主题

Integer

Boolean

Byte

Character

Double

Number

Math类中包含的三角函数方法如下：

☑ _ public static double sin(double a);返回角的三角正弦。
☑ public static double cos(double a);返回角的三角余弦。
☑ public static double tan(double a);返回角的三角正切。
☑ public static double asin(double a):返回一个值的反正弦。
☑ public static double acos(double a):返回一个值的反余弦。
☑ public static double atan(double a):返回一个值的反正切。
☑ public static double toRadians(double angdeg):将角度转换为弧度。
☑ public static double toDegrees(double angrad):将弧度转换为角度。

r: Random类对象。
seedValue：随机数生成器的种子。
在Random类中，提供了获取各种数据类型随机数的方法，下国之伙2今孙田计前
public int nextInt):返回一个随机整数。
public int nextInt(int n):返回大于等于0且小于n的随机
public long nextLong()：返回一个随机长整型值。
public boolean nextBoolean):返回一个随机布尔型值。
public float nextFloat()：返回一个随机单精度浮点型值。
public double nextDouble()：返回一个随机双精度浮点型应 
public double nextGaussian):返回一个概率密度为高斯少士8台晰明向叶进研

一个类继承另一个类需要使用关键字extends，关键字extends的使用方法如下：

class Child extends Parent{}

Java只支持单继承，即一个类只能有一个类，所以类似下面的代码是错误的的：

 class Child extends Parent1，Parent2{}

子类在继承父类之后，创建子类对象的同时也会调用父类的构造方法。

所有的类都是Object类的子类，所以在定义类时可以省略extends Object.

在Object类中，主要包括clone()、finalize()、equals()、toString()等方法，其中equals()、toString()最常用。由于所有的类都是Object类的子类，所以任何类都可以重写Object类中的方法。

注意：Object类中的getClass()、notify()、notifyAll()、wait()等方法不能被重写，因为这些方法被定义为final类型。

需要注意的是，只有具备继承关系得类与类之间才能进行对象类型转换，非继承关系之间不能进行类型转换。

对象之间的类型转换在Java编程中还是很常见的。类型转换分为向上转型与向下转型。

1.向上转型
而向上转型就是将子类对象赋值给父类对象。可以理解为将子类类型的对象转换为父类类型的对象，即把子类类型对象直接赋值给父类类型的对象。
格式为： 父类 对象名 = (父类) 子类对象;需要注意得是，在进行向上类型转换后，父类对象依旧无法调用子类独有的属性与方法。
只能调用从父类中继承下来的属性与方法。
2.向下转型

 向下类型转换可以理解为将父类类型的对象转换为子类类型的对象。 但是运用向下转型，因为父类大多是较为抽象的类，而子类大多是具体的类， 而将一个较为抽象的类转换为一个较为具体的类，这样的转换通常会出现错误，所以向下转型是不安全的。

instsnceof的语法格式如下：

myobject instanceof ExampleClass

 myobject:某类的对象引用。

ExampleClass:某个类。

误区警示：instanceof是Java语言的关键字，Java语言中的关键字都为小写。

重载与重写不同但又十分相似

重写是：返回参数相同 方法名相同 传入参数相同 只有方法体不同

重载则是：方法名相同 参数不同

重载和重写的区别在于：重写必须要有继承关系才能使用，而重写只要在同一个类里就能使用

利用多态可以使程序具有良好的扩展性，并可以对所有类对象进行通用的处理。

假如现在要编写一个绘制图形的方法draw（），如果传入正方形对象将绘制正方形，如果传入圆形对象就绘制圆形，这种场景可以使用重载来实现，定义如下：

public void draw(Square s){
//绘制正方形的方法
}
public void draw(Circular c){
//绘制圆形方法
}

抽象方选没有方法体，这个方法本身没有任何意义，除非它被重写，而承载这个抽象方法的抽象类必须被继系。实际上抽象类除了被继承没有任何意义。定义抽象类的语法如下：

public abstract class Parent{
    abstract void testAbstract();   //定义抽象方法
}
只要类中有一个抽象方法，此类就被标记为抽象类。

抽象类被继承后需要实现其中所有的抽象方法，也就是保证以相同的方法名称、参数列表和返回值类型创建出非抽象方法，当然也可以是抽象方法。下图说明了抽象类的继承关系。

接口所有方法都是抽象方法

修饰符inter face 接口名{}

实现implements

java语言每个类可以实现多个接口

修饰符 class 类名 implements 接口1，接口2，接口3，.....{}

接口是抽象类的延伸，可以将它看作是纯粹的抽象类，接口中的所有方法都没有方法体。对于7.8.1节中遗留的问题，可以将draw0方法封装到一个接口中，使需要draw0方法的类实现这个接口，同时也继承图形类，这就是接口存在的必要性。在图7.11中，描述了各个子类继承图形类后使用接口的关系

异常捕获结构由try、catch和finally 3部分组成

try语句块存放的是可能发生的Java语句；

catch语句块在try语句块之后，用来激发被捕获的异常；

finally语句块是异常处理结果的最后执行部分，无论try语句块中的代码如何退出，都将执行finall语句块

try{
      //程序代码块
}
catch（Exceptionytpe1 e){
      //对Exceptionytpe1 的处理
}
catch（Exceptionytpe2 e){
      //对Exceptionytpe2 的处理
}
...
finally{
       //程序代码块

在程序中使用自定义异常类，大体可分为以下几个步骤：

1.创建自定义异常类

2.在方法中通过throw关键字抛出异常对象。

3.如果在当前抛出异常的方法中处理异常，可以使用try-catch语句块捕获并处理，否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续惊醒下一步操作。

4.在出现异常的方法的调用者中捕获并处理异常。

 处理原则

  Java异常代码中我们使用异常的目的是让异常的异常类型来提示“什么”被抛出了--- 即出了什么问题；用异常的栈打印信息来跟踪异常在“哪里”抛出 --- 即哪里出了问题；

  异常提示信息来提示“为什么”会抛出 --- 即出问题的原因。在对异常进行处理时，遵循以下原则可以有助于在调试过程中最大限度的使用好异常。

具体明确
提早抛出
延迟捕获
  1.具体明确

  具体明确指的是在抛出异常时需要针对具体问题来抛出异常，抛出的异常要足够具体详细；在捕获异常时需要对捕获的异常进行细分，这时会有多个catch语句块，这几个catch块中间泛化程度越低的异常需要越放在

  前面捕获，泛化程度高的异常捕获放在后面，这样的好处是如果出现异常可以近可能得明确异常的具体类型是什么。