Java基础

之前看的Java核心技术的笔记，记录一些Java基础注意点：

数据

1.Java大小写敏感，空格多少不影响句子。
2.一个class文件只能有一个public类，且文件名与该public类类名相同；类名只能以字母开头，其后跟字符和数字任意组合（不能使用关键字）；标准命名规范（只是个标准）：大写字母开头，若名字由多个单词组合，则每一个单词第一个字母大写（骆驼命名法）。
3.Java是强类型语言，即要为每一个变量声明类型。
4.Java基本类型在任何计算机任何操作系统占用大小都不变，整型是精确值类型，浮点型是近似值类型。
5.注意'A'与"A"的区别，前者是字符，后者是字符串
6.在Java中，整型值与布尔型值不能相互转换。在C++中，值0相当于false，非0值相当于true，在Java中则不是这样的。即在Java中不能这样：

int a;//...if(a)...//这里a不能做判断条件，因为整型不能转换为布尔型，在C++是可以的，自动转换

7.变量
1).判断Java中的“字母”：可以使用Character类的isJavaIdentifierStart和isJavaIdentifierPart方法进行检测。$是Java字母，但不要使用它。
2).Java不区分变量的声明和定义。变量声明了使用前必须初始化，否则会报错。（C++对于基本类型则不会，静态的是默认值，动态的是随机值？）
3).常量，final修饰，只能在初始化的时候被赋值，通常常量名均用大写。类常量：static final修饰。static：这个类的特性，非某个实例所有若再加上public修饰，则其他类也可以使用，通过ClassName.value使用。

String str = new String("123");//创建了几个对象？//分析：//先去常量池查找是否有"abc"对象，如果没有，则在常量池创建此字符串对象（如果有则//省略该步骤），然后再在堆中创建一个常量池此"adc"对象的拷贝对象，所以，常量池中//没有"abc"字符串，则创建了两个对象，否则，就只是创建了一个

8.运算符
1).整数除整数结果还是整数，若其中有一个非整数，则结果为浮点数。
2).整数被0除产生一个异常，但是，浮点数被0除会得到无穷大或NaN。
3).自增自减运算符，尽量不要在其他表达式中嵌套。
4).关系运算符和boolean运算符：==、!=、>、<、>=、<=、!、&&、||（短路运算）。
5).位运算符：&(与)、|(或)、^(异或)、~(非)、>>(右移，用符号位填充高位)、<<(左移)；>>>(用0填充高位，C++没有此)，没有<<<运算符，对于移位运算右侧的参数，需要进行模32运算（除非左边的操作数是long类型，此时，则进行模64运算），例如1<<35与1<<3是相同的。
6).强制类型转换：丢失精度

double d=9.97;int x=(int)d;//这样结果x=9；只取整数位//若想获得舍入值，则需要使用Math的round方法：int x=(int)Math.round(d);//这时结果x=10；round返回的是long类型，如果值超过int范围，强转还是会损失精度

类与对象

1.基本
1).由类构造对象的过程称为类的实例化（所以，有时也称类的对象为类的实例）
2).对象中的数据称为实例域（instance field），每个对象都有自己一组特定的实例域，这些值的集合就是这个对象当前的状态（state）。无论何时只要向对象发送一个消息，他的状态就有可能改变
3).对象的三个主要特性：
(1).对象的行为（behavior）：可以对对象施加哪些操作，或可以对对象施加哪些方法？
(2).对象的状态（state）：当施加方法时，对象如何响应？
(3).对象的标识（identity）：如何辨别具有相同行为与状态的不同对象？
4).设计类>>>>>向类添加方法：描述类“外观”>>>>>描述类“行为”
5).类之间的关系：常见
(1).依赖（“uses-a”）：最明显常见的一种关系，A类需要B类（设计时尽可能较少该关系，让类的耦合度低）
(2).聚合（“has-a”）：具体且易于理解，A类对象包含B类对象
(3).继承（“is-a”）。
6).C++类的方法可以在类外定义，也可以在类内定义（类内定义自动成为内联方法）；Java则必须在类内定义（是不是内联方法由JVM决定）。
2.方法参数
1).Java所有的方法参数在方法内使用的是参数的拷贝！可能是值拷贝，可能是引用拷贝。（Java为每一个传进来的参数拷贝一个对象，方法内使用的就是这个对象）所以，传递进去的如果是值，则其值是不会变的，变的只是方法内的那个拷贝对象，与传递的参数无关；同样的，如果传递的是引用，实参指向是不会改变的，但是可以改变其指向的内容（可以改变引用对象的状态），相当于说，Java的方法参数全是final的！
注意：C++则可以通过&符号修改参数的指向
3.对象的构造：仅当类没有提供构造函数，系统才会提供一个默认的无参的构造函数
1).重载：任何方法都可重载：参数个数、类型其中一样不同就可，返回值不同没用。（Java不许重载运算符）
重写（方法覆盖）与重载区别：
(1).重写必须继承，重载不用。
(2).重写的方法名，参数数目相同，参数类型兼容，重载的方法名相同，参数列表不同。
(3).重写的方法修饰符大于等于父类的方法，重载和修饰符无关。
(4).重写不可以抛出父类没有抛出的一般异常，可以抛出运行时异常
2).一般的，最好在构造器中显示的给域初始化。局部变量必须显示初始化后才能用，而域则可以不用（会使用给类型的默认值，不过最好是显示
初始化，否则的话，影响可读性，这是二者最主要的不同点）

//C++注释：C++不能直接初始化类的实例域（既不能在声明处初始化），必须在构造器中才//行，但有一个特殊的初始化器列表：        Employee::Employee(String n,double s,int y,int m,int d):name(n),salary(s),hireDay(y,m,d){}//Java没并要有这，因为Java对象没有子对象（驻留在另一个对象中的对象，在一个类的//定义中，声明另一个类的对象来作为成员变量。），只有指向其他对象的指针（引用）

3).Java可以利用this，在一个构造器中调用另外一个构造器；而C++则不能，必须抽取出公共初始化代码编写成一个独立的方法。
4).初始化块：位于类中一个独立的块：

class A{    private int a;    {        //初始化块    }    public int getA(){}}

    只要构造类的对象（构造实例）就会执行初始化块；无论使用哪个构造器，初始化块都会    执行，而且是先执行，后才执行构造器中的语句

5).某些对象使用了内存之外的其他资源，例如，文件或使用了系统资源的另一个对象的句柄，这种情况，JVM是不会自动回收垃圾对象的，可以为任一个类添加finalize方法，finalize方法将在垃圾回收器清除对象之前调用。
4.包：只能用*导入一个包，即只能这样：import java.util.*;不能import java.*或import java.*.*;
1).import不仅可以导入类或一个包，也可以导入静态域和静态方法：

import static java.lang.System.*;//这样就可以直接：out.println();

继承

Java只有公有继承，没有C++的私有继承和保护继承
1.子类不能直接调用超类的私有域：

class A{        private int a;        public int getA(){            return this.a;        }    }    class B extends A{        private int x;        //要覆盖超类的getA方法        public int getA(){            // return a+x;   error，不能直接访问a，虽然B类继承了A类的私有域a            // return getA()+x; error，也不能这样，这样就成了无限递归了            return super.getA()+x;//正确，super不是一个对象引用，只是一个指示编译器调用超类方法的特殊关键字，和this不一样            //C++调用超类方法：A::getA()        }        //另外，注意，使用super调用超类构造器必须是子类构造器的第一条语句    }

2.多继承：
Java是没有多继承的，只有单继承，即一个子类只能有一个超类。
单继承：管理简单，不会出现逻辑错误以及多继承自身的缺陷，另一方面，Java使用了接口，一个类可以实现多个接口，从而在另一个更合理的角度来实现纯粹的多重继承。
类之间的继承（extends）只能单继承，但能实现（implements）多个接口；接口之间能继承（extends）多个接口，只需要用逗号分开即可，但是如果真的必须需要使用这样复杂的机制，务必注意方法重名导致的问题。
3.另外要注意，数组引用与一般对象引用的不同：

B b=new B();    A a=b;    a=new A();//完全可以    //但是，数组就不一样了：    B[] b=new B[10];    A[] a=b;//这个时候，完全可以，向下引用（向上赋值）    a[0]=new A();//错误    a=new A[10];//正确，此时，a[0]=new A();是可以的

也就是说，对于数组来说，当数组引用（这里就是a）指向了某一个类型的数组，就只能存储这个类型的数据（或这个类型的子类）