Java基础学习第五章之面向对象上

Java语言面向对象特征： 封装、继承、多态。抽象是所有计算机语言都有的特性。
封装：只关注一个主题，忽略与主题无关的属性。提供了public、protected、private 三个访问控制符来实现良好的封装。
继承：一个类可以拥有另一个类的所有属性和方法(构造方法除外)。java 继承 使用关键字 extends 。继承 增加了代码的重用性，也是多态的表现。Java 只支持单继承，只能有一个直接实现的父类。
多态：就是一个对象可以体现多种型态。Java中多态的实现只要体现在方法的重载和重写上。子类继承父类或是一个类实现一个接口。在创建对象和运行时，体现多态性。


继承和组合关系 都是代码重用的重要手段，有什么区别，
  继承 是一个子类继承一个父类，拥有类的所有的属性和方法，存在一个 is a的关系，有多态性，很好的体现。
  组合：是has a 的体现，并不能体现多态性。 


Java 语言可以自定义类、属性、方法。类是一种自定义的数据类型，可以使用类来定义属性、方法。用类来生成对象(实例)，类是对象的抽象描述，是对象的模板。对象是类的实例，是具体类的属性和方法的体现。
定义类的规则
访问控制符  Class 类名{


}
类名命名规范：常用驼峰命名法,有意义的单词构成，不要用拼音，如多个单词，首字母大写，其他小写，中间不使用任何的分割符。如
public class Student{} //学生类
public class MyCompany{} //我的公司类

构造器：构造器是用来创建对象实例的特殊方法。和类名相同，没有返回值，可以带参，可以为空。系统会默认为每个类提供一个无参的构建方法，如果自己提供，默认方法会不可用。如：

public class Student
      	public Student(){
		
	}
}
修饰类可以使用关键字abstract 或 final.
public abstract class Person {

	 public abstract String say();//抽象方法
	 
	 public String say(String str){
		 return str;
	 }
}

使用abstract 修饰的类称为抽象类，抽象类中可以定义抽象方法，只有方法体的定义没有实现。也可以定义普通的方法。只要是用abstract 修饰的方法，类一定要定义成抽象类。抽象类不能实例化。抽象类 是需要子类去实现的，所以访问修饰符不能定义成pricate 。子类继承后，需要实现所有的抽象 方法，否则子类要定义成抽象类。
final 定义的类成为最终类，最终类不能被继承，能通过 new 创建 实例，java.long.String 是一个最终类，最终类，对hibernate 的懒加载有影响。
static 可以修饰属性方法，或是单模块自己使用。
  static 修饰的方法或属性称为类方法和类属性，并不属于某一个实例对象，而是属于类，在加载类的时候，生成这些方法或是属性。要比构造方法先执行。

public abstract class Person {

	public static final String PERSON_NAME = "zs"; //类属性 
	public abstract String say();//抽象方法 
	/**
	 * 类方法
	 * @param far 多远
	 * @return 
	 */
	 public static String run(String far){
		 return far;
	 }
	 public String say(String str){
		 return str;
	 }
}

this 关键字，在每一个非静态方法中都可以使用这个 this 关键字，表示对本对象类型的引用。

public class PersonInstance{
	public  static String say2() {
		return null;
	}
	public String say1() {
		return null;
	}
	
	public String say() {
		this.say1();//普通方法可以使用this 来调用
		return null;
	}
	public static void main(String[] args) {
		PersonInstance.say2();// 静态方法可以使用类来调用
//		PersonInstance a= new Person();// 不能实列化
		PersonInstance pi= new PersonInstance();
		pi.getAge();
	}

}

方法的所属性
 在结构化编程语言中函数是第一公民，而在面象对象编程中类是第一公司，方法要存在于类中，方法只能属于类或是对象，只有类或是对象才能做为调用者调用方法。方法不能存在于类之外。
 Java 语言中方法的所属性体现在如下几个方面
方法不能独立定义，必须定义在类中。
从逻辑意义上讲，方法要么属于类，要么属于对象。
永远不能独立运行方法，必须是类或是对象做为调用者调用。

方法的参数传递机制
  Java 方法里只有一种传递方法，那就是值传递。所谓值传递就是实际参数的副本（复制品）传入方法内，而参数本身不受影响。
  示例：基本数据类型
   public class TestPromotiveTransfer {
   /**
    * 基本数据类型 数据交换
    * @param a
    * @param b
    */
	public static void swap(int a,int b){
	 	 int temp=a;
		  a=b;
		  b=temp;
		  System.out.println("swap方法的数据：a="+a+" b="+b);
	}
	public static void main(String[] args) {
		int a=6;int b=9;
		swap(a, b);
		System.out.println("main方法的数据：a="+a+" b="+b);
	}
  }
 结果：
   swap方法的数据：a=9 b=6
   main方法的数据：a=6 b=9
 
  引用类型：
 package com.soliucheng.domain;

public class TestPromotiveTransfer {
   /**
    * 基本数据类型 数据交换
    * @param a
    * @param b
    */
	public static void swap(int a,int b){
	 	 int temp=a;
		  a=b;
		  b=temp;
		  System.out.println("swap方法的数据：a="+a+" b="+b);
	}
	/**
	 * 引用数据类型 数据交换
	 * @param dw
	 */
	public static void DataWrapSwap(DataWrap dw){
		int temp=dw.a;
		dw.a=dw.b;
		dw.b=temp;
		System.out.println("DataWrapSwap方法的数据：dw.a="+dw.a+" dw.b="+dw.b);
	}
	public static void main(String[] args) {
		int a=6;int b=9;
//		swap(a, b);
		DataWrapSwap(new DataWrap(a, b));
		System.out.println("main方法的数据：a="+a+" b="+b);
	}
	
 }
// 实体类  是引用类型
class DataWrap{
	public int a; 
	public int b;
	public DataWrap(int a,int b){
		this.a=a;
		this.b=b;
	}
}

结果：
 DataWrapSwap方法的数据：dw.a=9 dw.b=6
 main方法的数据：a=6 b=9

 结论:只是改变了副本的数据，而原对象本身值并没有改变，所以Java中 只有值传递，而没有引用传递。

可变参数：在Jdk 1.5 时，增加了新特性。可变参数，实际上是数组。
做为参数，一定是方法在一起用运的， 参数格式 type ... variableName ,可变参数 只能放在参数列表的最后一个参数中。

	// 测试可变参数
      public static void changeParam(int num,String ... param){
		for(String key:param){
			System.out.println(key);
		}
     }

	public static void main(String[] args) {

		changeParam(4,"JAVA 基础","JAVAEE","JAVAWEB"); // 从传参的方式可以看出是一个String 类型的数组 所以，String ... param 可以写                                                             //成 String [] param,当然，写成数组 调用方式 就需要重新new 一个数组出来。
	}
	
  结果：
 	JAVA 基础
      JAVAEE
      JAVAWEB

递归算法： 方法的自我调用。自己去了解吧，不说了。哈哈...




方法重载：Java语言中允许同一个类中，有相同的方法名，但行参列表不同的方法存在，这就组成了方法的重载。
  特点：同一个类中，方法名相同，参数列表不同，与返回值无关。方法重载是多态的主要表现。

  public class TestPromotiveTransfer {
     public static void result(Object a ,Object b){
		System.out.println("object "+(Integer.valueOf(a.toString()) +Integer.valueOf(b.toString())));
	}
	
	public static void result(int a ,int b){
		System.out.println("int "+ (a + b));
	}
	public static void result(double a ,int b){
		System.out.println("double "+ (a + b));
	}
	public static void result(long a ,int b){
		System.out.println("long "+ (a + b));
	}
 }

作用：方便调用者使用 多态。调用时，参看参数类型，参数是什么类型，调用什么方法。
当可变参数做为参数时，方法重载。
public class TestPromotiveTransfer {
	public void result(String str){
		System.out.println("str ="+str);
	}
	public void result(String ... str){
		for(String key:str){
			System.out.println("key ="+key);	
		}
		
	}

  	public static void main(String[] args) {

		TestPromotiveTransfer tt = new TestPromotiveTransfer();
		tt.result("abc");
	}
}
结果：str =abc

成员变量和局部变量：
  成员变量是定义 在类中的变量，或者叫属性，字段。
  局部变量是定义在方法中、形参、代码块中的变量。
 Java 语言中有两类变量，一类是成员变量 另一类则是局部变量。使用 static 修饰的变量是成员变量或叫类变量，不使用static 修饰的是实例变题，属于某个对象。

   public static final String MARK_STR="1"; // 成员变量
   public String MARK_STR_NO="0";// 实例变量
   public static  int MARK_STR_INT; // 成员变量 系统加载成员变量时会 自动赋值 数值型 int 赋为 0,引用类型（String）都会 赋为 null                                    		//boolean 会赋值 为false
  
成员变量的生命周期：和类的生命周期相同，在类加载的时候，创建成员变量，在类销毁时，同时销毁此变量。
局部变量的生命周期：在方法的中定义，定义时创建局部变量，方法结束，此局部变量销毁。

访问控制符：java 提供了三个访问控制符，四种访问权限，有private、protected、public。可以修饰类，属性，方法等。
pricate 修饰的方法，只能被本类访问。
default 修饰的方法，能在本类和本包中访问。
protected 修饰的方法，能在本类,子类和本包中访问。
public 修饰的方法，能在本类 子类和本包，其他包中访问。


通常我们封装一个JavaBean,属性私有，方法公有，为每个私有属性提供getter 和 setter 方法。


package （打包） 和 import（导包）
为了表示防止同名类冲突引入了package,同时，也能表示层次关系。放在一个类的第一行。命名如 com.公司名.公能名称。 com.picc.domain
package com.picc.domain;
当别人要使用这个包下的这个类时，需要使用import 导入这个包就可以了。
java 工具中 提供给包下的类打包 javac -d . xx.java  。 javac 是编译 -d 是一个目录(Directory) . 表示当前目录 xx.java 是要编译的java 原文件。

package com.soliucheng.domain;
 
public class TestPromotiveTransfer {
  public static void main(String[] args) {
  System.out.println("hello world");	
 }
}


同时，会生成这个com/soliucheng/domain/ 这个文件夹。
 

 静态导入：JDK 1.5 新增的特性。可以静态的导入一个类。
package com.soliucheng.domain;
import static java.lang.System.*;
public class TestPromotiveTransfer {
  public static void main(String[] args) {
  out.println("hello world");	// 使用静态导入
 }
}

在编译和运行时，和平时非静态导入一样，没有区别。 lang 是language 的缩写，是一个使用平凡，不需要人为导入的工具包。

父类：
 package com.soliucheng.domain;

public class Bird {
	 private int age;
	 private String name;
	public Bird(){
     System.out.println("父类构造方法");		
	}
	public Bird(int age,String name){
		this.age=age;
		this.name=name;
				
	}
	public String say(String str){
		System.out.println("父类");
	  return str;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

}
子类：
package com.soliucheng.domain;

public class Ostrich extends Bird {
   private String colour;
    /**
    * 构造方法 也可以重载 ：同一个类中方法名相同，参列列表不同。
    */
   public Ostrich(){
	   System.out.println("子类构造方法");
   }
   /**
    * 子类不能 继承父类的构造方法
    */
   public Ostrich(int age,String name,String colour){
	   super(age,name);// 通过super 调用父类的构造方法
	   this.colour=colour;
   }
    /**
     * 重写父类的方法
     */
	@Override
	public String say(String str) {
		System.out.println("子类");
		return super.say(str);
	}
	
	public static void main(String[] args) {
		
		Ostrich o = new Ostrich();
		String str = o.say("abc");
		System.out.println(str);
		
		Ostrich os = new Ostrich(1,"abc","black"); //调用子类构造方法 创建子类
		System.out.println(os.toString());// 调用对象的toString 以字符串返回的对象表示
	}

	public String getColour() {
		return colour;
	}

	public void setColour(String colour) {
		this.colour = colour;
	}
	@Override
	public String toString() {
		return "colour="+this.colour+" age="+this.getAge();
	}

}

结果：
  父类构造方法
  子类构造方法
  子类
  父类
  abc
  colour=black age=1
 
深入构造方法：构造方法 也可以重载 ：同一个类中方法名相同，参列列表不同。

 
继承的特点：Java 使用关键字 extends 来实现，实现继承的类称为子类，被实现的类称为父类。子类做为父类的扩展。java 中 只支持单继承，一个类，只有一个直接父类，所有类 都是 java.lang.Object 的子类，在创建子类时，一定是先创建父类。
示例如下：

父类：
 package com.soliucheng.domain;

public class Bird {
	 private int age;
	 private String name;
	public Bird(){
     System.out.println("父类构造方法");		
	}
	public Bird(int age,String name){
		this.age=age;
		this.name=name;
				
	}
	public String say(String str){
		System.out.println("父类");
	  return str;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

}
子类：
package com.soliucheng.domain;

public class Ostrich extends Bird {
   private String colour;
    /**
    * 构造方法 也可以重载 ：同一个类中方法名相同，参列列表不同。
    */
   public Ostrich(){
	   System.out.println("子类构造方法");
   }
   /**
    * 子类不能 继承父类的构造方法
    */
   public Ostrich(int age,String name,String colour){
	   super(age,name);// 通过super 调用父类的构造方法
	   this.colour=colour;
   }
    /**
     * 重写父类的方法
     */
	@Override
	public String say(String str) {
		System.out.println("子类");
		return super.say(str);
	}
	
	public static void main(String[] args) {
		
		Ostrich o = new Ostrich();
		String str = o.say("abc");
		System.out.println(str);
		
		Ostrich os = new Ostrich(1,"abc","black"); //调用子类构造方法 创建子类
		System.out.println(os.toString());// 调用对象的toString 以字符串返回的对象表示
	}

	public String getColour() {
		return colour;
	}

	public void setColour(String colour) {
		this.colour = colour;
	}
	@Override
	public String toString() {
		return "colour="+this.colour+" age="+this.getAge();
	}

}

结果：
  父类构造方法
  子类构造方法
  子类
  父类
  abc
  colour=black age=1
 
深入构造方法：构造方法 也可以重载 ：同一个类中方法名相同，参列列表不同。

多态：Java 引用引用变量支持两种类型，一个是编译是类型，一个是运行时类型，编译时类型由声明该变量时使用的类型决定，运行时的类型由实际赋给该变量的对象类型决定，如果，声明变量类型与赋值给变量对象的类型不一致时，就会出现多态。
示例：父类  

package com.soliucheng.domain;

public class Bird {
	public String result="父类";
	 private int age;
	 private String name;
	public Bird(){
     System.out.println("父类构造方法");		
	}
	public Bird(int age,String name){
		this.age=age;
		this.name=name;
				
	}
	public String say(String str){
		System.out.println("父类");
	  return str;
	}
	public void fly(){
		System.out.println("父类飞");
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

}

子类：
package com.soliucheng.domain;

public class Ostrich extends Bird {
   public String result="子类";
   private String colour;
   /**
    * 构造方法 也可以重载 ：同一个类中方法名相同，参列列表不同。
    */
   public Ostrich(){
	   System.out.println("子类构造方法");
   }
   /**
    * 子类不能 继承父类的构造方法
    */
   public Ostrich(int age,String name,String colour){
	   super(age,name);// 通过super 调用父类的构造方法
	   this.colour=colour;
   }
    /**
     * 重写父类的方法
     */
	@Override
	public String say(String str) {
		System.out.println("子类");
		return super.say(str);
	}
	@Override
	public void fly(){
		System.out.println("子类飞");
	}
	public static void main(String[] args) {
		
		Bird bird =	new Ostrich(1,"abc","black");//自动拆装箱，可以把子类对象直接赋值给父类，而与父类没任何区别
		System.out.println(bird.result); // 属性 不具多态性，而方法 具多态性。
		bird.fly();
	}

	public String getColour() {
		return colour;
	}

	public void setColour(String colour) {
		this.colour = colour;
	}
	@Override
	public String toString() {
		return "colour="+this.colour+" age="+this.getAge();
	}

}

结果：
   父类
   子类飞
  
  结论：子类对象赋值给父类变量时，就会有多态发生，编译时，表同出变量类型，运行时，表现出赋值类型，属性没有多态性，方法具有多态性。

instanceof 的使用：instanceof 是在强转类型时，检查被转类型是否是接收类型的子类或是子实现。如果是 返回 true 否 返回false
   System.out.println("hello" instanceof String); // 字符串hello 是不是 String 类  
   System.out.println("hello" instanceof Comparable); // 字符串hello 是不是 实现了Comparable 接口
   Object o = 1;
   System.out.println(o instanceof String); // 数值型的 Object 是否是 String 类
 
  结果：
      true
      true
      false

继承和组合：继承和组合都代码重用的重要手段，继承因破坏了代码封装，所以又引入了组合，组合，作为类的一个属性而存在，继承是 is a 的关系，而组合是 是 has a 的关系。组合，类似于Spring 注入的用法。

 示例：
package com.soliucheng.domain;

public class Bird {
	public String result="父类";
	 private int age;
	 private String name;
	public Bird(){
     System.out.println("父类构造方法");		
	}
	public Bird(int age,String name){
		this.age=age;
		this.name=name;
				
	}
	public String say(String str){
		System.out.println("父类");
	  return str;
	}
	public void fly(){
		System.out.println("父类飞");
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

}

package com.soliucheng.domain;

public class Ostrich  {
	private Bird bird;// 作为 类的一个私有属性
	// 利用代码块初始化 属性
	{
		bird  = new Bird(1,"jom");// 给属性类 初始化
	}
	public static void main(String[] args) {
		Ostrich os = new Ostrich();
		os.test();
	}
	
    public void test(){
    
     	bird.fly(); // 调用属性方法
    }
	public Bird getBird() {
		return bird;
	}

	public void setBird(Bird bird) {
		this.bird = bird;
	}
	
 

}

 结果： 父类飞


代码块和静态代码块：代码块和静态代码块都是实现初始化的操作。先执行静态代码块--》代码块--》构造方法。
示例：
  	{
		System.out.println("代码块");
		
	}
	static{
		System.out.println("静态代码块");
	}

  public static void main(String[] args) {
		
		Bird bird =	new Ostrich(1,"abc","black");//自动拆装箱，可以把子类对象直接赋值给父类，而与父类没任何区别
		System.out.println(bird.result); // 属性 不具多态性，而方法 具多态性。
		bird.fly();
	}

   结果：
        静态代码块
	  代码块
	  父类
        子类飞