animal

面向对象三大特征之继承

由 我是研究僧i 提交于 2020-02-18 21:37:27
继承 ; A extends B; 就代表A继承了B; B类作为一个父类, A类作为一个子类; ​定义: 子类继承父类的属性和方法;子类可拥有自己独有的属性和方法; package com.lv.ext; //生物 public class Organisa { String name; public void huozhe(){ } } package com.lv.ext; //动物 //Animal extends Organisa 动物类继承生物类 //构造函数不能继承 public class Animal extends Organisa { //私有的属性 private int number; //私有的方法 private void test(){ } public Animal(){ System.out.println("这个是Animal的构造方法"); } public Animal(String name){ this.name=name; System.out.println("这个是Animal带参数的构造函数"); } public void eat(){ } public void sleep(){ } } package com.lv.ext; //蛇 public class Snake extends Animal { /

python学习Day18--继承

由 倖福魔咒の 提交于 2020-02-12 16:17:19
【知识点】 面向对象的三大特性：继承、多态、封装 【继承】 （1）继承：class Person(Animal): ——括号里的：父类，基类，超类 括号外的：子类，派生类 1 class Animal: 2 def __init__(self,name,sex,age): 3 self.name=name 4 self.sex=sex 5 self.age=age 6 7 class Person(Animal): 8 pass 9 10 p1=Person('小明','男',20) 11 print(p1.__dict__) # {'name': '小明', 'sex': '男', 'age': 20} （2）初识继承：子类以及子类实例化的对象 可以访问父类的任何方法或变量 　　#1、类名可以访问父类的所有东西 1 class Animal: 2 breath='呼吸' 3 4 def __init__(self,name,sex,age): 5 self.name=name 6 self.sex=sex 7 self.age=age 8 9 def eat(self): 10 print("动物都需要吃东西...") 11 12 class Person(Animal): 13 pass 14 15 print(Person.breath) # 呼吸 （用类名进行访问） 16

狗和鱼

由 三世轮回 提交于 2020-02-09 02:16:02
27．编写一个Animal类，具有属性：种类；具有功能：吃、睡。定义其子类Fish 和Dog，定义主类E，在其main方法中分别创建其对象并测试对象的特性。 package zuoye; public class Animal { private String shisan; public String getShisan() { System.out.println(shisan); return shisan; } public void setShisan(String shisan) { this.shisan = shisan; } public void eat() { System.out.println("123"); } public void sleep() { System.out.println("456"); } } package zuoye; public class Fish extends Animal { Fish() { setShisan("鱼"); } public void eat() { System.out.println("f吃"); } public void sleep() { System.out.println("f睡"); } } package zuoye; public class Dog extends Animal

js面向对象的三大特征加闭包

由 泄露秘密 提交于 2020-02-08 19:54:48
建立在抽象的基础上 一、封装: <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title></title> <link href="css/game.css" type="text/css" rel="stylesheet" /> <script language="JavaScript" type="text/javascript"> function Person(name,age1,sal1){ this.name=name; // 私有 var age=age1; var salary=sal1; this.show=function(){ window.alert(age+" "+salary); } //私有可以访问属性，但是外部调用不行 function show2(){ window.alert(age+" "+salary); } } var p1=new Person("sp",20,50000); window.alert(p1.name+" "+p1.age); p1.show(); </script> </head> <body> </body> </html> View Code proptype对所有的方法添加方法，当时不能访问私有对象和方法 <!DOCTYPE html> <html>

JAVA的三大特征之一--------------多态

由 我与影子孤独终老i 提交于 2020-02-06 01:39:29
一:多态的定义: 一个对象有多种形态 就称为多态 package 面向对象.多态.A; class Animal { void eat() { System.out.println("动物吃东西!"); } } class Dog extends Animal{ void eat() { System.out.println("狗吃骨头!"); } } class Cat extends Animal{ void eat() { System.out.print("猫吃鱼！"); } } public class Test { public static void main(String[] args) { //狗是动物类 //一个对象有多种形态 就称为多态 //一个表示自己的类，一个表示自己父类的类型 //子类对象赋值给父类类型 //运行时，表现得是子类的特征(先去找子类) //Animal dog = new Dog(); Dog dog = new Dog(); dog.eat(); //Animal cat = new Cat(); Cat cat= new Cat(); cat.eat(); System.out.println(cat.getClass()); /*** * 子类对象赋值给父类类型 * 运行时，表现的是子类的特征（先去找子类) */ } } 二

TypeScript中访问修饰符

由 不羁的心 提交于 2020-02-05 06:35:45
TypeScript访问修饰符 ts支持以下访问修饰符： public：所有定义成public的属性和方法都可以在任何地方进行访问。 class Animal { public age:number=10; public run() { console.log("这是一个跑的方法") } } class Dog extends Animal{ } let dog:Dog=new Dog() dog.run() //继承过来的方法 dog.age=99; //继承过来的属性 console.log(dog.age) private：所有定义成private的属性和方法都只能在类定义内部进行访问。 class Animal { private age:number=10; private run() { console.log("这是一个跑的方法") } } class Dog extends Animal{ } let dog:Dog=new Dog() //dog.run() //属性“run”为私有属性，只能在类“Animal”中访问 //dog.age=99; //属性“age”为私有属性，只能在类“Animal”中访问 protected：多有定义成protected的属性和方法可以从类定义内部访问，也可以从子类中访问。 class Animal { protected

day23——继承

由 醉酒当歌 提交于 2020-01-25 09:39:01
day23 初识继承 字面意思：儿子可以完全使用父亲的所有内容 专业角度：如果B类继承A类， B类就称为子类、派生类 A类就称为父类、基类、超类 面向对象三大特性：继承、封装、多态 继承：单继承、多继承 # class Human: # def __init__(self, name, sex, age): # self.name = name # self.age = age # self.sex = sex # # # class Dog: # def __init__(self, name, sex, age): # self.name = name # self.age = age # self.sex = sex # # # class Cat: # def __init__(self, name, sex, age): # self.name = name # self.age = age # self.sex = sex 继承 class Animal: def __init__(self, name, sex, age): self.name = name self.age = age self.sex = sex class Human(Animal): pass class Dog(Animal): pass class Cat(Animal): pass #

JS 基础篇(原型和继承)

由 可紊 提交于 2020-01-24 02:55:44
原型主要是用来存公共属性和方法 function Animal ( ) { } var a = new Animal ( ) a . _prop_ = Animal . prototype //对象的_prop_指向函数对象的原型 a . constructor = Animal //对象的构造函数指向函数对象 //a即为Animal的实例也为Animal.prototype的实例 原型继承 function Animal ( category ) { this . category = 'Animal' ; this . testrr = [ '松鼠' , '小狗' ] ; this . sleep = function ( ) { console . log ( '我是sleep' ) ; } } Animal . prototype . run = function ( ) { console . log ( 'hhhh' ) ; } function Dog ( name ) { this . name = name ; this . type = 'dog' ; } Dog . prototype = new Animal ( ) ; Dog . prototype . speak = function ( ) { console . log ( 'speak' ) ;

Java多态(更新中...)

由 谁都会走 提交于 2020-01-22 16:12:02
多态 多态指的是同一方法调用，由于对象不同可能会有不用的行为。在现实生活中，同一个方法，具体实现有可能完全不同，例如你叫一个人去玩，学霸就可能偷偷溜去学习，有的人则是跑去看电影，而我就有可能去睡觉，所以玩()这个方法，可能会有不同的行为，也称为方法的多态，属性是没有多态的。 多态实现需要三个必要条件： 1、父类对象指向之类对象 2、继承 3、重写 看一个具体的小例子： * * package com . liuzeyu12a . OOT ; /** * 实现多态的三个必要条件 * 1、父类对象指向之类对象 * 2、继承 * 3、重写 */ public class TestPolym { public static void main ( String [ ] args ) { Animal a = new Animal ( ) ; animalCry ( a ) ; Dog dog = new Dog ( ) ; animalCry ( dog ) ; //出现多态，或者 Animal dog2 = new Dog ( ) ; //自动向上转型(编译器只认为这个dog是Animal 因此不能调用Dog类的方法) animalCry ( dog2 ) ; //打上动物标签的狗 仍然还是狗 //dog2.seeDoor(); 不能被执行 没有这个方法 Dog dog22 = (

day5 java面向对象

由 為{幸葍}努か 提交于 2020-01-22 00:05:28
Java 继承 public class Mouse extends Animal { public Mouse(String myName, int myid) { super(myName, myid); } } Super调用其中的一个构造函数 implements关键字 使用 implements 关键字可以变相的使 java 具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。 public class C implements A,B { } Dog d = new Dog(); this.eat(); // this 调用自己的方法 super.eat(); // super 调用父类方法 Super() 构造器 Java 重写(Override)与重载(Overload) 当需要在子类中调用父类的被重写方法时，要使用 super 关键字。 Java 接口 [可见度] interface 接口名称 [extends 其他的接口名] { // 声明变量 // 抽象方法 } /* 文件名 : NameOfInterface.java */ import java.lang.*; //引入包 public interface NameOfInterface { //任何类型 final, static 字段 //抽象方法 } /
订阅 animal