Java基础之面向对象

一、面向对象与面向过程

二者都是一种思想，面向过程强调的是功能行为；面向对象将功能封装进对象，强调具备了功能的对象。

二、类和对象

类是对一类事物的描述，是抽象的、概念上的定义；对象是实际存在的该类事物的每个个体，也称为实例。
定义类实际上就是定义类中的成员（成员变量和成员方法）。

1. 对象的创建和使用

使用new +构造器创建一个新的对象；
使用“对象名.对象成员”的方式访问对象成员（包括属性和方法）；
例：

public class Zoo{
   public static void main(String args[]){
	Animal xb=new Animal();
	xb.legs=4;
	System.out.println(xb.legs);
	xb.eat();
	xb.move();
   }
}

如果创建了一个类的多个对象，对于类中定义的属性，每个对象都拥有各自的一套副本，且互不干扰。

1. 1. 对象的产生
      Person p1 = new Person();执行完后的内存状态
      
      当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值。除了基本数据类型之外的变量类型都是引用类型，如上面的Person及前面的数组。
      

1.2. 对象的使用

class TestPerson{
	public static void main(String[] args) {   //程序运行的内存布局如下图 
		Person p1 = new Person();
		Person p2 =new Person();
		p1.age = -30;
		p1.shout();
		p2.shout();
	}
}

1.3. 匿名对象
不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象。如：new Person().shout();

使用情况：
如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。
我们经常将匿名对象作为实参传递给一个方法调用

2.对象类型转换(Casting )

基本数据类型的Casting：

自动类型转换：小的数据类型可以自动转换成大的数据类型
	      如long g=20;           double d=12.0f
强制类型转换：可以把大的数据类型强制转换(casting)成小的数据类型
            如 float f=(float)12.0;   int a=(int)1200L

对Java对象的强制类型转换称为造型：

从子类到父类的类型转换可以自动进行
从父类到子类的类型转换必须通过造型(强制类型转换)实现
无继承关系的引用类型间的转换是非法的
在造型前可以使用instanceof操作符测试一个对象的类型

例：

public class ConversionTest{
	public static void main(String[] args) {
		double d = 13.4;
		long l = (long)d;
		System.out.println(l);
		int in = 5;
		//boolean b = (boolean)in;
		Object obj = "Hello";
		String objStr = (String)obj;
		System.out.println(objStr);
		Object objPri = new Integer(5);
		//所以下面代码运行时引发ClassCastException异常
		String str = (String)objPri;
	}
}



public class Test{ 
	           public void method(Person e) {	 //设Person类中没有getschool()						方法
		 // System.out.pritnln(e.getschool());   //非法,编译时错误
		 
		  if(e  instanceof  Student){
		          Student me = (Student)e;	//将e强制转换为Student类型
		          System.out.pritnln(me.getschool());
		  }	    
	   }
	    public static  void main(Stirng args[]){
	           Test t = new Test();
	            Student m = new Student();
	            t.method(m);
	    }
}

3.包装类

针对八种基本定义相应的引用类型—包装类（封装类）
有了类的特点，就可以调用类中的方法。

基本数据类型包装成包装类的实例 —装箱

通过包装类的构造器实现：
	int i = 500;   Integer t = new Integer(i);
还可以通过字符串参数构造包装类对象：
	Float f = new Float(“4.56”);
	Long l = new Long(“asdf”); 

获得包装类对象中包装的基本类型变量 —拆箱

调用包装类的.xxxValue()方法：
	boolean b = bObj.booleanValue()

JDK1.5之后，支持自动装箱，自动拆箱。但类型必须匹配。

字符串转换成基本数据类型

通过包装类的构造器实现：
	int i = new Integer(“12”);
通过包装类的parseXxx(String s)静态方法：
	float f = Float.parseFloat(“12.1”);

基本数据类型转换成字符串

调用字符串重载的valueOf()方法：
	String fstr = String.valueOf(2.34f);
更直接的方式：
	String intStr = 5 + “”

包装类用法举例：

int i = 500;
Integer t = new Integer(i);
装箱：包装类使得一个基本数据类型的数据变成了类。
有了类的特点，可以调用类中的方法。
String s = t.toString(); // s = “500“,t是类，有toString方法
String s1 = Integer.toString(314); // s1= “314“  将数字转换成字符串。
String s2=“4.56”;
double ds=Double.parseDouble(s2);   //将字符串转换成数字

拆箱：将数字包装类中内容变为基本数据类型。
int j = t.intValue();	// j = 500，intValue取出包装类中的数据
包装类在实际开发中用的最多的在于字符串变为基本数据类型。
String str1 = "30" ;
String str2 = "30.3" ;	
int x = Integer.parseInt(str1) ;	// 将字符串变为int型
float f = Float.parseFloat(str2) ; // 将字符串变为int型

三、类的成员之属性

语法格式：

修饰符  类型  属性名 =初值 ;

说明:修饰符private:该属性只能由该类的方法访问。
修饰符public:该属性可以被该类以外的方法访问。
修饰符缺省 ：可以被同一包中的所有类访问
类型：任何基本类型，如int、boolean或任何类。

四、类的成员之方法

方法是类或对象行为特征的抽象，也称为函数。
Java里的方法不能独立存在，所有的方法必须定义在类里。

1. 语法格式：

    修饰符 返回值类型 方法名（参数类型 形参1，参数类型 形参2，….）｛
          程序代码
          return 返回值;
    ｝
   

说明：
形式参数：在方法被调用时用于接收外部传入的数据的变量。
参数类型：就是该形式参数的数据类型。
返回值：方法在执行完毕后返还给调用它的程序的数据。
返回值类型：方法要返回的结果的数据类型。
实参：调用方法时实际传给函数形式参数的数据。

2. 方法的调用
   方法只有被调用才会被执行
   方法调用的过程分析：
   

3. 方法的重载
   在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
   重载的特点：与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。

4. 方法的参数传递
   方法必须有其所在类或对象调用才有意义。
   形参：方法声明时的参数
   实参：方法调用时实际传给形参的参数值；
   参数传递的方法是 值传递， 即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

五、类的成员之构造器（构造方法）

1. 构造器的特征：

   1. 具有与类相同的名称
   2. 不声明返回值类型。（与声明为void不同）
   3. 不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值

2. 构造器的作用:

   1. 创建对象；
   2. 给对象进行初始化

3. 语法格式：

    修饰符  类名 (参数列表) {
    	初始化语句；
    } 
   

例：

public class Animal {
private int legs;
public Animal() {legs = 4; }	   //构造器
public void setLegs(int i) { legs = i; }
public int getLegs(){return legs;}
}

4. 构造器的分类：
   根据参数不同分为：

    1. 隐式无参构造器（系统默认提供）
    2. 显式定义一个或多个构造器（无参、有参）
   

注意：

Java语言中，每个类都至少有一个构造器
默认构造器的修饰符与所属类的修饰符一致
一旦显式定义了构造器，则系统不再提供默认构造器
一个类可以创建多个重载的构造器
父类的构造器不可被子类继承

5. 构造器的重载
   构造器一般用来创建对象的同时初始化对象。
   构造器重载使得对象的创建更加灵活，方便创建各种不同的对象。
   构造器重载，参数列表必须不同。
   例：

public class Person {
    private String name;
    private int age;
    private Date birthDate;
    public Person(String name, int age, Date d) {
 	this.name = name;
 	this.age = age;
 	this.birthDate = d;
     }
     public Person(String name, int age) {
 	this(name, age, null);    
	//this.name=name; this.age=age; this.birthDate=null;
     }
     public Person(String name, Date d) {
 	this(name, 30, d);	   	
	//this.name=name; this.age=30; this.birthDate=d;
     }
     public Person(String name) {
	 this(name, 30);	   //this.name=name; this.age=30;
     }
}

六、类的成员之初始化块

对java对象进行初始化
程序的执行顺序：1.声明成员变量的默认值 ；2.显式初始化、多个初始化块依次被执行（同级别下按先后顺序执行）；3.构造器再对成员进行赋值操作

一个类中初始化块若有修饰符，则只能被static修饰，称为静态代码块(static block )，当类被载入时，类属性的声明和静态代码块先后顺序被执行，且只被执行一次。

非静态代码块：没有static修饰的代码块

   1.可以有输出语句。
   2.可以对类的属性、类的声明进行初始化操作。
   3.可以调用静态的变量或方法。
   4.若有多个非静态的代码块，那么按照从上到下的顺序依次执行。
   5.每次创建对象的时候，都会执行一次。且先于构造器执行

静态代码块：用static 修饰的代码块

 1.可以有输出语句。
 2.可以对类的属性、类的声明进行初始化操作。
 3.不可以对非静态的属性初始化。即：不可以调用非静态的属
     性和方法。
4.若有多个静态的代码块，那么按照从上到下的顺序依次执行。
5.静态代码块的执行要先于非静态代码块。
6.静态代码块只执行一次

静态初始化块举例：

class Person {
	 public static int total;
	 static {
		total = 100;
		System.out.println("in static block!");
	 }
}

public class Test {
	public static void main(String[] args) {
		System.out.println("total = "+ Person.total);
		System.out.println("total = "+ Person.total);
	}
}

七、类的成员之内部类

在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。
Inner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称。
Inner class的名字不能与包含它的类名相同；
Inner class可以使用外部类的私有数据，因为它是外部类的成员，同一个类的成员之间可相互访问。而外部类要访问内部类中的成员需要:内部类.成员或者内部类对象.成员。
分类：成员内部类（static成员内部类和非static成员内部类）
	     局部内部类（不谈修饰符）、匿名内部类

例：

public class A{
        private int s = 111;
        public class B {
	private int s = 222;
	public void mb(int s) {
	        System.out.println(s);              // 局部变量s
	        System.out.println(this.s);      // 内部类对象的属性s
	        System.out.println(A.this.s);   // 外层类对象属性s
	}
       }
       public static void main(String args[]){
	A a = new A();
	A.B b = a.new B();
	b.mb(333); 
        }}

1. 内部类的特性

Inner class作为类的成员：

可以声明为final的
和外部类不同，Inner class可声明为private或protected；
Inner class 可以声明为static的，但此时就不能再使用外层类的非static的成员变量；

Inner class作为类：

可以声明为abstract类 ，因此可以被其它的内部类继承

【注意】非static的内部类中的成员不能声明为static的，只有在外部类或static的内部类中才可声明static成员。

2. 匿名内部类
   匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。

    new 父类构造器（实参列表）|实现接口(){
       //匿名内部类的类体部分
    }
   

八、面向对象特征之 封装和隐藏

Java中通过将数据声明为私有的(private)，再提供公共的（public）方法:getXxx()和setXxx()实现对该属性的操作，以实现下述目的：

隐藏一个类中不需要对外提供的实现细节；
使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；
便于修改，增强代码的可维护性；

四种访问权限修饰符
Java权限修饰符public、protected、private置于类的成员定义前，用来限定对象对该类成员的访问权限。

对于class的权限修饰只可以用public和default(缺省)。
public类可以在任意地方被访问。
default类只可以被同一个包内部的类访问。

九、面向对象特征之 继承

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
此处的多个类称为子类，单独的这个类称为父类（基类或超类）。可以理解为:“子类 is a 父类”。

继承的作用：

1.提高代码的复用性
2.让类与类之间产生联系，提供了多态的前提
3.子类继承父类，就继承了父类的方法和属性
4.在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。
5.在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”。

继承的规则：

子类不能直接访问父类中私有的(private)的成员变量和方法。
一个子类只能有一个父类
一个父类可以派生出多个子类

调用父类的构造器：

子类中所有的构造器默认都会访问父类中空参数的构造器
当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器，且必须放在构造器的第一行
如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错

例：

 public class Person {
2 	
3 	private String name;
4 	private int age;
5	private Date birthDate;	
6
7 	public Person(String name, int age, Date d) {
8 	        this.name = name;
9 	        this.age = age;
10 	        this.birthDate = d;
11            }
12 	public Person(String name, int age) {
13 	        this(name, age, null);
14 	}
15 	public Person(String name, Date d) {
16 	        this(name, 30, d);
17	 }
18 	public Person(String name) {
19 	        this(name, 30);
20	}
21 	// ……
22   }




public class Student extends Person {
2 	private String school;
3
4             public Student(String name, int age, String s) {
5 	          super(name, age);
6 	          school = s;
7             }
8 	public Student(String name, String s) {
9 	          super(name);
10	          school = s;
11 	}
12 	public Student(String s) { // 编译出错: no super(),系统将调用父类  
                                                          无参数的构造方法。
13 	          school = s;
14 	}
15  }

子类继承父类：

若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中
对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量

十、面向对象特征之 多态

Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。
若编译时类型和运行时类型不一致，就出现多态（Polymorphism）。

前提：
需要存在继承或者实现关系
要有覆盖操作

成员方法：
编译时：要查看引用变量所属的类中是否有所调用的方法。
运行时：调用实际对象所属的类中的重写方法。

成员变量：
不具备多态性，只看引用变量所属的类。

java中有两种体现：方法的重载(overload)和重写(overwrite)。

对象的多态：在Java中,子类的对象可以替代父类的对象使用。
一个变量只能有一种确定的数据类型。
一个引用类型变量可能指向(引用)多种不同类型的对象。
子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型(upcasting)。
一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法。

Student m = new Student();
m.school = “pku”; 	//合法,Student类有school成员变量
Person e = new Student(); 
e.school = “pku”;	//非法,Person类没有school成员变量
  属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编译错误。

虚拟方法调用：

 正常的方法调用
   	Person e = new Person();
  	e.getInfo();
  	Student e = new Student();
   	e.getInfo();
  虚拟方法调用(多态情况下)
  	Person e = new Student();
    	e.getInfo();	//调用Student类的getInfo()方法
  编译时类型和运行时类型
编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类的getInfo()方法。——动态绑定

方法声明的形参类型为父类类型，可以使用子类的对象作为实参调用该方法
例：

public class Test{ 
	public void method(Person e) {
	           //……
	           e.getInfo();
	}
	public static  void main(Stirng args[]){
	           Test t = new Test();
	            Student m = new Student();
	            t.method(m); //子类的对象m传送给父类类型的参数e
	}
}

十一、抽象类

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。

用abstract关键字来修饰一个类时，这个类叫做抽象类；
用abstract来修饰一个方法时，该方法叫做抽象方法。
抽象方法：只有方法的声明，没有方法的实现。以分号结束：abstract int abstractMethod( int a );
含有抽象方法的类必须被声明为抽象类。
抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。
不能用abstract修饰属性、私有方法、构造器、静态方法、final的方法。

例：

abstract class A{   
       abstract void m1( );
       public void m2( ){
	    System.out.println("A类中定义的m2方法");
       }
}

class B extends A{
       void m1( ){
	     System.out.println("B类中定义的m1方法");
       }
}

public class Test{
       public static void main( String args[ ] ){
	     A a = new B( );
	     a.m1( );
	     a.m2( );
       }
}

抽象类是用来模型化那些父类无法确定全部实现，而是由其子类提供具体实现的对象的类。
例：
问题：卡车(Truck)和驳船(RiverBarge)的燃料效率和行驶距离的计算方法完全不同。Vehicle类不能提供计算方法，但子类可以。
解决方案：
Java允许类设计者指定：超类声明一个方法但不提供实现，该方法的实现由子类提供。这样的方法称为抽象方法。有一个或更多抽象方法的类称为抽象类。
Vehicle是一个抽象类，有两个抽象方法。

public abstract class Vehicle{
	public abstract double calcFuelEfficiency();	//计算燃料效率的抽象方法
	public abstract double calcTripDistance();	//计算行驶距离的抽象方法
}
public class Truck extends Vehicle{
	public double calcFuelEfficiency( )   { //写出计算卡车的燃料效率的具体方法   }
	public double calcTripDistance( )    {  //写出计算卡车行驶距离的具体方法   }
}

public class RiverBarge extends Vehicle{
	 public double calcFuelEfficiency( ) { //写出计算驳船的燃料效率的具体方法  }
	 public double calcTripDistance( )  {  //写出计算驳船行驶距离的具体方法}
}

十二、接口

接口(interface)是抽象方法和常量值的定义的集合。
从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。
一个类可以实现多个接口，接口也可以继承其它接口。

1. 接口的特点：

    用interface来定义。
    接口中的所有成员变量都默认是由public static final修饰的。
    接口中的所有方法都默认是由public abstract修饰的。
    接口没有构造器。
    接口采用多继承机制。
   

实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类。
接口的主要用途就是被实现类实现。（面向接口编程）
与继承关系类似，接口与实现类之间存在多态性
如果实现接口的类中没有实现接口中的全部方法，必须将此类定义为抽象类
接口也可以继承另一个接口，使用extends关键字。

通过接口可以实现不相关类的相同行为，而不需要考虑这些类之间的层次关系。
通过接口可以指明多个类需要实现的方法，一般用于定义对象的扩张功能。
接口主要用来定义规范。解除耦合关系。

接口和抽象类之间的关系

在开发中，一个类不要去继承一个已经实现好的类，要么继承抽象类，要么实现接口。