java接口与多态

Ⅰ 用java继承，多态与接口

题目有关回答如下，供参考：

4、this:当前对象的引用
super:当前对象的超（父）类对象的一个引用

5、继承是面向对象最显着的一个特性。
继承的意义：继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。
定义继承：使用关键字 extends 来实现继承

6、多态（Polymorphism）按字面的意思就是“多种状态”，也是面向对象的一个特性。
允许将子类类型的引用赋值给父类类型的引用。

7、代码如下：

/**
*父类（图形）
*
*@authorqd
*
*/
abstractclassFigure{

doublearea;
}

/**
*求面积的接口
*
*@authorqd
*
*/
interfaceArea{

publicvoidgetArea();
}

/**
*三角形
*
*@authorqd
*
*/
{

//底
doublebottom;
//高
doublehigh;

publicTriangle(doublebottom,doublehigh){
super();
this.bottom=bottom;
this.high=high;
}

@Override
publicvoidgetArea(){

area=bottom*high*0.5;
System.out.println("三角形面积是："+area);
}

}

/**
*正方形
*
*@authorqd
*
*/
{

//边长
doublelength;

publicSquare(doublelength){
super();
this.length=length;
}

@Override
publicvoidgetArea(){

area=length*length;
System.out.println("正方形面积是："+area);
}

}

/**
*圆
*
*@authorqd
*
*/
{

//半径
doubleradius;

publicCircular(doubleradius){
super();
this.radius=radius;
}

@Override
publicvoidgetArea(){

area=Math.PI*radius*radius;
System.out.println("圆面积是："+area);
}

}

publicclassTest{

publicstaticvoidmain(String[]args){

//三角形对象
Areatriangle=newTriangle(3,4);
triangle.getArea();

//正方形对象
Areasquare=newSquare(4);
square.getArea();

//圆对象
Areacircular=newCircular(2);
circular.getArea();
}
}

8、代码如下：

/**
*球类
*
*@authorqd
*
*/
classBall{

//私有成员变量半径
privatedoubler;

publicdoublegetR(){
returnr;
}

publicvoidsetR(doubler){
this.r=r;
}

}

/**
*台球
*
*@authorqd
*
*/
classBilliardsextendsBall{

//私有成员变量颜色
privateStringcolor;

publicvoidsetColor(Stringcolor){
this.color=color;
}

//输出信息
publicvoidprintMess(Billiardsbilliards,Ballball){

System.out.println("台球的颜色是："+billiards.color+"台球的半径是："+ball.getR());
}

}

/**
*公有测试类
*
*@authorqd
*
*/
publicclassTestBall{

publicstaticvoidmain(String[]args){

Ballball=newBall();
ball.setR(5);

Billiardsbilliards=newBilliards();
billiards.setColor("白色");
billiards.printMess(billiards,ball);
}
}

7题和8题测试如下：

Ⅱ java问题中接口为什么用多态的形式呢

就针对你贴出来的例子。如果还有个
class PeopleMapperImpl implements UserMapper{
// 操作people表的所有方法

}
你的main函数中（相当于使用端），只要把 new UserMapperImpl 切换为 new PeopleMapperImpl即可。代码剩余部分不需要做任何修改。
这个例子中，你的使用端，比较简单。如果你的使用端封装度很高。是一个factory类，有一个
UserMapper createImpl(Class class)；方法。
此时你的main是这样的
UserMapper userMapper = Factory.createImpl(PeopleMapperImpl.class);
这种代码在项目中经常使用，这时你想根据不同的场景进行切换，会非常简单。

Ⅲ java讨论:什么是多态和接口,为什么需要

多态:有三要素:1.继承 2.重写 3.父类引用指向子类对象，提高了代码的扩展性和维护性，可以这么理解，父类就好比是厨师长，手下一帮厨子就是子类，他们每个人可以炒不同的菜，你只需要告诉厨师长你要吃什么，厨师长就会找到会做这道菜的厨师去给你做。如果有道菜没有人会做，很简单，招个会做的厨师就行了，这就是扩展性，如果有道菜吃出什么问题了，我们换掉那个厨子就行了，不会影响别的菜，这就是维护性。
接口:即面向接口编程，最主要作用是解耦合，如此一来就会产生很多优点，就比如一个小组写面向接口调用，另一个小组写接口方法的实现，两边可以同步进行以提高效率。其次java中不支持多重继承，接口的出现解决了这个问题，可以提高代码的复用率，增加程序的扩展性和可维护性。

Ⅳ Java中 接口是如何实现多态的特性的

1. 概念
   

   Java中多态是个很难理解的概念，但同时又是非常重要的概念，

   Java三大特性（封装、继承、多态）之一，
   我们从字面上理解，就是一种类型的多种状态，
   一下通过卖小汽车的例子再次说明什么是多态，其中利用到了接口。

2. 案例

   //汽车接口
   interface Car{
   //要求 接口中有：汽车名称和售价
   
   String getName();
   int getPrice();
   
   }
   
   //宝马类
   class BMW implements Car{
   
   @Override
   public String getName() {
   // TODO Auto-generated method stub
   //return null;
   return "宝马";
   }
   
   @Override
   public int getPrice() {
   // TODO Auto-generated method stub
   //return 0;
   return 300000;
   }
   
   }
   
   //奇瑞QQ
   class CheryQQ implements Car{
   
   @Override
   public String getName() {
   // TODO Auto-generated method stub
   return "奇瑞QQ";
   }
   
   @Override
   public int getPrice() {
   // TODO Auto-generated method stub
   return 40000;
   }
   
   }
   
   //汽车出售店
   class CarShop{
   //收入
   private int money=0;
   
   //卖出一部汽车
   public void sellCar(Car car){
   System.out.println("车型："+car.getName()+"价格："+car.getPrice());
   //增加卖出车售价的收入
   money+=car.getPrice();
   }
   //售车总收入
   public int getMoney(){
   return money;
   }
   }
   
   public class jieKouDemo {
   public static void main(String[]args){
   CarShop shop=new CarShop();
   //卖出一辆宝马
   shop.sellCar(new BMW());
   //卖出一辆奇瑞QQ
   shop.sellCar(new CheryQQ());
   
   System.out.println("总收入："+shop.getMoney());
   }
   
   结果：

   

Ⅳ 简单的java接口与多态问题

你是怎么理解多态，常规来讲多态是指不同的实现同一个接口的类都实现接口中的方法，但各自有不同的表现。题目里只有一个Duck类实现Swimmable和FlyClimbable接口，如果要做多态必须还要另一个类来实现这两个接口。

Ⅵ java 接口和多态的区别

java中没多继承一个类只能有一个父类 继承的表现就是多态 一个父类可以有多个子类 子类可以重写父类的方法 不同的子类调用相同的方法会有不同的结果

接口可以实现多继承 一个类可以实现多个接口 子类在可以实现接口增加新的方法

接口也具有多态性

Ⅶ java中的接口和多态是怎么一回事 希望给我解释清楚 谢谢了

先说说为什么会出现接口
两个公司要合作，共享一些信息，比如现在都有个QQ登录和新浪登录。你要调用QQ的用户，QQ需要在数据库中查找，写个方法
public User getUser(){
逻辑结构
SQL语句

逻辑结构
}
QQ只要把这个方法给了客户，客户就能将QQ用户的详细信息查找出来。但是，这里有个致命缺陷，QQ把逻辑结构也暴露给客户了，客户可以根据逻辑结构找到QQ的系统漏洞。这可是很恐怖的事情。
解决方法，写一个接口，QQ只给客户接口，接口中可是没有任何代码，那么也就无所谓查找QQ的系统漏洞了
接口：public User getUser(); (把这句代码给了客户)
实现：public User getUser(){ （实现方法没有给客户，客户看不到）
逻辑结构
}
多态问题，在查找QQ用户时，你是怎么查找的？是按照姓名还是ID号？
public User getUserByName(String name);
public User getUserById(int id); (这两个是传统写法)
看看使用多态写法的好处
public User getUser(String name);
public User getUser(int id);
你想获得用户的信息吗，那好，你调用getUser();这个方法就行，至于你想通过什么方式获取，是通过用户名还是ID，你自己往getUser();参数里面放就可以了。
接口保护了系统的内部实现信息，多态使系统方法变得可扩展。当然，用途多着呢，这里只列出了一丁点。

Ⅷ JAVA里多态和接口有什么区别

多态：就是方法的重写，一个或多个方法进行重写便出现多种‘态’，也就是说‘多态’，最后就根据main方法的需求而选择调用合适的‘态’

接口：当某个方法实现了一个接口，就必须重写接口里边的方法

一般来说多态里边重写的是方法名相同，而定义的其它参数，条件不同。 接口里边的方法重写的是不同的方法，那接口有多少个就重写多少个，必须一一的去定义一遍，这里一般一个方法重写一次，当然也可以多次，那么也相当于多态了

Ⅸ 求详解java中的接口与多态

多态是面向对象的核心之一，面向接口编程也是以面向对象编程为核心。
接口就是一种规范，我们平时编程要融入生活，比如说电脑的主板，上面有很多接口，插CPU得接口只要插上CPU就可以工作，不管它是哪个厂家生产的CPU，不管它内部如何工作，只要是CPU就可以用。好比你写个接口，里面有个fly方法，实现此接口的类都要实现这个方法，至于你如何飞是你的问题，不管你用翅膀飞，还是骑扫把飞，只要实现’fly飞‘就可以。
上面是让你将编程融入生活，说说编程的东西。
多态就是父类或者接口的引用指向子类的对象的情况。比如child类 extends Fahter类
那么可以Father f=new Child(); 如果一段代码可以用父类运行，当换成子类时，功能不变，那么就是多态。多态主要一定要记得两段话，编译时看引用，运行时看对象。这句话的意思是在IDE编译阶段，你用f点出来的方法(f.这里会提示Father类有得实例方法)都是Fahter类自己有得，而Child类里自己有得方法不会被自动提示出来。但是如果子类重写父类的方法了（重写：就是子类定义了一个与父类一模一样的方法，只是方法体不同），运行时还要看后面new出来的是谁，new Child();那么执行要执行Child类重写的方法体，这样做的好处是我可以在一个方法里写f.fly();（比如Father和Child都有fly方法）
public void test(Father f){
f.fly();
} 在这样的代码下 我里面代码不用动，但是可以让f.fly()效果不同，因为我传进去的子类对象可以不同，比如test(new Child1()); test(new Child2()); test(new Child3());然而这三个子类里面的fly都有自己的具体实现，这就是多态的表现，同一个引用调用同一个方法而表现出多种状态。接口换成父类是一样的。 再有不懂得地方追问。 呵呵

Ⅹ JAVA里多态和接口有什么区别

多态是面向对象编程的特征之一，而接口是一系列方法的声明，是一些方法特征的集合，有特定的语法和结构，这两者根本不是同一类型和层次上的概念。接口毫无疑问可以体现出多态性来，但是多态性未必一定要用接口，只要存在方法的重写、重载与动态连接即可体现多态性（如存在继承关系的类之间），所以，不存在“什么时候用接口什么时候用多态”的问题，程序里写的具体代码只可能是接口，只是这代码可能会体现出多态性而已，两者可以在不同的概念层次上并存，不存在冲突。
简而言之，你可以在程序里用代码定义一个接口，但是你不能定义一个多态，多态只是对你代码特征的一种描述，一种概念上的抽象和总结。