面向对象的众多特性

-------------------------------------------------------------
package语句,
注意,package语句必须写在import语句的上面,否则编译失败!
--------------------------------------------------------------
import语句并不会额外占用虚拟机资源,与写全包名的类一样,没区别.
1.import语句,可以导入一个类或某个包中的所有类.
2.import static语句(静态导入--JDK1.5的新特性),可以导入一个类中的,一个静态成员或所有静态成员(包括静态成员变量和静态方法).
案例:
求两个数的最大值和相减结果的绝对值,
import static java.lang.Math.*;
...
max(3,9);
abs(88-99);
random();//返回double值,>=0且<1,此方法是线程同步的.
-------------------------------------------------------------------------------------------------------------------------
(可变参数--JDK1.5的新特性),一个方法接受的参数的个数不固定(0-n个).
可变参数的限制:
1.只能出现在参数列表的最后
2.可变参数的符号"..."位于变量类型和变量名之间,前后有无空格都可以
3.调用可变参数的方法时,编译器为该可变参数"隐含"创建一个"数组",在方法体中以"数组"的形式访问可变参数
案例:
求多个整数的和,
public static int add(int... args)
{
 int sum = 0;
 for(int i=0; i<args.length; i++)
 {
  sum += args[i];
 }
 return sum;
}

揭示可变参数的编译本质:
1.方法声明,中的可变参数,在编译的过程中,直接被转换为数组.
2.方法调用,中的可变参数,在编译的过程中,编译器会检查"现有参数"类型是否匹配<?>[ ],匹配的过程中遵从"多态机制"!
3.如果匹配,编译器不修改"现有参数",如果不匹配,编译器试图把"现有参数"打包为<?>[ ]类型的数组.
注意,"可变参数"在编译过程中就会被干掉,所以编译后的代码里没有"可变参数"的概念.
-------------------------------------------------------------------------------------------------------------------------
案例:
说说overload(重载)和override(重写)的区别,

分析:
1.只要参数不同(不管是不是同一类, 不管是不是父类私有),就叫做重载,要求比较宽松.
2.参数相同,同一类中,叫做重复,编译失败.
3.参数相同,不同类中,父类中函数是private,不是重写,不用满足重写条件.
4.参数相同,不同类中,父类方法不是private,就是重写.

只有同时,这满足3个条件(参数相同 + 不同类中 + 父类不私有),编译器才会认定,这是一个重写.

既然编译器认定,是重写了,还要必须满足以下3条:
1.权限必须>=,否则编译失败.
2.静态修饰必须一样,否则编译失败.(子和父中谁有static都不行)
3.返回值类型必须一样,否则编译失败.

注意:如果不是重写(比如父类是private),肯定不能产生多态.
--------------------------------------------------------------------------------------
多态,产生的条件,必须同时满足,以下3个条件:
1.继承
2.重写
3.父类引用指向子类对象

多态中的强制转型:
1.多态所得到的是间层对象,本质还是一个子类对象,(通过反射验证)
2.这个中间层的对象,向上转型(不报错,转型失败),无法转成真正的父类对象.
3.这个中间层的对象,向下转型(不报错,转型成功),可以转成真正的子类对象.

突破多态机制的限制:
//利用反射的目光,重新学习多态,
1.子类拥有自己的和从父类继承的,成员变量和成员方法,private的除外,
2.不可调用重写的子类中的成员变量,通过强制转型,可以调用,
3.不可调用重写的父类中的成员方法,通过super关键字,可以调用,
---------------------------------------------------------------------------------------
java中的权限修饰符:
类中的成员的权限大小(前者包含后者):
包外 > 包外的子类 > 包内 > 类内
类的权限大小(前者包含后者):
包外 > 包内
----------------------------------------------------------------------------------------
构造函数的限制:
1.构造函数,不能是静态的,但是静态成员却可以调用(特例).
2.构造函数,不能写返回值类型,因为本身就返回一个对象.
3.构造函数,不能使用synchronized关键字,不能被继承,不能被重写,只能被调用.

只有2种方式,可以调用构造函数:
1.可以使用super语句和this语句,这种方式,只能用于构造函数中,且必须放在第一行.
2.其它地方,使用构造函数,只能使用new关键字.
3.将永不能使用   "构造函数()"  的方式来调用构造函数,除非写一个与构造"同名同参"的方法(void的也行,什么的都行),竟然不报错(变态),看来构造函数不是真正的方法.

案例:
class Person
{
 Person()
 {
 }
}
class Student extends Person
{
 void method()
 {
  Person();
 }
 void Person()
 {
 }
}
注意,以上代码看上去像是重写,其实并不是重写!(重写要求返回值类型也一样).
---------------------------------------------------------------------------------------
抽象类和接口:
1.抽象类中的抽象方法,权限可以是public,protected,默认,3种都行,不能用private(private不能重写).
2.接口中的方法,权限只能是public abstract的,其它都错.
接口具有固定格式的修饰,不能改变:
1.成员变量:public static final
2.成员方法:public abstract

---------------------------------------------------------------------------------------
分析类中的各种元素:
1.成员变量
2.成员方法
3.构造函数,注意,与成员方法相比,具有很大的不同，很搞笑的用法.
4.代码块
5.静态代码块
6.成员类

整理各种元素修饰符:
1.类
public,abstract,final,strictfp
2.成员变量
public,protected,private,static,final,transient,volatile(专用)
3.成员方法
public,protected,private,static,final,abstract,native,synchronized,strictfp
4.构造函数
public,protected,private
5.局部变量
final

strictfp关键字:
1.表示执行IEEE-754规范的浮点数的运算,更加精确
2.可用于------类,接口和方法
3.不能用于-----构造方法和接口中的方法

参考:
http://www.csdnjava.com/forum.php?mod=viewthread&tid=76367
-----------------------------------------------------------------------------------------

 

 

 

 

 

-----------------------------------------------------------------------------------3
在Java中,有内部类,也有内部接口,比如:
1.public static interface Map.Entry<K,V>接口

内部类的局限性:
1.只有定义在成员位置上时,才可以使用public,protected,默认,private或者static修饰符.(当然,静态内部类也只能访问外部类的静态的成员,外部类的静态成员也只能访问静态的内部类)
2.如果内部类的内部有静态的成员,那么内部类也必须是静态的.(因为还没有生命周期,所以容易理解)
3.内部类不可能访问到局部变量.(因为局部的东西,出了大括号,就没有人认识局部变量了)

局部类的局限性:
1.不可被成员修饰符修饰(public,protected,默认,private,static),所以局部类内部也不能定义静态成员!
2.局部类内的成员,不可能是静态的.
3.局部类可以访问局部变量,但局部变量必须是final的!(不清楚是什么原因,可能是为了,想简化java的语法)

如何突破final的限制:
1.可以把final变量升级为成员变量.
2.可以把final的变量作为一个对象,而对对象中的变量进行改变.
3.可以通过桥接的方法,此时,只能由外向内修改,无法由内向外修改.

内部类和局部类的共同点:
他们都可以直接访问外部类中的成员(包括私有),因为它们都持有外部类的引用.
访问的格式--> Outer.this.x (可以省略Outer.this.)

外部其它类对内部类和局部类的访问:
1.不能访问局部类.(因为局部的东西,出了大括号,就没有人认识局部类了)
2.对非private的内部类,可以直接实例化.
非静态内部类格式:Outer.Inner in = new Outer().new Inner();
静态内部类格式:  Outer.Inner in = new Outer.Inner();

外部类对内部类和局部类的访问:
1.不能访问局部类.(因为局部的东西,出了大括号,就没有人认识局部类了)
2.非静态可以访问非静态和静态,静态只能访问静态.(包括私有)
3.外部类的静态成员,访问静态内部类的非静态成员,也行.(这是一个特例)

注意:老张说,静态内部类,实际上就已经变成了一个外部类,是的没错,这句话,还是有一定道理的.

案例:
class Outer
{
 private int x = 3;
 class Inner
 {
  int x = 4;
  void function()
  {
   int x = 5;
   System.out.println(x);//结果5
   System.out.println(this.x);//结果4
   System.out.println(Outer.this.x);//结果3
  }
 } 
}
注意:以上方法,说明了Outer.this.关键字的使用方法.

案例:
class Outer
{
 static class Inner
 {
  void show()
  {
   System.out.println("inner show");
  }
 }
 
 static void method()
 {
  new Inner().show();
 }
}
注意:外部类中的静态方法访问可以调用静态的内部类中的方法,即使这个方法不是静态的(只要求这个内部类是静态的),访问也是成功的!

案例:
class Outer
{
 int x = 3;
 void method()
 { 
  new Inner().function();//出错的位置
  class Inner
  {
   void function()
   {
    System.out.println(Outer.this.x);
   }
  }
 }
}
注意:以上代码将出错,把new放在下面就对了,因为java是解释型的语言,方法的内部将是"有序的"解释执行!

案例:
class Outer
{
 int x = 3;
 void method(final int y)
 { 
  class Inner
  {
   void function()
   {
    System.out.println(y);
   }
  }
  new Inner().function();
 }
}
...
Outer o = new Outer();
o.method(5);
o.method(8);
...
注意:以上代码是正确的,因为final y局部变量是存放在"栈中"的,它只在它的生命周期的内部是final的,而上面的代码,相当于final y有了2个生命周期,这与final并不矛盾!
----------------------------------------------------------------------------------------------------------------------
匿名内部类的构造函数:
1.new子类,肯定是先new其父类,子类构造和父类构造,肯定都是被调用了.
2.匿名,连名都没有,所以匿名内部类是没法再写构造,只有默认空参构造,子类调用的就是这个空参的构造.
3.父类调用的是哪一个构造,括号中的内容很重要,就决定了父类调用的是哪一个构造方法.

案例:
new Thread(new Runnable() //这是父类中的构造函数,肯定也是被调用了的.
{
 @Override
 public void run()
 {
  System.out.println("构造函数打印了");
 }
}){
 public void run()
 {
  System.out.println("子类方法打印了"); //打印结果是这个.
 }
}.start();
-----------------------------------------------------------------------------------------------------------
异常的2种处理方式:
1.try,可以把大异常变成小异常,也可以把有异常变成没异常.
2.抛,抛的时候要注意异常的大小的限制,可能产生语法错误,要小心.

方法重写中的异常的限制:
为了多态中的异常机制的安全性,要求子类中的方法只能抛出<=父类或接口中的方法所抛出的异常(或者不抛),从而保证了在多态形式的方法调用中,仍然能够捕获的到.

方法重写中的异常的解释:
1.如果非要在,在子类的方法中搞出一个异常>父类或接口中的被重写的方法所抛出的异常,那么此时子类方法中的异常,只能try不能抛.
2.如果父类或接口中的方法抛出了多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集.
3.如果父类或接口中的方法中没有抛出异常，那么子类在覆盖该方法时，也不可以抛出异常.

案例:
演示方法重写中的异常的限制.

注意,在接口所声明的方法后,也是可以抛出异常的!
----------------------------------------------------------------------------------------------------------------------