JAVA总结 DAY09 1024

DAY09

一、抽象类

1.抽象方法
1、抽象：抽取像的、相同的、相似的内容出来
2、抽象方法：只有方法声明，而没有方法实现的方法，就是抽象方法
在各个子类中，对于某个方法都有自己不同的实现，所以实现各不相同，无法抽取，只能抽取方法的声明上来，在父类中，方法就只有方法声明没有方法体。就是抽象方法。
3、定义格式：
没有方法实现，连大括号都没有，直接在方法声明后面加上一个分号，表示方法定义结束 public abstract void test();
为了将方法标记为抽象方法，需要在方法前面加上一个abstract关键字

2.抽象类
1、可以定义抽象方法的类，就是抽象类
2、定义格式：

 	abstract class 类名 {
 	 	
}

3.抽象类的特点
1、抽象类和抽象方法都需要使用abstract关键字修饰
抽象类：abstract class {}
抽象方法：public abstract void test();
Public private protected这些称之为修饰符
2、抽象类和抽象方法的关系：
抽象方法所在的类必须是抽象类
抽象类中未必一定都定义抽象方法，抽象类中未必存在抽象方法
3、抽象类的实例化（抽象类如何创建对象）
抽象类不能直接实例化（不能创建对象）
定义抽象类的子类，由子类创建对象，调用方法
4、抽象类子类
在子类中，将父类所有的抽象方法全部重写（实现），子类就成了一个普通类，就可以创建对象
在子类中，没有将父类中所有的抽象方法全部实现，子类就还是一个抽象类，还需要使用abstract关键字修饰子类。
代码示例

	public static void main(String[] args) {
		//Animal an = new Animal();//抽象类不能直接实例化
		Cat c = new Cat();
	}

abstract class Animal {
	//抽象方法
	public abstract void speak();
 
/*	public void sleep(){//抽象类中不一定全部是抽象方法
		System.out.println();
	}*/
}
class Cat extends Animal {
	@Override
	public void speak(){
		System.out.println("喵喵喵");
	}
}
abstract class Pig extends Animal {
	@Override
	public void speak(){
		System.out.println("哼哼哼");
	}
	public abstract void eat();
}

4.抽象类成员特点
1、成员变量：可以定义变量，也可以定义常量，但是不能被抽象
2、构造方法：有
虽然本类无法创建对象，但是抽象类一定有子类，子类会访问父类的抽象方法。
是否有构造方法，不取决于是否可以创建对象，而是取决于是否可以定义成员变量。如果可以定义成员变量，那么就需要初始化成员变量，就是构造方法来完成的。
3、成员方法：
既可以是抽象方法：强制子类重写
也可以是非抽象方法：用于给子类继承，提高代码的复用性

二、多态
1.多态的概述
1、多态：事物的多种状态
对象的多态性：同一个对象，可能具有不同的名称，同一个对象，有不同的类型的引用指向它。本质：同一个物体有不同的名称和描述。
类型的多态性：同一个类型，可能具有不同的子类实现。同一个类型引用，有不同的对象实现。本质：同一个名字和描述，可以在不同场景下有不同的真实实现。
2、多态的前提：
1、要有子父类的继承（实现）关系
2、有方法的重写
3、父类的引用指向子类的对象

2.在多态中成员变量的访问特点
1、编译看左边，运行看左边
2、编译的时候，要看【=】左边的引用的类型中，是否有该变量的定义，如果有，就编译成功，如果没有，就编译失败。
3、运行的时候，要看【=】左边的引用所属类型中，真正如何给变量赋值的。获取到的是引用父类的赋值结果。

3.多态中成员方法的访问特点
1、编译看左边，运行看右边
2、编译的时候，要看【=】左边的引用所属的类型中，是否有该方法的定义，如果有，就编译成功，如果没有，就编译失败。
3、运行的时候，要看【=】右边的对象所属的类型中，是如何实现这个方法的。最终运行的是子类重写过的方法实现。
代码示例

	public static void main(String[] args) {
		/*
			多态中成员方法的访问特点
		*/
		Animal a = new Cat();//父类的引用指向子类的对象
		a.speak();
		//成员方法的访问特点，编译看= 左边，运行看=右边
		//a.eat();
		//成员变量访问特点，编译看=左边，运行也看=左边
		System.out.println(a.age);
	}

class Animal {
	int age = 10;
	public void speak(){
		System.out.println("我是动物");
	}
}

class Cat extends Animal {
	int age = 20;
	String color;
	@Override
	public void speak(){
		System.out.println("喵喵喵");
	}

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

4.多态中静态方法的访问特点
1、编译看左边，运行看左边
2、编译的时候，要看【=】左边的引用所属的类型中，是否有该方法的定义，如果有，就编译成功，如果没有，就编译失败
3、运行的时候，要看【=】左边的引用所属的类型中，如何实现该方法的。最终运行的是引用所属类型中该方法的实现。（方法属于类，和父类的方法不属于重写关系）
4、静态最终解释：
静态变量：存储在类的字节码中的变量，被所有对象所共享，不随着对象的变化而变化，都有相同的值，所以称为静态变量
静态方法：只会根据引用所属的父类，来决定运行的内容，运行内容，不会随着子类的变化而变化，都是引用所属的父类的方法实现，所以称为静态方法。

5.向上向下转型
1、向上转型：
使用子类的引用指向子类的对象（正常情况）
多态中，使用父类的引用指向子类的对象（向上转型）
本质：缩小了对象本身的访问范围，减少了访问的权限（只能访问父类中定义的内容）
2、向下转型：
概念：
让指向子类对象的父类引用，【恢复】成子类的引用
格式：
子类类型 引用名称 = (子类类型)父类类型的引用
SuperMan sm = (SuperMan)m;
本质：
【恢复】子类类型原本就有的访问范围
代码示例

public static void main(String[] args) {
		Man m = new SuperMan();//向上转型.自身的访问权限变小了
		System.out.println(m.name);//普通人的名字
		m.business();
		//m.fly();普通人不能飞，不能调用fly()方法
		//向下转型
		SuperMan sm = (SuperMan)m;
		//double b = 20.3333;
		//int a = (int)b;
		System.out.println(a)；
		sm.fly();
	}
}

class Man {
	String name = "KangKang";
	public void business(){
		System.out.println("卖煎饼果子");
	}
}
class SuperMan extends Man{
	String name = "SpiderMan";
	public void business(){
		System.out.println("敲代码");
	}
	public void fly(){
		System.out.println("我要去拯救世界了");
	}
}

6.多态的好处
1、提高了代码的可扩展性
2、在方法的参数列表中，可以定义父类类型的引用，将来调用的时候，所有的子类类型的对象，都可以作为方法的实际参数。
3、不在方法的参数列表中，就在普通的方法体中，使用父类的类型指向子类的对象，也能提高代码的可扩展性。对象的来源非常广泛，不仅仅是new出来的，（还可能是通过反射获取的，通过文件读取的，还可能是网络传递的，在写代码的编译阶段，无法知道对象具体的子类类型的）需要使用父类类型的引用，操作不知道的子类类型的对象。

三、接口

1.接口的概述
1、广义：一切定义规则的都是接口
2、狭义：java中用于定义方法命名的规则就是接口
Java接口中，全都是方法的声明，都是抽象方法
3、好处：
一旦将命名规则定义出来，【方法的调用】和【方法的实现】就分离开了，可以提升开发效率，降低代码的耦合性

2.接口的特点
1、接口的定义：使用interface关键字，编译也是生成一个【.class】(字节码文件)文件
interface 接口名称 {
方法声明的定义;
}
2、接口中，只可以声明抽象方法（只能定义方法起名字的规则）
3、类可以实现接口：使用implements关键字
实现：接口中只有方法名称的定义，在类中把接口方法的真正完成逻辑写出来
class 类名称 implements 接口名称 {
对接口中方法的实现;
}
4、接口的实例化：不能直接实例化
定义实现类，实现接口，类创建对象，对象调用方法
5、接口的实现类：
如果是一个抽象类，该类没有实现接口中的所有抽象方法
如果是一个普通类，该类实现了接口中的所有抽象方法
代码示例

	public static void main(String[] args) {
		//MyClass m = new MyClass();
		//m.test();
		// 接口
	}
}
interface  MyInter {
	public  void test();
	public  void test1();
}
//没有全部实现接口中的所有方法，必须是一个抽象类
abstract class MyClass implements MyInter {
	public void test(){
		System.out.println("test");
	}
}
//实现了接口中的所有方法变为一个普通类可以进行实例化
class MyClass1 implements MyInter {
	public void test(){
		System.out.println("test");
	}

	public void test1(){
		System.out.println("test1");
	}

}

3.接口中成员的特点
1、成员变量：
只能是常量，不能是变量
默认加上public static final
2、构造方法：
没有构造方法。接口中无法定义成员变量，所以不需要使用构造方法给成员变量初始化赋值。
虽然接口有自己的实现类，但是对于实现类而言，不去访问接口中的构造方法，而是访问实现类的父类的构造方法。（父类是亲爹、接口是干爹，找亲爹的构造方法，而不是干爹的）
3、成员方法：
只能是抽象方法，不能是非抽象方法
默认加上public abstract

4.类与类、类与接口、接口与接口之间的关系
1、类与类
继承的关系，使用extends
可以单继承、不可以多继承、可以多层继承
2、类与接口：
实现关系，使用implements 实现
可以单实现、也可以多实现、不能多层实现（一旦实现变成了一个类）
多实现的格式：
class 实现类类名 implements 接口1, 接口2, 接口3…{
重写所有接口中的所有抽象方法
}
多实现没有安全隐患：即使两个接口中有一样的方法声明，但是在类中也只有一个实现

在继承一个父类的前提下，还可以实现多个接口
格式： 	 
 	class 子类类名 extends 父类类名 implements 接口1, 接口2.....{
 	 	//重写父类和所有接口中的所有抽象方法

}
3、接口与接口：
继承关系，使用extends
可以单继承、也可以多继承、可以多层继承
多继承的格式：
interface 接口名 extends 父接口1, 父接口2…{
相当于继承了所有父接口的所有抽象方法
}

4、类和接口的区别（设计区别）：
抽象类：定义物体本身具有的固有属性和行为
接口：定义物体通过学习、训练而扩展出来的行为，

总结
java面向对象三大特性之一，要更完善自己写代码的思想！！！