多态性
向上转型
子类 子类对象 = new 子类
父类 父类对象 = 子类对象
具体代码解释：
class Person{//父类
public void say1(){//父类方法1
System.out.println("P-1");
}
public void say2(){//父类方法2
System.out.println("P-2");
}
}
class Man extends Person{//子类并继承父类
public void say1(){//子类重写方法1
System.out.println("M-1");
}
public void say3(){//子类方法3
System.out.println("M-3");
}
}
public class Learn {
public static void main(String[] args) {
// TODO Auto-generated method stub
Man m= new Man();//声明实例化子类
Person p = m;//进行向上转型
p.say1();
p.say2();
}
}
运行结果：
M-1 //被重写
P-2
向下转型（前提进行向上转型）
父类 父类对象 = new 子类
子类 子类对象 = （子类）父类对象
具体代码解释：
public class Learn {
public static void main(String[] args) {
// TODO Auto-generated method stub
Person p= new Man();//进行向上转型
Man m = (Man)p;//进行向下转型
m.say1();
m.say2();
m.say3();
}
}
运行结果：
M-1
P-2
M-3
向上向下转型有什么用我也不知道，目前没什么感觉
多态性的简单使用
我理解起来就是子类能直接调用父类里面的属性与方法，然后通过简单的传参函数来简化调用（目的就是简化代码）
具体操作：
package javalearn;
class A{
public void say1(){
System.out.println("A-1");
}
}
class B extends A{
public void say2(){
System.out.println("B-1");
}
}
class C extends A{
public void say3(){
System.out.println("C-1");
}
}
public class Learn {
public static void main(String[] args) {
// TODO Auto-generated method stub
B b= new B();
b.say1();
C c= new C();
c.say1();
System.out.println("-----上面代码繁琐，可以使用下面的方法-------");
use(new B());//调用use函数
use(new C());
}
public static void use(A a){
a.say1();
}
}
运行结果：
A-1
A-1
-----上面代码繁琐，可以使用下面的方法-------
A-1
A-1
instanceof关键字
目的判断一个对象是不是一个类的对象（就是说比如判断a是不是A类的对象），代码：
package javalearn;
class A{
public void say1(){
System.out.println("A-1");
}
}
class B extends A{
public void say2(){
System.out.println("B-1");
}
}
public class Learn {
public static void main(String[] args) {
// TODO Auto-generated method stub
A a= new A();
System.out.println(a instanceof A);
System.out.println(a instanceof B);
A a1= new B();//进行向上转型以后结果会不一样
System.out.println(a1 instanceof A);
System.out.println(a1 instanceof B);
}
}
运行结果：
true //对象a是类A的对象
false //对象a不是是类B的对象
true //对象a1是类A的对象
true //对象a1是类B的对象
抽象类的使用
我的理解举个例子：
有一个类：人；还有两个类：学生和老师；学生和老师都属于人，所以可以继承类：人；但是学生和老师的需求确实不一样的，学生想要成绩，老师想要工资，怎么办？这时候可以在类：人中创建一个抽象方法来实现，具体代码：
package javalearn;
abstract class Person{
String name;
int age;
public Person(String name,int age){
this.name=name;
this.age=age;
}
public abstract void want();//不一样的地方用构造方法来实现
}
class Student extends Person{
int socer;
public Student(String name, int age,int socer) {
super(name, age);
this.socer=socer;
}
public void want(){
System.out.println("姓名："+name+" 年龄："+age+" 成绩："+socer);
}
}
class Teather extends Person{
int money;
public Teather(String name, int age,int money) {
super(name, age);
this.money=money;
}
public void want(){
System.out.println("姓名："+name+" 年龄："+age+" 工资："+money);
}
}
public class Learn {
public static void main(String[] args) {
// TODO Auto-generated method stub
new Student("小明",15,100).want();
new Teather("灭绝师太",15,1000).want();
}
}
运行结果：
姓名：小明 年龄：15 成绩：100
姓名：灭绝师太 年龄：15 工资：1000
接口的应用
我的理解，举个例子：
优盘和打印机都能在电脑上工作，为什么，因为电脑有USB接口，其他机器可以通过与USB接口来连接电脑工作，so，这个接口很重要，我们来具体代码写一下：
package javalearn;
class Computer{//电脑
public static void work(Usb a) {//创建方法来使用接口
a.start();
System.out.println("工作中。。。");
a.stop();
}
}
interface Usb{//USB接口
void start();//因为接口只能存在抽象方法可以简写
void stop();
}
class UsbDisk implements Usb{//优盘
public void start() {
System.out.println("优盘开始工作");
}
public void stop() {
System.out.println("优盘停止工作");
}
}
class Printer implements Usb{//打印机
public void start() {
System.out.println("打印机开始工作");
}
public void stop() {
System.out.println("打印机停止工作");
}
}
public class Learn {
public static void main(String[] args) {
Computer.work(new UsbDisk());
Computer.work(new Printer());
}
}
运行结果：
优盘开始工作
工作中。。。
优盘停止工作
打印机开始工作
工作中。。。
打印机停止工作