1.什么是上转型对象及其基本特征？
上转型对象—子类对象赋值给父类变量。
例如：
package com.wangxing.test1;
//父类
public class Person {
public void testPerson() {
System.out.println("父类Person的实例方法");
}
}
package com.wangxing.test1;
//子类
public class Student extends Person{
public void testStudent() {
System.out.println("子类Student的实例方法");
}
}
package com.wangxing.test1;
public class Test1 {
public static void main(String[] args) {
//上转型对象---子类对象赋值给父类变量。
//person上转型对象表示将子类对象向上转型成父类对象
Person person=new Student(); //person上转型对象
//上转型对象的可以调用被子类继承的变量和方法，不能调用子类自己创建的变量和方法。
person.testPerson();
//person.testStudent();
//上转型对象不能调用子类自己创建的变量和方法，那么如果一定要强制使用子类自己创建的变量和方法，此时我们需要将上转型对象强制类型转换成子类对象。
Student stu=(Student)person;
stu.testStudent();
}
}
上转型对象的可以调用被子类继承的变量和方法，不能调用子类自己创建的变量和方法。
上转型对象不能调用子类自己创建的变量和方法，那么如果一定要强制使用子类自己创建的变量和方法，此时我们需要将上转型对象强制类型转换成子类对象。
2.什么是抽象类？
类–用来描述具有共同性质的一组事物的自定义复合数据类型
通过class关键字创建一个java类。
通过abstract 修饰的java类就是抽象类。
格式: 访问修饰符 abstract class 类名{}
例如：
public abstract class Hello{ }
3.为什么要使用抽象类？
抽象类的出现体现出java的重构.[重复的动作提取出来]
抽象类是提供可以由子类共享的一般形式，由子类根据自己的实际情况去处理这个一般形式。
例如:坐车收费，出租车有收费功能【1元/公里】，公交车有收费功能【全程1元】
抽象类的子类往往都是同一种事物。
4.抽象类中可以有哪些元素？
抽象类中的元素实例变量、类变量、构造方法、实例方法、类方法、【抽象方法】。
抽象方法–abstract修饰，没有方法体的方法。
抽象方法就是抽象类提供给子类的一般形式。
抽象类中可以有抽象方法，也可以一个抽象方法都没有。普通的java类中是不能有抽象方法的。
例如:
package com.wangxing.test1;
public abstract class MyAbstractClass {
public int id=1001; //实例变量
public static String name="zhangsan"; //类变量
public MyAbstractClass() {
System.out.println("构造方法");
}
public void testMethod() {
System.out.println("实例方法");
}
public static void staticMethod() {
System.out.println("类方法");
}
//abstract修饰，没有方法体的方法就是抽象方法
//抽象方法就是抽象类提供给子类的一般形式
//抽象类中可以有抽象方法，也可以一个抽象方法都没有
public abstract void abstractMethod();
}
5.抽象类的具体用法
1.抽象类不能new
2.普通的java类继承了抽象类，就需要重写抽象类中的抽象方法，否则将这个普通的java类改成抽象类。
3.抽象类可以继承其他的抽象类，可以不用重写抽象方法。
4.利用上转型对象创建出抽象类对象
5.抽象类对象可以访问抽象类中的实例变量、类变量、构造方法、实例方法、类方法、【抽象方法】。
6.抽象类对象访问抽象方法时候实际上访问的是子类重写以后的抽象方法。
7.当某一个普通的java类中的方法参数是抽象类类型的时候，可以传递上转型对象，也可以是抽象类的子类对象。
例如：
package com.wangxing.test1;
public abstract class MyAbstractClass {
public int id=1001; //实例变量
public static String name="zhangsan"; //类变量
public MyAbstractClass() {
System.out.println("构造方法");
}
public void testMethod() {
System.out.println("实例方法");
}
public static void staticMethod() {
System.out.println("类方法");
}
//abstract修饰，没有方法体的方法就是抽象方法
//抽象方法就是抽象类提供给子类的一般形式
//抽象类中可以有抽象方法，也可以一个抽象方法都没有
public abstract void abstractMethod();
}
package com.wangxing.test1;
//普通的java类继承了抽象类，就需要重写抽象类中的抽象方法，否则将这个普通的java类改成抽象类。
public class SunClass extends MyAbstractClass{
//子类重写抽象类的抽象方法
//去掉abstract，加上方法体
public void abstractMethod() {
System.out.println("子类重写抽象类的抽象方法");
}
}
package com.wangxing.test1;
public class MyClass {
public void testMyClass(MyAbstractClass mac) {
}
}
package com.wangxing.test1;
public class Test1 {
public static void main(String[] args) {
//抽象类的具体用法
//1.抽象类不能new
//MyAbstractClass mac=new MyAbstractClass();
//2.利用上转型对象创建出抽象类对象
MyAbstractClass mac=new SunClass();
System.out.println("id=="+mac.id);
System.out.println("name=="+MyAbstractClass.name);
System.out.println("name=="+mac.name);
mac.testMethod();
mac.staticMethod();
//子类重写以后的抽象方发
mac.abstractMethod();
MyClass mc=new MyClass();
//当某一个普通的java类中的方法参数是抽象类类型的时候，可以传递上转型对象，也可以是抽象类的子类对象
mc.testMyClass(mac);
//抽象类的子类对象
SunClass sun=new SunClass();
mc.testMyClass(sun);
}
}
6.什么是接口？
通过interface关键字修饰的java元素就是接口。
package com.wangxing.test1;
//接口
public interface MyInterface {
}
7.为什么要使用接口？
接口的出现体现出java的扩展.[为了以后程序扩展方便]
接口是提供可以由子类共享的一般形式，由子类根据自己的实际情况去处理这个一般形式。
例如:收费，出租车有收费功能【1元/公里】，飞机有收费功能【全程1000元】
接口的子类往往都是不同种类事物。
接口主要是提供功能，提供功能不去实现该功能，由不同的不同种类事物去实现。
为了克服java的单继承问题，可以使用接口，可以被使用多个。
8.接口中可以有哪些元素？
接口中可以有类变量、类方法、抽象方法。
1.接口中变量一定是 public static修饰的类变量。
2.接口中的类方法一定是public修饰的，public可以被省略
3.接口中的抽象方法一定是public abstract修饰的，public abstract可以省略
例如：
package com.wangxing.test1;
//接口
public interface MyInterface {
//接口中的变量一定是 public static修饰的类变量
// public static是可以省略
public int id=1001; //类变量
int age=23;
public static String name="lisi"; //类变量
//接口中没有构造方法
//public MyInterface() {}
//接口中没有实例方法
//public void testMethod() {}
//接口中的类方法一定是public修饰的，public可以被省略
public static void staticMethod() {
}
//接口中的抽象方法一定是public abstract修饰的
//public abstract可以省略
public abstract void abstractMethod1();
abstract void abstractMethod2();
void abstractMethod3();
}
9.接口的具体用法
1.接口不能new
2.类可以通过implements关键字去实现一个/多个接口
实现一个public class MyClass implements MyInterface{}
实现多个接口 public class MyClass implements MyInterface1,MyInterface2,…,MyInterface_n{}
3.普通的类去实现一个/多个接口，就需要将每一个接口中的抽象方法重写，否则就需要将这个普通的类改成抽象类.
4.抽象类去实现一个/多个接口，不需要重写接口中的抽象方法。
5.接口可以继承接口，并且可以继承父接口中的所有元素.
package com.wangxing.test1;
//接口可以继承接口，并且可以继承父接口中的所有元素
public interface DemoInterface extends MyInterface{
}
6.利用接口回调对象创建出接口对象
7.当某一个普通的java类中的方法参数是接口类型的时候，可以传递接口回调对象，也可以是接口的子类对象。
例如:
package com.wangxing.test1;
//接口
public interface MyInterface {
//接口中的变量一定是 public static修饰的类变量
// public static是可以省略
public int id=1001; //类变量
int age=23;
public static String name="lisi"; //类变量
//接口中没有构造方法
//public MyInterface() {}
//接口中没有实例方法
//public void testMethod() {}
//接口中的类方法一定是public修饰的，public可以被省略
public static void staticMethod() {
System.out.println("接口中的类方法");
}
//接口中的抽象方法一定是public abstract修饰的
//public abstract可以省略
public abstract void abstractMethod1();
abstract void abstractMethod2();
void abstractMethod3();
}
package com.wangxing.test1;
//类可以通过implements关键字去实现一个/多个接口
//普通的类去实现一个/多个接口，就需要将每一个接口中的抽象方法重写，否则就需要将这个普通的类改成抽象类
public class MyClass implements MyInterface{
@Override
public void abstractMethod1() {
System.out.println("子类重写抽象类的抽象方法");
}
@Override
public void abstractMethod2() {
// TODO Auto-generated method stub
}
@Override
public void abstractMethod3() {
// TODO Auto-generated method stub
}
}
package com.wangxing.test1;
public class DoClass {
public void test(MyInterface inter) {
}
}
package com.wangxing.test1;
public class Test1 {
public static void main(String[] args) {
//1.接口不能new
//new MyInterface();
MyInterface inter1=new MyClass();
System.out.println(inter1.name);
MyInterface.staticMethod();
inter1.abstractMethod1();
DoClass dc=new DoClass();
dc.test(inter1);
MyClass mc=new MyClass();
dc.test(mc);
}
}
10.抽象类与接口的区别
| 抽象类 | 接口 |
| abstract class | interface |
| extends 一个 | implments 一个/多个 |
| 体现出java的重构,抽象类的子类往往都是同一种事物 | 体现出java的扩展,接口的子类往往都是不同种类事物 |
| 抽象类中的元素实例变量、类变量、构造方法、实例方法、类方法、【抽象方法】。 | 接口中可以有类变量、JDK8.0类方法、抽象方法。且都是public修饰符修饰的。 |
| 抽象方法可以有页可以没有 | 接口中大部分都是抽象方法 |
11.什么是接口回调对象及其基本特征？
接口回调对象与上转型对象很相似
上转型对象–子类对象赋值给父类变量。
接口回调对象—实现了该接口的子类对象赋值给接口变量。
接口回调对象可以调用被子类重写的抽象方法，但是不能调用子类自己的定义的变量和方法，如果一定要调用子类自己的定义的变量和方法，那么就需要将接口回调对象强制类型转换成子类对象
例如：
package com.wangxing.test1;
public interface TestInterface {
void testMethod();
}
package com.wangxing.test1;
public class SunClass implements TestInterface{
public void sunMethod() {
System.out.println("SunClass类的实例方法");
}
@Override
public void testMethod() {
System.out.println("子类重写接口的抽象方法");
}
}
package com.wangxing.test1;
public class Test1 {
public static void main(String[] args) {
//接口回调对象---实现了该接口的子类对象赋值给接口变量。
TestInterface inter1=new SunClass();
//接口回调对象可以调用被子类重写的抽象方法，但是不能调用子类自己的定义的变量和方法
inter1.testMethod();
//inter1.sunMethod();
//如果一定要调用子类自己的定义的变量和方法，那么就需要将接口回调对象强制类型转换成子类对象
SunClass sc=(SunClass)inter1;
sc.sunMethod();
}
}
