print就是一般的标准输出，但是不换行
println和print基本没什么差别，就是最后会换行
1、父类静态变量和静态代码块（先声明的先执行）
2、子类静态变量和静态代码块
3、父类变量和代码块
4、父类的构造方法
5、子类的变量和代码块
6、子类的构造方法
静态方法不能访问非静态成员，编译会出错
已知如下代码
class Example{
String str;
public Example(){
str= "example";
}
public Example(String s){
str=s;
}
}
class Demo extends Example{
}
public class Test{
public void f (){
Example ex = new Example("Good");
Demo d = new Demo("Good");
}
}
q.哪句语句会导致错误？（）
A、 line 3 B、line 6 C、line 10 D、 line 14 E、 line 15
*在java中，如果一个类没有定义构造方法，编译器会默认插入一个无参数的构造方法；但是如果一个构造方法在父类中已定义，编译器不会自动插入一个默认的无参构造方法。对于子类来说，不管是无参构造方法还是有参构造方法，都会默认调用父类的无参构造方法；当编译器尝试在子类中往这两个构造方法插入super()方法时，因为父类没有一个默认的无参构造方法，所以编译器会报错。
answer：E
int型范围-2147483648~2147483647
超过范围的int计算 i=2147483647+1-2×2147483648=-2147483648
给定如下一个Java源文件Child.java，编译并运行Child.java, 以下结果正确的是
A. 编译错误：没有找到构造器Child()
B. 编译错误：没有找到构造器Parent1()
C. 正确运行，没有输出值
D. 正确运行，输出结果为：parent2
因为Parent2构造方法会默认有super()调用他的父类构造方法，但是Parent1显示的定义了一个有参构造，系统会回收默认的无参构造。
answer：B
*知识点回顾：
继承中子类实例化的过程：先调用父类构造方法，然后再执行子类构造方法。因为子类中所有构造方法的第一行有默认式==super();==语句（父类对象先进内存，这样子类才能拥有父类的成员）。这道题的错因在于，父类有参数，那么子类的super()必须有参数<=>如果父类中没有无参构造方法，那么子类必须使用带参super()调用父类的构造方法。
构造方法
A. 第2行错误，Test类的构造函数中参数名称应与其父类构造函数中的参数名相同
B. 第3行错误，应使用super关键字调用父类的name属性，改为super.name=“hello”
C. 第4行错误，调用父类构造方法的语句必须放在子类构造方法中的第一行
D. 程序编译通过，无错误
*在调用父类的构造方法时，super必在子类构造方法的第一行，否则会报错。与上一题类似。
answer：C
分析下面两个类：
class First{
final static int A=3;
}
final class Second extends First{
void method(){
System.out.printin(A);
}
}
正确的是____。
A.类First能被编译，但类Second不能
B.类Second能被编译，但类First不能
C.两个类都不能被编译
D.两个类都不能被编译，并且当调用方法method()时，将输出3
E.两个类都能被编译，但当调用方法method()时，将抛出一个例外
*当关键字final用来修饰类时，其含义是该类不能再派生子类，换句话说，任何其他类都不能继承用final修饰的类，即使该类的访问权限为pubilc类型，也不能被继承；否则，将编译报错。但这道题是final类是子类所以不影响，故程序可以正常编译。
answer:D*
格式再次记忆！！
byte不能自动转换到char，因为char没有符号，会丢失精度
这样写一定要带括号！！
0 ! = 1
方法调用：
非静态方法在同一类内调用其他方法：直接调用方法名即可
public class Test {
public void Son1(){//非静态方法
System.out.println("java大爷，你成功调用了你非静态方法里的儿子1");
}
public static void Son2(){//静态方法
System.out.println("java大爷，你成功调用了你静态方法里的儿子2");
}
public void alloutput(){
Son1();//非静态方法直接调用类内的非静态方法△
Son2();//非静态方法直接调用类内的静态方法△
}
public static void main(String[] args) {
Test test = new Test();
test.alloutput();//前边已学静态方法通过对象调用非静态方法
}
}
非静态方法在不同类之间调用其他方法：通过对象才能调用非静态方法；非静态方法既可以通过对象调用静态方法又可以通过类名直接调用（由于对象的调用方式属于非静态调用方式，所以建议使用类名直接调用静态方法）
静态方法调用非静态方法：需要通过对象调用
静态方法调用静态方法：同一类内直接调用，不同类内直接通过类名.方法名（参数表）调用
public class Cylinder { //04314题
Cr c; //引用变量是在栈内存里开辟了空间给引用变量c，这时c=null
private int h;
public Cylinder(){
c=new Cr(); //表示在堆内存中开辟了空间给Cr类的对象，对象叫c（此时真正创建了对象）
h=0;
}
public Cylinder(int r, int h){
c=new Cr(r);
this.h=h;
}
public double getArea(){
return 2*c.getArea()+c.getPerimeter()*h;
}
public double getVolume(){
return c.getArea()*h;
}
}
public DateAndTime(MeDate date, MeTime time){
this.date= new MeDate(date);
this.time= new MeTime(time);} // 构造方法
public DateAndTime(MeTime time, MeDate date){
this(date, time);
} // 构造方法
此时this((date, time)显式调用同一类中有相同形参的构造方法，所以此时调用的是上面的构造函数，若为this(time,data)则会无限调用自己
String都是常用的方法，应写成str.length()
str.equals(“YES”)返回值是true和false
class MyClass {
public static int method(String a, String b) {
int a1=Integer.parseInt(a); //Interger必须实例化后才能使用（int不需要）
int b1=Integer.parseInt(b);
return a1+b1;
// 返回两个整数的和
}
}
两者区别
1.Integer是int的包装类（Integer 类型的对象包含一个 int 类型的字段。 此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理道 int 类型时非常有用的其他一些常量和方法，比如定义了表示整数的最大值和最小值的常量），int则是java的一种基本数据类型 (面向过程留下的痕迹，不过是对java的有益补充)。
2.Integer变量必须实例化后才能使用，而int变量不需要 。
3.Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值 。
4.Integer的默认值是null，int的默认值是0。
double只有10进制，有标准记数法和科学记数法表示方式
标准计数法由小数部分和整数部分组成，两者可省其一，如12d（要加d/D)和12.3和42
科学计数法，E/e前面必须有数字（可以是整数），E/e后必须是整数，如0.12E2，12e-10
此时运算式双目提升为double型，0是一个无限趋于0但不等于0的数，相除是无穷大
逻辑运算不涉及数据类型的转换或提升，所以&两边都应该是boolean型，故报错
关键字：都是小写字母 then不是，无论是String或string都不是
true，false，null是系统预定义的三个文字
instanceof是运算符
ACD）
A.这里的1是整形，当赋值给一个float时，存在一个隐式转换，不损失精度。
B.会出错。 因为1.0默认是double类型的。double范围比float大，为了不损失精度，不会自动转换。
CD.属于隐式转换了
C）a=b返回值1，C中赋值后，会与0进行比较，如果大于0，if为true，否则返回false，而java中不会于0进行比较，而是直接把赋值后的结果放入括号中，而if只存放boolean类型
这是接收数组
main不能作为关键字，它属于标识符，main函数的main是函数名
书本易错点：
基本类型包括：整型，浮点型，布尔型，字符型
整型：二进制码格式存放，分为byte（字节型，-128~127），short（短整型），long（长整型），int（整型）
浮点型：float（单精度），double（双精度），包括正零（+0.0），负零（-0.0），正无穷（+Infinity），负无穷（-Infinity），特殊NaN值
字符型：char型码值是无符号的，而short型整数有符号，在Java的基本数据类型中，char型采用Unicode编码方案，每个Unicode码占用2字节存空间，这样，无论是中文字符还是英文字符，都是占用2字节存空间
布尔型：略
文字
int型：10，8（以0开始），16（以0x或0X开始，A~F代表10-15）进制表示
long型：与int型类似，以 l 或 L 结尾
l与L可以加,也可以不加1. 所赋的值超过了int型的取值范围,后面必须加上字母l 2.所赋的值未超过int型的取值范围,后面可以加/可以省略字母l
eg. long n= 0xa; //合法的，定义了一个值为10的int型，int型可以被赋值给long型
float型：没有16进制
double型：只有十进制，可以加上d或D，有e的是
char型：‘ ’
boolean型： String型：必须在一行内写完
局部变量不能超前使用，在已经存在的变量上重新定义会编译错
int a=100; byte x1=a; //初始化是错误的，不能将非常数表达式的int值赋给byte型变量（int不能赋给byte），赋值转换是系统自动完成的，所以必须符合要求
double->float 值太小了是正负零，值太大了正负无穷
单目运算符：+、-在运算前会进行单目运算提升，结果至少是int型
而++，- -不提升，结果与变量类型相同
双目运算符：会算术提升，结果至少是int型
关系运算符：双目提升
0.0==-0.0
组合赋值运算符（+=、-=、*=、/=、%=）：类似于强制转换，左面一定有值
double factor; int width; width+=factor;
会自动把double转化成int型（double不会自动转换成int
-x++ -(x++) 单目运算符同级右结合
a? b : c? d:e a? b : ( c? d:e ) 三目运算符同级右结合
x=y=13 x=(y=3) 赋值运算符也是右结合
eg. byte i=3, j=1;
i < j | i + j < 5
float类型的字面常量,后面需要加上f或者F来表示是一个单精度浮点数，因为在java里面，没小数点的默认是int,有小数点的默认是 double
char的默认值是’u0000’，不是空格
u0000代表的应该是nul,一个控制字符，表示没有值，不可见，输出控制台是空，但不是真正的空格，因为真正的空格的unicode编码是’u0020’
错题：
char和short位长都是16
0xffff是65535 short是-32768~32767
int a=10; int b=10; 那a==b成立，不算是两个不同的对象
*==是会双目运算提升的
类方法调用：类.方法名
switch(<不能是long>)
方法的调用必须用实例
局部变量和实例变量的区别：
判断是否在方法内部，局部变量可以屏蔽实例变量
对一个实例的实例变量值的改变不会影响另一个实例的实例变量值
静态初始化块的作用只能是初始化类变量，不能有return，super，this
类变量：无论创建多少个实例变量，类变量都只有一个，不会随着改变（它是固定住的）
类方法不能被abstract修饰，抽象方法不能用static，final，private修饰
形参实参要赋值相容，传参不能缩窄
先初始化所有的实例变量，后执行构造方法中的代码
方法签名：方法名+形参表
方法重载：方法名相同但形参不同
静态初始化块和类方法都不能使用this
类方法访问类变量，类方法（所有类），但是在类方法中创建实例/接收实例，就可以通过实例访问实例变量或调用实例方法
void method(Sa0412_1 obj){
…} // 可以看成obj指向所传对象，这就是引用传递，但是方法的局部变量会在方法执行后消失，故obj会被垃圾回收
D）public static void main()实际上是main方法，里面的变量是局部变量，而局部变量需要初始化（且局部变量可以和成员变量重名。
ans：main()方法不能调用amethod方法，因为类方法不能调用实例方法/成员变量，必须通过创建实例调用
F）
static修饰的方法是类方法，先于任何实例存在。static修饰的方法在类加载的时候就已经存在了，实例是在创建时才在内存中生成。而this关键字，总是指向当前调用该方法的对象。
在方法中定义使用的this关键字，它的值是当前对象的应用，也就是说你只能用它来调用属于当前对象的方法或者使用this处理方法中的成员变量和局部变量重名的情况。static修饰的方法是属于类的，该方法的调用者可能是一个类，而不是对象。那么，如果使用的是类来调用而不是对象，则this就无法指向合适的对象，所以static修饰的方法中不能使用this。
AD）A形参次序不同，ok；B方法重载与返回值类型无关；C方法重载与参数名无关，与参数类型有关；D方法名称不同，ok
D）首先，编译不会出错，rg一定是在执行完getIt()方法后被回收的，方法返回实例。
当某一字节大于0x7f（127），将强制转换
字符串的第一次字符的位置序号为0
subString()截取范围：beginIndex~endIndex-1
equals(…)判断字符串内容是否相等
trim()去空：移去调用串前后两段空白字符
String是不可变的（源码里String类有final修饰符），所以数值一旦初始化后便不能更改，如果调用了实例方法处理，若值发生了变化，系统将返回一个新的String实例，否则返回当前调用串本身
System.out.println（Object）自动调用的toString方法
valueOf是类方法，可以通过类名直接调用 eg. String.valueOf(x) （类方法在类被加载的时候就被分配了入口地址，所以类方法不仅可以被类创建的任何对象调用执行，也可以直接通过类名调用）
StringBuffer：初始容量=str.length()+16
length()返回长度，capacity()返回容量
方法有：append( String) insert(int, String) delete(start,end-1) replace(start, end, String) reverse()
StringBuffer是可更改的，上述实例方法都不会产生新的StringBuffer类，只是对原来实例内容的修改
文字池中的文字是类装入初始化时创建的，代码执行过程中创建的String实例不加入文字池
当程序正文出现字符串文字时，运行系统会为其创建一个String实例
6+6+“xy”——12xy “xy”+6+6——xy66
装箱开箱：
装箱就是将基本数据类型转化为包装类型，那么拆箱就是将包装类型转化为基本数据类型。
自动装箱：或者叫隐式装箱，直接给Integer赋值，即Integer d=1,在编译的时候，会调用Integer.valueOf（）方法完成装箱。
A）
theFile->program.java
fname->program
fname->program.txt
f->program.txt
但是theFile还是指向program.java
B）（)是转义字符，若想输出 需要写成
public static String method(String str) {
// 返回参数字符串中大写字母组成的倒序字符串
if(str==null) return null;
if(str=="") return str;
int i=0;
StringBuffer s=new StringBuffer();
while(i='A'&&str.charAt(i)<='Z')
s.append(str.charAt(i));
i++;
}
return s.reverse().toString();
}
reverse()是StringBuffer的方法
回顾：append()，insert(int, String)，delete(start, end)，replace()，reverse()都是StringBuffer的实例方法
class MyClass {
public static String method(String str) {
return str.replaceAll("(rn|r|n)","
");
} //str中的回车符(r)、换行符(n)或回车换行符(rn)替换成
，并返回替换后的结果。
}
public class Spheroid extends edu.Cc{ //edu.Cc 写清楚是在哪个包中调用的类
public Spheroid(){}
public Spheroid(int r){
super(r);}
public double getSurfaceArea(){
return 4*Math.PI*getRadius()*getRadius();
}
public double getVolume(){
return 4.0/3*Math.PI*getRadius()*getRadius()*getRadius(); //返回类型是double所以...
}
}
public boolean equals(Object sh){ //传入的是Object类，但Object可以转换成任何类
Rectangle s = (Rectangle)sh;
if(getArea() == s.getArea())return true;
else
return false;
} // 判断当前形状与参数形状的面积是否相等
第六章 继承和嵌入类
is-a关系：可以将子类类型变量赋值给超类类型变量，反之不可，若超类赋值子类，会导致子类的新成员没有定义，引发编程错误
从超类中继承的方法访问的仍然是超类中被隐藏的同名变量x
方法覆盖要求:
1.返回类型相同
2.覆盖方法访问级别高于被访问方法级别
3.覆盖方法不能比被覆盖方法抛出更多例外类型
与成员变量隐藏的区别：方法覆盖中 (超类).实例.方法 调用的还是子类中覆盖方法
例子：
class Sa0605{...}
class Sa0605_1 extends Sa0605{
int j,k;
Sa0605_1(){
//这里隐含调用直接超类不带形参的构造方法 super();
j=20;
}
Sa0605_1(int a){
this(); //显式调用当前类中不带形参的构造方法
k=a;
}
}
构造方法从超类执行开始
超类中所有实例变量初始化完成，构造方法执行后，才开始子类的装入
超类子类初始化顺序：父类属性值–》》父类构造方法–》》创建父类对象–》》子类属性–》》子类构造方法–》》创建子类对象
局部内部类和匿名内部类只能访问final的局部变量
Object类方法：
Object的equals方法和==作用一样，判断是否是同一个对象
clone()产生一个内容完全相同的新对象，Object类本身没有实现Cloneable接口，所以对象的类必须实现Cloneable接口，clone方法返回类型是Object，所以在对象复制时需要类型转换
public class Parent {
protected static String a = "static";
final String b = "final";
public static void staticMethod(){
System.out.println("this is a static method");
}
public final void finalMethod(){
System.out.println("this is a final method");
}
}
public class Child extends Parent {
@Test
public void test(){
System.out.println(a);
System.out.println(b);
staticMethod();
finalMethod();
}
}
输出的结果是这样的：
static
final
this is a static method
this is a final method
由此可见，只要是非私有的成员都是可以被继承的，并且也可以在子类对其进行覆盖。
用final定义的类不能有子类
D）子类默认super()，但是父类没有无参构造方法，于是报错
解决方法：1）在父类中加一个无参构造方法 2）子类添加super(参数)去显示的调用父类的带参构造方法 3)子类通过this去调用本类的其他构造方法 子类中一定要有一个去访问了父类的构造方法，否则父类数据就没有初始化
接口中的方法都是public，abstract属性，可以省略
抽象方法不能是final的
一个接口能扩展一个接口，也可以扩展多个接口
*long型不能转换成int
数组元素的访问可以是构造n个对象，每个a[i]指向一个类的对象
class MyClass {
public static int[][] multiply(int[][] x, int[][] y) {
// 矩阵相乘
int m=x.length;
int n=x[0].length;
int l=y[0].length;
int[][] z;
z=new int[m][l];
for(int i=0;i
第九章 例外处理
书本易错点：
不捕捉则声明
EOFExpextion 和 FileNotFoundException都是类IOExpection的子类
NullPointerExpection是一种不受检查的例外类型，所以可以充当覆盖方法的抛出声明
Exception是IOException的超类
自定义例外类型是Exception的子类，需要在定义的时候extends Exception
拓展：
受检查的异常和不受检查的异常区别：
受检查的异常用try—catch块代码处理，或者在main方法中用throws关键字声明抛出；不受检查的异常可以忽略或用throws声明。
Exception（环境影响造成）是所有被检查异常的基类
RuntimeException是不受检查的基类（+Error），通常由于糟糕的编程引起的，继承了Exception
throw和throws区别：
throw是语句抛出一个异常 eg. throw(异常对象); throw e;
throws是方法可能抛出的异常 so普通类不能抛出异常
throws表示出现异常的一种可能性，并不一定会发生这些异常；throw则一定是抛出了异常。
写法注意！！ throw new Exception && throws Exception
覆盖原则：
子类所抛出异常不能超过父类异常（超类），但可以抛出任何不受检查的异常，可以抛出父类异常的多个子类
父类捕捉到了子类的异常，e仍是子类异常名称
