面向对象总结

一、什么是面向对象？

    在现实生活中，随处可见的一种事物就是对象，对象是事物存在的实体，如人类、计算机、手机、动物等。解决事物问题总是将复杂的事情简单化，于是就会思考这些对象都是由哪些部分组成的。一般将对象分为两部分，动态部分与静态部分。动态部分：比如一个人会笑、会跑、会吃饭、会说话，具备行为即方法。静态部分：比如：一个人的姓名、年龄、性别等属性。

二、面向对象三大特性

1.封装   概述：封装是面向对象的核心思想，将对象的属性和行为封装起来，将对象的属性和行为封装起来的载体就是类。

public class Demo {
	private String name;//成员变量
	private int age;
	//有参构造
	public Demo(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	//无参构造
	public Demo() {
		super();
	}
	
	//忽略 get/set方法
	//特有的成员方法
}

2.继承  概述：什么是继承？is a 关系。当类与类之间存在所属关系的时候，就定义继承，Son是Fatcher中的一种，Son extends Fatcher

    继承的好处：1.提高了代码的复用性 2.让类与类产生关系

    java 中支持单继承，不直接支持多继承，因为多个父类中有相同的成员会产生不确定性

    单继承：一个子继承只能有一个直接父类。多继承：一个子类可以有多个直接父类（可以继承一个父类，但可以实现多个接口）

    Son extends Fatcher

    成员变量：1.不重名（没有影响） ；  2.重名（就近取值）；  2.1 区分（this和super的用法很相似；this：代表本类对象的引用，super：代表父类对象）

    构造方法：不能继承，默然调用；子类构造方法中 包含super()；创建子类对象，先初始化父类空间；（注意：任何类不要忘了写构造方法(有参无参)）

    成员方法：不重名（没有影响）；重名（方法重写；子父类中返回值类型一样，参数列表一样，权限一样；作用：功能增强，想保留父类方法，super.方法）

    抽象类：抽象类中可以含有抽象方法的类（格式：abstract class Demo {  抽象方法();  }）

    接口和抽象类有什么区别？

    1.抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象的子类对象，接口变量必须指向实现所有接口方法的类对象

    2.抽象类要被子类继承，接口要被类实现

    3.接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现

    4.接口里定义的变量只能是公共的静态的常量，抽象类中的变量时普通变量

    5.抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类只能为抽象

    6.抽象方法只能申明，不能实现，接口实现，抽象类是重构的结果

    7.抽象类里可以没有抽象方法；如果一个类里有抽象方法，那么这个类一定是抽象类；抽象方法要被实现，所以不能是静态的，也不能是私有的。

    8.接口可以继承接口，并可多继承，但类只能单继承

    定义一个Animal父类

public abstract class Animal {
	private int age;
	private int numLogs;

	//抽象方法eat
	public abstract void eat();

	public Animal() {
		super();
	}

	public Animal(int age, int numLogs) {
		super();
		this.age = age;
		this.numLogs = numLogs;
	}
	//getter/setter 忽略
}

public class Carnivore extends Animal{
	@Override
	public void eat() {}

	public Carnivore() {
		super();
	}
	public Carnivore(int age, int numLogs) {
		super(age, numLogs);
	}
}

public class Giraffe extends Herbivore {

	@Override
	public void eat() {
		super.eat();
		System.out.println("年龄为" + super.getAge() + "岁的" + super.getNumLogs() + "长颈鹿在吃树叶");
	}

	public Giraffe() {}

	public Giraffe(int age, int numLogs) {
		super(age, numLogs);
	}
}

public class Main {

	public static void main(String[] args) {
		Giraffe giraffe = new Giraffe();
		giraffe.setAge(2);
		giraffe.setNumLogs(2);
		giraffe.eat();		
	}
	//年龄为2岁的2长颈鹿在吃树叶
}

3.多态 ： 什么是多态？

1.多态定义：指允许不同类的对象对同一消息作出响应，同一消息可以根据发送的对象的不同而采用多种不同的行为方式

2.多态的作用：消除类型之间的耦合性

多态存在的三个必要条件

1.要有继承 2.要有重写 3.父类引用指向子类对象

定义一个父类飞机（所有飞机都会飞）

public class Plane {	 
	public void fly(){
		System.out.println("所有飞机都会飞...");
	}
}

定义一个战斗机（战斗机不仅会飞还能发射火箭）

public class Battleplane extends Plane implements Fire{
	@Override
	public void fire() {
		System.out.println("战斗机可以发射火箭");
	}
	@Override
	public void fly() {
		System.out.println("战斗机也会飞");
	}		
}

发射火箭接口

public interface Fire {	
	/*
	 * 发射火箭
	 */
	public void fire();
}

Test类

public class Main {	
	public static void main(String[] args) {
		//普通飞机可以飞  不能发火箭
		Plane plane = new Plane();
		plane.fly();		
		System.out.println("=======");		
		//战斗机
		Battleplane battleplane = new Battleplane();
		battleplane.fire();
		battleplane.fly();		
		System.out.println("======");		
		Plane plane2 = battleplane;
		plane2.fly();
		//如果普通飞机也能发射火箭,判断plane2是否是Battleplane的实现对象
		if(plane2 instanceof Battleplane){
			Battleplane battleplane2 = (Battleplane)plane2;
			battleplane2.fire();
			battleplane2.fly();
		}
	}
}

还有一个内部类  概念：可以将一个类定义放在另一个类定义的内部，这就是内部类。

定义一个员工类

public abstract class Employee {
	private int id;
	private String name;
	public abstract void work();
	public Employee(int id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
	public Employee() {
		super();
	}
	//getter/setter 忽略
}

/*
 * 在某新型公司,每一个员工都有工号,姓名; 都要工作,但是每一个员工的工作内容都不一样; 
 * 要求:使用匿名内部类创建对象
 */
public class Main {

	public static void main(String[] args) {		
		Employee emp = new Employee() {
			@Override
			public void work() {
				System.out.println("工号为" + getId() + "的员工" + getName() + "在和我一块敲代码");
			}
		};
		emp.setId(001);
		emp.setName("范冰");
		emp.work();
	}
}

到这里我们需要明确一点，内部类是编译时的概念，一旦编译成功，它就与外围类属于两个完全不同的类（当然它们之间也有联系）。对于一个名为OuterClass的外围类和一个名为 InnerClass的内部类，编译成功后，会出现两个class文件：OuterClass.class和OuterClass$InnterClass.class.

Java中内部类主要分为成员内部类，局部内部类，匿名内部类，静态内部类。

1.成员内部类也就是普通的内部类，它是外围的一个成员，所以他是可以无限制的访问外围类的所有 成员属性和方法，尽管是private的，但是外围类要访问内部类的成员属性和方法则需要通过内部类实例来访问。