面向对象三大特征之继承,多态----＞第三周学习总结

一.eclipse工具的使用(这里只介绍部分高频快捷键的使用)

*alt+/------->自动补全代码(main方法,标准输出语句等)
*Ctrl+/------>单行注释,也可以取消单行注释
*Ctrl+shift+/---->多行注释
*Ctrl+shift+\---->取消多行注释
*Ctrl+shift+o---->快速导包
*alt+shift+s+c--->自动生成无参构造方法
*alt+shift+s+o--->自动生成有参构造方法
*alt+shift+s+r--->自动生成set,get方法
*alt+shift+s+v--->重写方法方法
*Alt+Shift+R ---->重命名 
*Alt+Shift+M ---->抽取方法 
*Alt+Shift+C ---->修改函数结构
*Alt+Shift+L ---->抽取本地变量
*Alt+Shift+F ---->把Class中的local变量变为field变量 
*Alt+Shift+I ---->合并变量
*Alt+Shift+V ---->移动函数和变量
*Alt+Shift+Z ---->取消重构

二.java中的代码块

1)概念:Java中的代码块就是用{}包起来的内容.
2)分类:
 	*局部代码块:
 		**在方法中定义的{}
 		**作用:限定局部变量的生命周期.
	*构造代码块:
		**在类中的成员位置中定义的{}
		**作用:在执行构造方法之前先执行构造代码块,然后对当前数据(类中的成员变量)进行初始化.将构造方法中的共性内容存储在构造代码块中.(一般情况都是通过构造方法进行初始化)
	*静态代码块:
		**在类中的成员位置定义的static{}
		**作用:随着类的加载加载,在{}里面给数据进行初始化,整个static{}优先于对象存在,而且静态代码块执行只执行一次, (因为类之加载一次)
3)代码块的优先级: 静态代码块 > 构造代码块 > 构造方法

代码块优先级的代码示例:
class Root {
      static {
        System.out.println("Root的静态初始化块");
      }
      {
        System.out.println("Root的普通初始化块");
      }
      public Root() {
         System.out.println("Root的无参数的构造器");
       }
}
// 
class Mid extends Root {
  static {
    System.out.println("Mid的静态初始化块");
  }
 
  {
    System.out.println("Mid的普通初始化块");
  }
 
  public Mid() {
    System.out.println("Mid的无参数的构造器");
  }
 
  public Mid(String msg) {
    this();
    System.out.println("Mid的带参数构造器，其参数值：" + msg);
  }
}
// 
class Leaf extends Mid {
  static {
    System.out.println("Leaf的静态初始化块");
  }
 
  {
    System.out.println("Leaf的普通初始化块");
  }
 
  public Leaf() {
    super("hello");
    System.out.println("Leaf的构造器");
  }
}
// 
public class LeafTest {
  public static void main(String[] args) {
    new Leaf();
  }
}

/*  运行结果:
	1)Root的静态初始化块
	2)Mid的静态初始化块
	3)Leaf的静态初始化块
	4)Root的普通初始化块
	5)Root的无参数的构造器
	6)Mid的普通初始化块
	7)Mid的无参数的构造器
	8)Mid的带参数构造器，其参数值：hello
	9)Leaf的普通初始化块
	10)Leaf的构造器


*/

三.面向对象三大特征–>继承

1)概念:
	*事物与事物之间所提取出来的共同属性和行为,并且可以用is a 关系表示的关系.可以实现继承关系.
	*例如: 猪,狗,猫
				共同属性:名字(name),年龄(age),毛色(color)
				共同行为:吃(eat),睡觉(sleep)
		  并且 猪,狗,猫都是可以称为动物.所以可以实现继承.都可以继承动物类(Animal)
2)格式: 关键字:extends  子类名  extends 父类名{}
3)继承的优点:
	*提高代码的复用性(使代码结构清晰)
	*提高代码维护性
	*类和类产生这种继承关系,是多态的前提条件
4)继承的特点:
	*java中,只支持单继承,不支持多继承,但是类和类之间可以支持多层继承
5)继承的缺点:类和类的产生,耦合性增强(耦合的含义是:尽量的一个类能完成的事情一个类去完成,不要产生过多的关系)
6)开发原则:
	*低耦合,高内聚
7)使用继承时注意事项:
	*子类继承父类,可以继承父类中所有非私有的成员.
	*子类继承父不能继承构造方法,但是可以通过一个关键字(super)来访问父类的构造方法.
8)继承中的关系:
	*成员变量:
		**子类继承父类,如果子类中的成员变量名称和父类的成员变量名称不一致的情况:分别访问即可.
		**子列继承父类,如果子类中的成员变量名称和父类的成员变量名称一致的情况:
			***现在子类的局部位置中找,如果找到了就使用它.
 			***如果局部位置中没有,在子类的成员位置中找,如果找到了,就使用!
 			***如果找不到,就在父类的成员位置中找,如果找到了,就使用
 			***如果还找不到,就报错了,说明访问了一个不存在的变量!
 			***遵循一个原则:就近原则
	*成员方法:
		**子类继承父类,如果子类的成员方法名称和父类的成员方法名称不一致的情况:只要通过子类对象分别调用即可!
		**子类继承父类,如果子类的成员方法名称和父类的成员方法名称一致的情况:
            ***先在子类的成员位置中是否存在该方法,存在,就调用.
            ***如果不存在,在父类的成员位置中找,如果存在,就使用
            ***如果不存在,父类中没有这个方法,就会报错!(都不存在这个方法)
	*构造方法:
		子类是不能继承父类的构造方法的,但是通过super()来访问父类的构造方法,在继承中,子类中所有的构造方法都默认访问父类的无参构造方法;相当于子类的所有构造方法的第一句话:隐藏了super().
9)this和super关键字在继承中的应用:
	*访问成员变量:
  			this.变量名  :访问本类的成员变量
 			super.变量名: 访问父类的成员变量
  	*访问成员方法:
  			this.方法名() ;访问本类的成员方法
  			super.方法名();访问父类的成员方法
  	*访问构造方法:
  		**无参构造:
			this():表示访问的是本类的无参构造方法
  			this(xx);表示访问本类的有参构造方法
  		**有参构造:
  			super() ;表示访问父类的无参构造方法
 			super(xx); 表示访问父类的有参构造方法

1)继承引出的方法重写:
	子类和父类出现一模一样的方法声明

1)final关键字
	*概念:最终的,无法更改的(是状态修饰符)
2)final关键字可以和static关键字一起使用
3)特点:
	*可以修饰类:
		**该类不能别继承
	*修饰成员方法:
		**该方法不能重写
	*可以修饰成员变量.此时变量就是常量
		**如果该变量是一个基本基本类型修饰的变量:变量的值再不能改变
		**如果该变量是一个引用类型的(Student s = new Student()),被final修饰了那么该s对象不能再重新开辟堆内存空间了(堆内存地址值不能改变)
4)使用final关键字注意事项:
	*final修饰的变量是基本类型,它的值不再改变
	*final修饰的变量是引用类型,它的堆内存地址值不再改变

//继承代码演示:
/*
	狗(具体事务)
		属性:名字(name),年龄(age),毛色(color)
		行为:吃(eat()),睡觉(sleep())
		特有行为:看门(lookDoor())
	猫(具体事务)
		属性:名字(name),年龄(age),毛色(color)
		行为:吃(eat()),睡觉(sleep())
		特有行为:抓老鼠(mouse())
	 动物类(Animal)(抽取而来)
		定义:共同属性:名字(name),年龄(age),毛色(color)
		     共同行为:吃(eat),睡觉(sleep)      
*/
class Animal {
	private String name ;
	private int age ;
	private String color;
//无参构造方法
	public Animal() {
		super();
		// TODO Auto-generated constructor stub
	}
//有参构造方法
	public Animal(String name, int age, String color) {
		super();
		this.name = name;
		this.age = age;
		this.color = color;
	}
	
	//对外提供公共方法set,get 方法
	/**
	 * @return the name
	 */
	public String getName() {
		return name;
	}
	/**
	 * @param name the name to set
	 */
	public void setName(String name) {
		this.name = name;
	}
	/**
	 * @return the age
	 */
	public int getAge() {
		return age;
	}
	/**
	 * @param age the age to set
	 */
	public void setAge(int age) {
		this.age = age;
	}
	/**
	 * @return the color
	 */
	public String getColor() {
		return color;
	}
	/**
	 * @param color the color to set
	 */
	public void setColor(String color) {
		this.color = color;
	}
	public void eat() {
		System.out.println(name + "要吃东西");
	}
	public void sleep() {
		System.out.println(name+"要睡觉");
	}	
}
class Cat extends Animal {

	public Cat() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Cat(String name, int age, String color) {
		super(name, age, color);
		// TODO Auto-generated constructor stub
	}
	public void eat(String food) {
		System.out.println(getName()+ "吃"+ food);
	}
	public void catchMuose() {
		System.out.println(getName()+"可以抓老鼠");
	}
}
class Dog extends Animal {

	public Dog() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Dog(String name, int age, String color) {
		super(name, age, color);
		// TODO Auto-generated constructor stub
	}
	public void eat(String food) {
		System.out.println(getName()+ "吃"+ food);
	}
	public void lookDoor() {
		System.out.println(getName()+"可以看门");
	}
}
public class AnimalText {
	public static void main(String[] args) {
		Cat c = new Cat("Tom",3,"金色");
		c.eat();
		c.sleep();
		c.catchMuose();
		System.out.println(c.getName()+"--"+c.getAge()+"--"+c.getColor());
	}
}

四.面向对象三大特征–>多态

1)概念:
	一个事物在不同时刻的不同体现
2)多态的前提条件:
	*有继承关系
	*有方法重写
	*父类引用指向子类对象
3)多态的优点:
	*提高了代码的复用性
	*提高了代码的扩展性
4)多态的特点:
	*成员变量:
		编译看左边.运行看左边!(等号左边编译通过,说明Fu类存在这个变量;运行看左,访问的是Fu类的变量)
	*成员方法:
		编译看左边,运行看右边(等号左边编译通过,说明父类存在这个方法;运行看右边,子类出行和父类一模一样的方法声明:方法重写)
	*静态的成员方法(不是方法重写,和类相关):
		编译看左,运行看左
	*构造方法:
		存在继承关系,还分层初始化;先让父类初始化,然后子类初始化
5)多态的弊端:
	*不能访问子类特有功能
	*解决办法:
		**创建子类的具体对象来访问子类的特有的功能(耗费空间)
	    **向下转型 
	    	Animal a = new Dog();(这是向上转型,是向下转型的前提)
	    	Dog d = (Dog)a;(优与第一种)
	*在使用向下转型时,一定要注意类型,现在父类引用所指向的内存是谁
		

/* 使用多态的案例:
定义一个动物类，里面有一个方法voice(),
定义一个类Cat,实现voice方法
定义一个Dog类，实现voice方法
定义一个Store（宠物店）类的getInstance方法：
如果传入的参数是字符串dog，则返回一个Dog对象；
否则，返回一个Cat对象。（提示：字符串中比较用equals(指定字符串)方法）
*/
import java.util.Scanner;
//动物类
 class Animal {
	public void voice() {
		System.out.println("");
	}
}
//猫类继承与动物类
class Cat extends Animal {
	public void voice() {
		System.out.println("猫是喵喵叫...");
	}
	
}
//狗类继承与动物类
class Dog extends Animal {
	public void voice() {
		System.out.println("狗是汪汪叫...");
	}

}
//宠物店类
class Store {
	public void funtion(Animal a) {
		a.voice();
	}
	public Animal getInstance(String a) {
		if("dog".equals(a)) {
			return new Dog();
		}else if("cat".equals(a)){
			return new Cat();
		}else {
			return null;
		}
	}
}
//测试类
public class Text {
	public static void main(String[] args) {
		//测试猫
		Store s = new Store();
		s.funtion(new Cat());//使用多态
		//测试狗
		Store s3 = new Store();
		s3.funtion(new Dog());//使用多态
		//测试输入
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入需要测试的字符串 : ");
		String ss = sc.nextLine();
		Store s4 = new Store();
		System.out.println("输出对应对象 :");
		System.out.println(s4.getInstance(ss));
	}
}

五.抽象类

1)概念:
	在一个类中存在一个功能,仅仅方法声明,没有方法体(抽象方法)需要将该类定义为抽象类
2)特点:
	*如果一个类中有抽象方法,那么该类一定是抽象类
	*如果一个类是抽象类,那么该类中不一定存在抽方法
	*抽象类不能实例化(不能创建对象)
	*抽象类必须强制子类完成抽象类中的抽象方法.
3)抽象类多态:父类引用指向子类对象
4)抽象方法的格式:权限修饰符 abstract 返回值类型 方法名(形式参数);
5)抽象类成员特点:
	*成员变量:既可以定义一个常量,也可以定义一个变量
	*成员方法:既可以定义抽象方法,也可以定义非抽象方法
	*构造方法:存在构造方法,既可以有参也可以是无参构造.
6)抽象类成员方法的特点:
	*成员方法如果是抽象方法,必须强制类完成的事情
	*成员方法如果故事非抽象方法,子类继承父类--来提高代码的复用性.
7)使用abstract关键字注意事项:
	*不能和下面这些关键字同用:
		**final(冲突,final所修饰的成员方法,不能被重写,而抽象方法,就是需要强制子类实现重写)
		**private(冲突,private所修饰的成员不能被继承)
		**static(冲突,和类相关,随着类的加载而加载,没有方法体,就没有意义)

//抽象类实例代码:
/*
定义一个人为抽象类(Person)
定义一个学生(Student)类继承人类
	属性:姓名(name),年龄(age)
	行为:吃饭(eat())
定义一个教师(Teacher)类继承人类
	属性:姓名(name),年龄(age)
	行为:吃饭(eat())
*/
//定义一个抽象类-->人类
class abstract Preson{
	String name;
	int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public abstract void eat();
}
//定义一个学生类继承人类
class Student extends Person{
	//重写父类eat()方法
	public void eat(){
		System.out.println("学生吃学生餐...");
	}
}
//定义一个教师类继承人类
class Teacher extends Person{
	//重写父类eat()方法
	public void eat(){
		System.out.println("教师吃教师餐...");
	}
}
//测试类
public class Test{
	public static void main(String[] args){
		//测试学生类
		Student s = new Student();
		s.setName("李明");
		s.setAge(23);
		System.out.println(s.getName()+"--"+s.getAge());
	}
}

六.接口–>比抽象更抽象的事物(面向接口编程)

1)概念:
	*体现的是事物的一种扩展性功能.(本身不具备的,经过一些学习才能具备的功能)
	*接口声明的关键字: interface
	*声明格式:权限修饰符 interface 接口名{
                代码体;
            }
2)接口中成员特点:
	*成员方法:
		**只能是抽象方法,存在默认的修饰符,public abstract
	*成员变量:
		**只能是常量,存在默认修饰符:public static final
	*构造方法:
		**接口中不存在构造方法
3)类与类,接口与接口,接口与类之间的关系
	*类与类:只支持单继承,但可以多层继承
	*类与接口:
		**实现关系:implements 一个类继承另一个类的同时,可以实现多个接口
		**格式: 类名 implement 接口1,接口2{
					重写所有接口中的所有抽象方法;
		 		}
	*接口与接口:
		**可单继承,也可多继承(提高代码复用性,父接口中所有功能,子接口也具备该功能)
4)接口中的注意事项:
	*接口中只能定义抽象方法
	*接口不能实例化
		##接口在不能实例化的情况下如何实例化
            **通过接口的子实现类来进行实例化:
                格式:
                    接口名 对象名 = new 子实现类名();
5)接口和子实现类之间的关系(实现关系):
 	 *接口的子实现类:
   		**子实现类不是具体类--->抽象类(子实现类是抽象类)不能实例化-->继续寻找存在具体的子类
   		**子实现类研究的都是具体类!因为具体的子实现类可以实例化(具体对象)

面试题:抽象类和接口之间的区别?
1)成员的区别 
    *成员变量:
	  抽象类:既可以定义常量,也可以定义变量
	  接口:只能是常量,存在默认修饰符:public static final...
	*成员方法:
	  抽象类:既可以定义抽象方法,也可以定义非抽象方法
	  接口:只能是抽象方法,存在默认的修饰符:public abstract..
	*构造方法:
	  抽象类:存在构造方法,无参/有参,对数据进行构造初始化(分层初始化)
	  接口:没有构造方法
	
2)关系的区别
	*类与类之间
		**不管这个类是抽象类还是具体类,都继承关系(extends)
		**支持单继承,不支持多继承,可以多层继承
	*类与接口之间
		**实现关系(implements)
			  一个类继承另一个类的同时可以实现多个接口!
	*接口与接口之间
		**继承关系(extends)
		  支持单继承,以及多继承!	
3)设计理念的区别
	*抽象类----在抽象类多态中使用:
    	**存在继承关系---- >体现的一种"is a"的关系
		**举例:  父类引用指向子类对象: Animal a = new Cat()	
	*接口:体现的一个事物的扩展功能(额外功能),本身不具备的功能子实现类实现(implements)接口 
	*接口之间存在实现关系:
		**体现的是一种"like a"的关系!
		**举例:
			部分猫经过学习--->产生一个"跳高的功能" (跳高猫很像猫)	

七.形参和返回值问题的研究

1)形参:
	*方法形式参数的两种类型:
		**基本数据类型:形式参数的改变对实际参数没有影响
		**引用数据类型:形式参数的改变对实际参数有直接的影响
           ***具体类
           		调用该方法,实际参数需要传递改具体类的对象
           ***抽象类
           		调用该方法,实际参数需要传递该抽象类的子类对象
           ***接口
           		调用该方法,实际参数需要传递该接口的子实现类对象
2)返回值:
	*基本数据类型
		需要什么类型,在调用的时候,就是用该具体类型去接收
	*引用数据类型
		**具体类:需要返回该具体类的对象
        **抽象类:需要返回该抽象类的子类对象
        **接口:需要返回该接口的子实现类对象

八.包和权限修饰符

1.包

1)概念
	包就是文件夹(目录)
2)包的命名规则:
	包全部都是小写,公司域名反写(cn.edu.slxy)
3)包的分类:
	单级包(单个文件夹):com
	多级包(多个文件夹):com
						qianfeng1
						qianfeng2
						qianfeng3
4)包的划分:
	按功能划分
	按模块划分

2.权限修饰符

九.内部类

1)概念:
	就是在一个类中定义另外一个类
2)内部类分类:	
    *成员内部类:
    	在外部类的成员位置
    *局部内部类:
    	在局部位置(外部类的成员方法中)定义一个类
    	
3)特点:
	<1>成员内部类:
		[1]其中的修饰符:
			***private:能够保证内部类的数据安全性
			***static:静态的成员内部类
				<被static修饰的成员内部类,它里面的成员方法(可以是静态,也可以是非静态)只能访问外部类中的静态成员>
		[2]外部类访问内部类(非静态的)成员:
		     格式:
             #外部类.内部类 对象名 = new 外部类().new 内部类();
			 #对象名.内部类成员方法名();
	 	[3]外部类访问内部类(静态的)成员:
	 		***访问静态内部类的非静态成员方法:
	 	  	 格式: 
	 	   	 #外部类名.内部类名 对象名 = new 外部类名.内部类名();
	 		 #对象名.内部类成员方法名();
	 		***访问静态内部类的静态成员方法: 
	 		 格式:
	 		 #外部类名.内部类名.静态成员方法名(); <2>局部内部类:在局部位置定义的类
		[1]特点:
			*可以直接访问外部类的成员,包括私有.
			*在外部类的成员方法中,可以通过创建局部内部类对象来访问局部内部类的成员.
			*局部内部类访问局部变量的时候,这个局部变量必须加上final(JDK8以前需要手动加,以后不需要).
				##为什么要加上final:局部变量的生命周期,随着方法的调用而存在,随着方法的掉用完毕而消失,
				而当前这个局部变量被局部内部类在进行访问,在堆内存中对象不会被立即回收,他还在继续使用
				这个局部变量,需要将这个变	量定义为常量.常驻内存-->以便局部内部类

//内部类代码示例:
package com.qinafeng2;
//定义一个外部类
class Outer{
	private int num = 100 ;
	
	//成员内部类(非静态) :一般说成员内部类都是默认非静态!
	class Inner{
	 public void show() {
		System.out.println(num);//直接可以访问外部类包括私有!
		}
	}
	//外部类的成员方法访问内部类成员
	public void method() {
		(new Inner()).show();
	}
}
//测试类
public class Test {	
	public static void main(String[] args) {
		//需要在这里来访问成员内部类的成员!
		//外部类名.内部类名 对象名 = 外部类对象().内部类对象();
		Outer.Inner oi = new Outer().new Inner() ;
		oi.show();
		(new Outer()).method();
 	}
}

十.匿名内部类

1)概念:它是内部类一种简化方式
2)格式:
	new 类名/接口名(){
		重写方法
	};
3)优点:
	省去了繁杂的代码,不需要定义类里面的子类或者接口的子实现类,写法简单.
4)匿名内部类的本质:
	继承该类或者实现了该接口的子类对象.
5)匿名内部类在局部位置使用
6)匿名内部类在开发中的使用:
	方法形式参数或者返回值中常见的就是形参是抽象类

//匿名内部类的示例代码:
	package com.qinafeng2;

interface Inner{
	  void show() ;
}
class Outer{
	
	//补全代码:
	public static Inner method() {
		//接口的匿名内部类:返回该接口的子实现类对象
		return new Inner() {
			@Override
			public void show() {
				System.out.println("helloworld");
			}			
		};
	}
}
public class Test {
	public static void main(String[] args) {
			Outer.method().show() ;
	}
}