java 继承，多态，抽象，接口

继承

package com.wanyan.extend;

/**
 * 
 * @author 顽岩
 * @date  2021年8月6日
 */

/*
 * 一.面向对象的特征之二:继承性
 * 
 * 继承格式：
 *  class 子类名  extends 父类名{}
 * 
 * 1）一旦子类A继承父类B以后，子类A 中就获取父类B中声明的所有属性和方法
 * 特别的是，父类中声明为private的属性或者方法，子类继承父类以后，仍然认为获得父类中的私有属性或方法
 * 只是因为封装性的影响，使得子类不能直接调用父类结构
 * 
 * 2)子类继承父类以后，还可以声明自己特有的属性和方法，实现功能拓展
 * 
 * 
 * 继承的好处：
 * 1.减少代码的繁琐，提高了代码的复用性
 * 2.便于功能的扩展
 * 3.为以后多态性的使用，提供了前提
 * 
 * ctrl + t : 可以看到类之间的继承结构
 * 
 * 二.java关于继承的规定
 * 1.一个类可以被多个子类继承
 * 2.一个类只有一个父类（单继承性）
 * 3.多层继承  (A继承B，B继承C，C继承D..)
 *   子类直接继承的父类，叫做直接父类，间接继承的父类，叫做间接父类
 * 4.子类继承父类以后，就获得了直接父类以及所有间接父类中声明的属性和方法
 * 
 * 
 * 三.1.如果我们没有明显的声明一个类是父类的话，则此类继承java.lang.object类
 *    2.所有的java类(除了java.lang.object类之外)，都直接或间接的继承于java.lang.object类
 *    3.意味着，所有类都具有java.lang.object类功能
 *    
 * 
 * 
 */
public class ExtendTest {
       
	public static void main(String[] args) {
		Person person = new Person();
		Student student = new Student();
		student.setName("tom");
		System.out.println(student.getName());
	}
}

多态

package com.wanyan.polymorphism;

/**
 * 
 * @author 顽岩
 * @date  2021年8月9日
 * 
 * 
 */

/*
 * 
*  面向对象特征之三:多态性
*   1.理解多态性:可以理解为一个事物的多种形态。
*   2.何为多态性:
*   对象的多态性:父类的引用指向子类的对象（或子类的对象赋给父类的引用)
*   3．多态的使用:虚拟方法调用
*    有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
*    *总结:编译，看左边;运行，看右边。
*
*	4.多态性的使用前提:类的继承关系方法的重写
*
*   5.对象的多态性，只适用于方法，不适用于属性
*   
*   6.向下转型:使用强制类型转换符。
*   
*   
*/




public class PersonTest {

	public static void main(String[] args) {
		Person person = new Person();
		person.eat();
		
		// 对象的多态性，父类引用指向子类的对象
		Person person1 = new man();
		// 多态的使用，当调用子父类同名同参数的方法时，实际执行的事子类重写方法
		person1.eat();
		person1.walk();
		
		//有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型
		//编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。
		Person person2 = new woman();
		person2.eat();   //可以
		person2.walk();  //可以
		// person2.name();  报错
		
	
		//如何才能调用子类特有的属性和方法
		//向下转型:使用强制类型转换符。
           woman p = (woman)person2;    
		   p.name();  // 可以调用子类特有方法
	}
	
}

抽象类

package com.wanyan.abstract1;
/**
 * 
 * @author 顽岩
 * @date  2021年8月12日
 */

/*
 *abstract关键字的使用
 *	1.abstract:抽象的
	2.abstract可以用来修饰的结构:类、方法
	3. abstract修饰类:抽象类
		>此类不能实例化
		>抽象类中一定有构造器，便于子类实例化时调用（涉及:子类对象实例化的全过程)
		>开发中,都会提供抽象类的子类，让子类对象实例化，完成相关的操作
	4. abstract修饰方法。抽象方法
		>拍象方法只有方法的声明，没有方法体一
		>包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
		>若子类重写了父类中的所有的抽象方法后，此子类方可实例化
		若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰

 * 
 * 5.abstract使用上的注意点:
    	5.1.abstract不能用来修饰:属性、构造器等结构
		5.2.abstract不能用来修饰私有方法、静态方法、final的方法、final的类

 * 
 * 
 * 
 */

public class AbstractTest {

	public static void main(String[] args) {
		
	}
	
	
}

//抽象类
abstract class Person{
	String name;
	int age;
	
	
	public Person() {
		super();
	}


	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	public void eat() {
		System.out.println("eat");
	}
	
	
	//抽象方法
	abstract public void walk() ;
}

class Student extends Person{
	

	public Student(String name, int age) {
		super(name,age);
		
	}
	
	//子类必须实现抽象类中的抽象方法
	public void walk() {
		
		
		}
	
}

接口

package com.wanyan.interface1;

import javax.print.attribute.standard.MediaName;

/**
 * 
 * @author 顽岩
 * @date  2021年9月2日
 */

/*
 * 	1,接口使用interface来定义
	2.Java中,接口和类是并列的两个结构
	3.如何定义接口:定义接口中的成员
	
		3.1 JDK7及以前:只能定义全局常量和抽象方法
					>全局常量:.public static final的.但是书写时，可以省略不写
					>抽象方法:public abstract的
	    3.2 JDK8:除了定义全局常量和抽象方法之外，还可以定义静态方法﹒默认方法（略)
	    
	4、接口中不能定义构造器的! 意味着接口不可以实例化
	5.Java开发中,接口通过让类去实现(implements)的方式来使用，
	    如果实现类覆盖了接口中的所有抽象方法,则此实现类就可以实例化
	   如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类

 * 
 * 
 */

public class InterfaceTest { 
	  public static void main(String[] args) {
	
		  Plane plane = new Plane();
		  plane.fly();
	}
	  
	  

}

//接口
interface Flyable {
	
	//全局常量
	public static final int MAX_SPEED = 7900;
	int  MIN_SPEED = 1 ;  // 省略了public static final 
	
	//抽象方法
	public abstract void fly();
	void stip();        // 省略了public abstract
	
}


interface Attack{
	 void run();
}

//实现接口（调用接口）
class Plane implements Flyable{

	@Override
	public void fly() {
		// TODO Auto-generated method stub
		System.out.println("fly");
	}

	@Override
	public void stip() {
		// TODO Auto-generated method stub
		System.out.println("stop fly");
	}
	
	
}


//一个类可以继承多个接口
//class AA  extends BB implements CC,DD...
class Bullet extends Object implements Flyable,Attack{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void fly() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void stip() {
		// TODO Auto-generated method stub
		
	}
	
}

//***********************************************

//接口与接口之间，继承
//接口与类之间 ， 实现

interface AA{
	
}

interface BB{
	
}

interface CC extends AA,BB{
	
}