java面向对象

继承

让类和类之间产生父子关系 ,子类可以很方便的使用父类的内容,解决类之间的代码重复问题

语法格式

//父类：动物
public class Animal{}

//子类：小猫
public class Cat extends Animal{}

特点

1、java是单继承（一个子类只能有一个父类）

public class A extends B(){}//正确
public class A extends B,C(){}//错误

2、java可以多层继承

public class A extends B(){}
public class B extends C(){}

3、Object是所有类的超类，一个没有继承关系的类，会默认继承超类
4、java中的继承是一种“假继承”，“伪继承”（子类初始化之前，会先完成父类的初始化，子类使用的 内容，其实是父类的对象）

重写(override)和重载(overload)

重写：父子类中有相同的方法

//父类：动物
public class Animal{
	public void eat(){
		System.out.println("吃东西");
	}
}

//子类：小猫
public class Cat extends Animal{
		public void eat(){
			System.out.println("小猫吃鱼");
	}
}

重载：在一个类中（前提），相同的方法名，不同的参数

public class Person{
	public void buy(String commodity){
		System.out.println("我买了"+commodity);
	}
	
	public void buy(String commodity,int money){
		System.out.println("我买"+commodity+"用了"+money+"元");
	}
}

this和super的关系

this 当前的对象
super 父类的对象
this.  super. 获得对应的内容（用谁点谁）
this() super() 获得对应的构造器 -->必须是代码的第一行
在所有的构造器中 你不写的话 会默认调用父类的无参数构造super()

抽象类是特殊的父类
抽象类中有要求子类必须实现的方法

抽象类的定义

//抽象类
public abstract class Psrson{
	//抽象方法，子类必须实现
	//只有方法的定义，没有方法的代码实现
	public abstract void speak();
}

注意：
1、抽象类中一定有抽象方法吗？不一定
2、抽象方法所在的一定是抽象类吗？不一定，例如，抽象类和接口
3、抽象类能实例化吗？不能
4、抽象类中有构造器，自己不能使用，给子类赋值使用

接口

一系列规范的汇总

特点：
1、全部是抽象方法
2、全部是静态常量
3、接口和类之间是实现关系，可以多实现

public interface Message{
	public abstract void send();
}

public interface Call{
	public abstract void find();
}

//接口和类之间是实现关系，可以多实现
public class Phone implement Message,Call(){

		public abstract void send(){
			System.out.println("发邮件");
		}
		
		public abstract void find(){
			System.out.println("找人");
		}
}

接口和抽象类的区别

抽象类

在Java中被abstract关键字修饰的类称为抽象类，被abstract关键字修饰的方法称为抽象方法，抽象方法只有方法的声明，没有方法体。抽象类的特点：

a、抽象类不能被实例化只能被继承；

b、包含抽象方法的一定是抽象类，但是抽象类不一定含有抽象方法；

c、抽象类中的抽象方法的修饰符只能为public或者protected，默认为public；

d、一个子类继承一个抽象类，则子类必须实现父类抽象方法，否则子类也必须定义为抽象类；

e、抽象类可以包含属性、方法、构造方法，但是构造方法不能用于实例化，主要用途是被子类调用。

接口

Java中接口使用interface关键字修饰，特点为:

a、接口可以包含变量、方法；变量被隐士指定为public static final，方法被隐士指定为public
abstract（JDK1.8之前）；

b、接口支持多继承，即一个接口可以extends多个接口，间接的解决了Java中类的单继承问题；

c、一个类可以实现多个接口；

d、JDK1.8中对接口增加了新的特性：
（1）、默认方法（default method）：JDK
1.8允许给接口添加非抽象的方法实现，但必须使用default关键字修饰；定义了default的方法可以不被实现子类所实现，但只能被实现子类的对象调用；如果子类实现了多个接口，并且这些接口包含一样的默认方法，则子类必须重写默认方法；
（2）、静态方法（staticmethod）：JDK
1.8中允许使用static关键字修饰一个方法，并提供实现，称为接口静态方法。接口静态方法只能通过接口调用（接口名.静态方法名）。

多态 对象的多种形态

具体的代码实现：

public class Fu(){}

public class Zi extends Fu(){}

Fu fu = new Zi();

多态的前提：

1、有继承或者实现关系、
2、父类引用指向子类对象

多态的优点和缺点

优点：扩展性强,父类的变量可以赋值不同的子类对象,而调用不同的子类重写的方法
缺点：用不了子类的特性，想要使用必须强制向下转型

多态中的方法调用问题
1、多态产生，子类只能调用父类存在的方法

public class A(){
	public void buy(){
		System.out.println("购物");
	}

	public void eat(){
		System.out.println("吃东西");
	}
}

public class B extends A(){
	public void buy(){
		System.out.println("买手机");
	}
}

public class C(){
	public static void main(String args[]){
		//多态产生
		A a = new B();
		a.buy();//买手机
		a.eat();//吃东西
	}
}

2、多态产生，父类有该方法，子类没有该方法，则向上查找，执行父类的方法

public class A(){
	public void buy(){
		System.out.println("购物");
	}
}

public class B extends A(){
}

public class C(){
	public static void main(String args[]){
		//多态产生
		A a = new B();
		a.buy();//购物
	}
}

3、如果多态产生，父类有该方法，子类也有该方法，

public class A(){
	public void buy(){
		System.out.println("购物");
	}
}

public class B extends A(){
	public void buy(){
		System.out.println("买游戏机");
	}
}

public class C(){
	public static void main(String args[]){
		//多态产生
		A a = new B();
		a.buy();//买游戏机
	}
}

多态产生时，我们可以向下转型（强制类型转换）消除多态的弊端，但是向下转型可能出现 类型转换错误 , 必须是该类型的多态转换执行类型可以使用 instance 来判断 保存成功

public class A(){
	public void buy(){
		System.out.println("购物");
	}
}

public class B extends A(){
	public void buy(){
		System.out.println("买游戏机");
	}
}

public class C(){
	public static void main(String args[]){
		A a = new B();
		//判断
		if(B instanceof A){
			//向下强制类型转换
			B b = (B) a;
		}
	}
}