java动物特性的面向对象描述 项目

Posted 2023-05-10

定义LandAnimal接口和WaterAnimal接口
有DOG,CAT,FROG,分别继承ANIMAL类,待征有name,mammal,carnivorous,mood,
用来实现如:

狗是哺乳动物
狗是肉食动物
狗通常的情况下,和人打招呼的方式为:摇摇尾巴
狗被抚摸情绪好的时候,打招呼的方式是:旺旺叫
狗烦躁的时候会:呜呜叫
狗有4条腿
只能用面向对象,不能用别的,有水生,和陆生.
把接口完善一下啊,完善了给你分

定义LandAnimal接口和WaterAnimal接口 ,只定义个接口好定义，只是你的题目用不到啊。（没水生和陆生啊）
下面是定义的ANIMAL类，实现了他们共有的属性。CAT,FROG没说出来啊，自己定义吧。

public class ANIMAL
public String name;
public boolean mammal; // 哺乳动物
public boolean carnivorous;// 肉食动物
public String mood;
public int logs;

public void setName(String name)
this.name = name;


public void setMammal(boolean mammal)
if (mammal)
System.out.println(name + "是哺乳动物");
else
System.out.println(name + "不是哺乳动物");



public void setCarnivorous(boolean carnivorous)
if (carnivorous)
System.out.println(name + "是肉食动物");
else
System.out.println(name + "不是肉食动物");



public void setMood(String mood1, String mood2, String mood3)
System.out.println(name + "通常的情况下,和人打招呼的方式为:" + mood1);
System.out.println(name + "被抚摸情绪好的时候,打招呼的方式是:" + mood2);
System.out.println(name + "烦躁的时候会:" + mood2);


public void setLogs(int logs)
System.out.println(name+"有"+logs+"条腿");




下面是 狗的那个类继承类ANIMAL：
public class Dog extends ANIMAL

public Dog()



public static void main(String[] args)
ANIMAL dog = new Dog();
dog.setName("狗");//设置动物名字
dog.setMammal(true);//设置是否Mammal
dog.setCarnivorous(true);//设置是Carnivorous
dog.setMood("摇摇尾巴", "旺旺叫", "呜呜叫");//设置 在3种不同情况下的动作
dog.setLogs(4);



输出：
狗是哺乳动物
狗是肉食动物
狗通常的情况下,和人打招呼的方式为:摇摇尾巴
狗被抚摸情绪好的时候,打招呼的方式是:旺旺叫
狗烦躁的时候会:旺旺叫
狗有4条腿

其他的动物 同样的原理。

补充：
public interface LandAnimal


public interface WaterAnimal


你的输出内容中 没用的到 （没有显示这两个接口有关信息，没有说明他是水生，陆生）

如果是狗的 那么直接 那个类 implements LandAnimal
public class Dog extends ANIMAL implements LandAnimal就行了 ，说明他是陆生的一种标志
这样就像 java.io.Serializable这个接口 ，一种标志。 参考技术A 具体的对象：猫、狗、青蛙。关系：都属于动物，猫和狗属于陆生动物，青蛙属于水生。
所以应该有6个类：
动物、陆生动物、水生动物、猫、狗、青蛙。
陆生动物、水生动物继承动物类 ；猫、狗继承陆生动物类；青蛙继承水生动物类。

下面是代码

/**
* 动物抽象类
*
* @author haisheng
*
*/
public abstract class Animal

public String creattype;//类别（哺乳、卵生）
public String eattype;//类别（肉食、杂食）

/**
* 正常行为
*/
public abstract void nomalAct();

/**
* 收到惊吓的行为
*/
public abstract void scaredAct();



/**
* 陆地动物
* @author haisheng
*
*/
public abstract class AnimalLand extends Animal
/**
* 打招呼
*/
public abstract void hello();

/**
* 发声音
*/
protected void voice(String str)
System.out.println(str);



/**
* 水生动物
* @author haisheng
*
*/
public abstract class AnimalWater extends Animal



/**
* 猫
* @author haisheng
*
*/
public class Cat extends AnimalLand

public Cat()
this.creattype="哺乳类";
this.eattype="肉食类";


@Override
public void nomalAct()
voice("咕噜咕噜");

@Override
public void scaredAct()
voice("嘶嘶");

@Override
public void hello()
voice("喵~");




/**
* 狗
* @author [e-mail]
*
*/
public class Dog extends AnimalLand

public Dog()
this.creattype="哺乳类";
this.eattype="肉食类";


/**
* 摇尾巴
*/
public void wagTail()
System.out.println("摇尾巴了");


@Override
public void nomalAct()
voice("旺旺叫");

@Override
public void scaredAct()
voice("呜呜");

@Override
public void hello()
wagTail();




/**
* 青蛙
* @author haisheng
*
*/
public class Frog extends AnimalWater

public Frog()
this.creattype="卵生";


@Override
public void nomalAct()
System.out.println("呱呱呱");


@Override
public void scaredAct()
System.out.println("跳水了");



说明：AnimalWater类是个空的类没什么属性和方法，这个是便于系统以后扩展用的 参考技术B class Animal

boolean mammal;
boolean carnivorous;
int mood;
Animal(boolean mammal,boolean carnivorous)

this.mammal=mammal;
this.carnivorous=carnivorous;

void isMannal()

if(mammal==true)

System.out.println("鏄�摵涔冲姩鐗?);
else

System.out.println("涓嶆槸鍝轰钩锷ㄧ墿");


void isCarnivorous()

if (carnivorous==true)

System.out.println("鏄�倝椋熷姩鐗?);
else

System.out.println("涓嶆槸镶夐�锷ㄧ墿");


void setMood(int mood)

if(mood==1)

System.out.println("镫楅氩父镄勬儏鍐典笅锛屽拰浜烘墦鎷涘懠镄勬柟寮忎负:鎽囨憞灏惧惂");
System.out.println("镫匾�鎶氭懜鎯呯华濂界殑镞跺欙紝镓撴嫑锻肩殑鏂瑰纺鏄�细镞烘椇镞哄彨");
System.out.println("镫楃储韬佺殑镞跺欎细锛氩憸锻滃彨");
else

if(mood==2)

System.out.println("鐚�氩父镄勬儏鍐典笅锛屽拰浜烘墦鎷涘懠镄勬柟寮忎负锛氩柕鍠靛彨");
System.out.println("鐚�儏缁�ソ镄勬椂鍊欎细锛氩挄鍣滃挄鍣滃彨");
System.out.println("鐚�储韬佺殑镞跺欎细锛氩桩鍢跺彨");
else

System.out.println("闱掕洐阃氩父镄勬儏鍐典笅锛屾墦鎷涘懠镄勬柟寮忎负锛氩懕锻卞懕");
System.out.println("闱掕洐鎯呯华濂界殑镞跺欎细锛氩懕锻卞彨");
System.out.println("闱掕洐鍙楀埌鎯婂悡镞朵细锛氭墤阃氢竴澹拌烦鍏ユ按涓?);





interface LandAnimal

public void getNumberOfLegs();

interface WaterAnimal

public void hasGills();
public void laysEggs();

class Dog extends Animal

int leg=4;
Dog(boolean mammal,boolean carnivorous)

super(mammal,carnivorous);

public void getNumberOfLegs()

System.out.println("镫楁湁"+leg+"鏉¤吙");


class Cat extends Animal

int leg=4;
Cat(boolean mammal,boolean carnivorous)

super(mammal,carnivorous);

public void getNumberOfLegs()

System.out.println("鐚�湁"+leg+"鏉¤吙");


class Frog extends Animal

Frog(boolean mammal,boolean carnivorous)

super(mammal,carnivorous);

public void hasGills()

System.out.println("闱掕洐链夐硟");


public void laysEggs()

System.out.println("闱掕洐浜у嵉");



class MyObj1

public static void main(String a[])

Dog dog1=new Dog(true,true);
System.out.print("镫?);
dog1.isMannal();
System.out.print("镫?);
dog1.isCarnivorous();
dog1.setMood(1);
System.out.print("镫?);
dog1.getNumberOfLegs();
System.out.println("");
Cat cat1=new Cat(true,true);
System.out.print("鐚?);
cat1.isMannal();
System.out.print("鐚?);
cat1.isCarnivorous();
cat1.setMood(2);
cat1.getNumberOfLegs();
System.out.println("");
Frog frog1=new Frog(false,false);
System.out.print("闱掕洐");
frog1.isMannal();
System.out.print("闱掕洐");
frog1.isCarnivorous();
frog1.setMood(3);
frog1.laysEggs();
frog1.hasGills();


汉字有点问题,不过你应该知道写什么的 参考技术C 放弃吧。放弃吧。表学JAVA啦~~~~~~~~

Java基础---面向对象[多态]

多态

1.多态的概述
同一个对象(事务)，在不同的时刻体现出来的不同状态。
使用举例:
猪:是一种动物，是属于一种哺乳动物

2.多态的前提
(1).要有继承的关系。
(2).要有方法的重写。
其实也可以没有，但是如果没有方法的重写，那么这一个就没有意义。
动物 c=new 猫();
c.show()
动物 d=new 狗();
d.show();
(3).要有父类的引用指向子类对象
父 f=new 子();

3.多态中的成员访问特点
(1).成员变量
编译看左边，运行看右边
(2).构造方法
创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
(3).成员方法(主要是由于方法重写的缘故造成子类的方法覆盖了父类的方法)
编译看左边，运行看右边
(4)静态方法
编译看左边，运行看左边

代码：
父类代码:
public class Father {
public int num=10;

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

public static void function(){
System.out.println("function father");
}
}

//子类代码以及测试类
public class Student extends Father{
public int num=200;
public int num2=400;

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

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

public static void function(){
System.out.println("function student");
}


//多态测试
@SuppressWarnings("static-access")
public static void main(String[] args) {
Father ft=new Student();
//访问父类的成员变量的时候运行看左边
System.out.println(ft.num);
//找不到符号，编译的时候报错，编译看右边，找的是父类里面的变量，没有就会报错
//System.out.println(ft.num2);
ft.show();
//找不到符号，报错
//ft.method();
ft.function();

}
}
//输出结果
10
student show
function father

4.多态的好处
(1).提高了代码的维护性(继承保证)
(2).提高了代码的扩展性(由多态保证)
我们写一个动物类，然后使用猫狗案例来实现各自需要的功能，由于这一些功能是相似的(吃饭、睡觉、玩耍)等，所以我们在工具类中统一制定一个，就可以对所有的动物进行操作使用，
而由于在调用的的时候每一个对象都是不一样的，所以调用也会不一样，这就能够保证代码的扩展性。

(3).代码：
动物类
public class Animal {
//吃饭
public void eat(){
System.out.println("animal eat()");
}
//睡觉
public void sleep(){
System.out.println("animal sleep");
}
}
//狗类
public class dog extends Animal{
public void eat(){
System.out.println("狗吃肉");
}
public void sleep() {
System.out.println("狗蜷缩着睡觉");
}
}
//猫类
public class cat extends Animal{
public void eat(){
System.out.println("猫吃鱼");
}
public void sleep() {
System.out.println("猫趴着睡觉");
}
}
//工具类
//针对动物操作的工具类
public class AnimalTool {
private AnimalTool(){}

//调用猫的功能
public static void useCat(cat c){
c.eat();
c.sleep();
}
//调用狗功能
public static void useDog(dog d){
d.eat();
d.sleep();
}
}

5.多态中的转型问题

(1).多态的弊端
多态不能够使用子类的特有功能。如果想要使用子类特有的功能，那么如何实现，这一个时候就需要使用转型。

(2).转型主要有俩种：向下转型和向上转型
向下转型:(子类变成父类)
格式:fu f=new Zi();
向上转型:(父类变成子类)
格式:Zi z=(Zi)f

代码：
//父类代码
public class Father {
public void show(){
System.out.println("show father");
}
}
//子类代码以及测试
public class Student extends Father{

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

public void method(){
System.out.println("method student");
}
//多态测试
public static void main(String[] args) {
Father f=new Student();
f.show();
//f.method();报错
Student st=(Student) f;
st.show();
st.method();

}
}
//输出结果
student show
student show
method student

(3).多态问题的理解(孔子装爹)
class 孔子爹{
public int age=40;

public void teach(){
System.out.println("孔子爹会将易经");
}
}

class 孔子 extends 孔子爹{
public int age=20;

public void teach(){
System.out.println("孔子会讲论语");
}

public void playGame(){
System.out.println("玩英雄联盟");
}

}

//最近学习易经的人比较多，很多人就请孔子爹去讲课，这一天孔子爹就被请走了，但是还是有人来请，
//同时，价格还不错，就剩下孔子在家，孔子一想，我是不是可以考虑去？然后就穿上父亲的衣服，粘上胡子，然后就开始假装是他爹，然后就走了
//这里面实质是一个向上转型的过程
//孔子爹 k爹=new 孔子();外面看是孔子爹，实质是孔子
System.out.println(k爹.age);//40因为是孔子在装爹，如果说年龄不像，就没有人认为他是他爹，也不会叫他去讲课
k爹.teach();孔子只会讲论语，这一个过程就是多态中调用成员变量和方法的过程。
k爹.playGame();尽管这一个是儿子本身，但是这一个是是在装父亲，所以是不能够玩游戏呢。


//讲完了，下班回家
//脱下爹的伪装，然后又变回自己
//其实这一个时候是一个向下转型的一个过程，这一个时候就是还原自己的样子
孔子 k=(孔子) k爹;
System.out.println(k.age);//20
k.teach();//讲论语
k.playGame();//玩英雄联盟

 

6.多态练习

(1).不同地方不同的饮食文化
//person类
public class Person {
public void eat(){
System.out.println("person eat");
}
}
//南方人
public class SouthPerson extends Person{
public void eat(){
System.out.println("炒菜，吃米饭");
}

public void bus(){
System.out.println("经商");
}
}
//北方人
public class NorthPerson extends Person{
public void eat(){
System.out.println("炖菜，吃馒头");
}

public void yanjiu(){
System.out.println("研究");
}
}
//测试类
public class DuoTaiTest {
public static void main(String[] args) {
//南方人
Person p=new Person();
p.eat();
System.out.println("-------------");
SouthPerson sp=new SouthPerson();
sp.bus();
sp.eat();
System.out.println("-------------");
//北方人
p=new NorthPerson();
p.eat();
System.out.println("-------------");
NorthPerson np=(NorthPerson)p;
np.eat();
np.yanjiu();
}
}
//测试结果
person eat
-------------
经商
炒菜，吃米饭
-------------
炖菜，吃馒头
-------------
炖菜，吃馒头
研究

 

(2).面试题:看程序写结果
class A{
public void show(){
show2();
}

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

class B extends A{
public void show2(){
System.out.println("爱");
}
}

class C extends B{

public void show(){
show2();
}

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

}

public class DuoTaiTest{
public static void main(String[] args) {
A a=new B();
a.show();

B b=new C();
b.show()

}

}

//输出结果:爱你