java面向对象(封装-继承-多态)
框架图
理解面向对象
- 面向对象是相对面向过程而言
- 面向对象和面向过程都是一种思想
- 面向过程强调的是功能行为
- 面向对象将功能封装进对象,强调具备了功能的对象。
- 面向对象是基于面向过程的。
面向对象的特点
是一种符合人们思考习惯的思想
可以将复杂的事情简单化
将程序员从执行者转换成了指挥者
完成需求时:
- 先要去找具有所需的功能的对象来用。
- 如果该对象不存在,那么创建一个具有所需功能的对象。
- 这样简化开发并提高复用。
面向对象开发,设计,特征
开发的过程:其实就是不断的创建对象,使用对象,指挥对象做事情。
设计的过程:其实就是在管理和维护对象之间的关系。
面向对象的特征:
- 封装
- 继承
- 多态
类与对象的关系
计算机语言是虚拟的,但描述的是现实中的事物,java中描述事物通过类的形式体现,类是具体事物的抽象,概念上的定义。对象即是该类事物实实在在存在的个体。
类与对象的关系好比汽车的设计图纸,参照这个设计图制造的汽车,具有颜色、轮胎等特征。图纸就是类,汽车就是堆内存中的实体对象。我们可以对某个汽车所改观,比如换颜色换轮胎,和其他汽车没有关系。
生活中描述事物无非就是描述事物的属性和行为。Java中用类class来描述事物也是如此:
属性:对应类中的成员变量。
行为:对应类中的成员函数。
定义类其实就是在定义类中的成员(成员变量和成员函数)。
匿名对象
匿名对象是对象的简化形式
对比如下:
1 Car c = new Car(); 2 c.color="red" 3 c.run(); 4 5 6 new Car().run();
匿名对象两种使用情况
- 当对对象方法仅进行一次调用的时,如果对一个对象进行多个成员调用,必须给这个对象起名。
- 匿名对象可以作为实际参数进行传递,函数调用完成后自动释放,没了引用指向,匿名对象在堆内存中成为垃圾被自动回收。
成员变量和局部变量
a.无论成员变量还是局部变量使用前都需要声明;
b. 局部变量使用前必须初始化;成员变量可以不用初始化,其每个类型的的成员变量都有一个初始值:byte、short、int、long类型初始值为 0;float、double类型初始值为0.0;char类型的初始'\u0000';boolean类型的初始值为false;
c.局 部变量没有访问权限修饰符,不能用public,private,protected来修饰。局部变量不能用static修饰,没有”静态局部变量“。局 部变量的作用域仅限于定义它的方法,在该方法的外部无法访问它;成员变量定义在类中,在整个类中都可以被访问。如果权限允许,还可以在类的外部使用成员变 量;
d.局部变量的生存周期与方法的执行期相同。当方法执行到定义局部变量的语句时,局部变量被创建,执行到它所在的作用域的最后一条语句时,局部变量被销毁;类的成员变量,如果是实例成员变量,它和对象的生存期相同。而静态成员变量的生存期是整个程序运行期;
e.在同一个方法中,不允许有同名的局部变量。在不同的方法中,可以有同名的局部变量,它们互不干涉。 局部变量可以和成员变量同名,且在使用时,局部变量具有更高的优先级。
局部变量代码示例
1 public class localVariable 2 { 3 public void method_1() 4 { 5 int va = 0; //正确 6 public int pva; //错误,不能有访问权限 7 static int sa; //错误,不能是静态的 8 final int CONST = 10; //正确,可以是常量 9 double va =0.0; //错误,与前面的va同名 10 vb = 100.0; //错误,vb还未定义 11 double vb; 12 vb = 100.0; //正确,现在可以使用了 13 } 14 public void method_2() 15 { 16 va = 0; //错误,method_1()中的变量va在此不可用 17 int CONST = 100; //正确,它与method_1()中的CONST不同 18 } 19 }
局部变量与成员变量同名示例
1 public class localVSmember 2 { 3 private int iVar = 100; 4 public void method_1() 5 { 6 int iVar; //正确可以与成员变量同名 7 iVar = 200; //这里访问的是局部变量 8 this.iVar = 300; //这里访问的是成员变量 9 } 10 public void method_2(){ 11 iVar = 400; //这里访问的是成员变量 12 } 13 } 14 //因为局部变量优先级高于成员变量,同一函数内调用,同名的局部变量会屏蔽掉成员变量。为了访问被屏蔽的成员变量,需要使用"this"关键字,它表示的是"本类对象"(所在函数所属对象)成员变量其实还是对象在调用
构造函数
对象一建立就会调用与之对应的构造函数,用于给对象进行初始化。当一个类中没有定义构造函数时,那么系统会默认给该类加入一个空参数的构造函数。当在类中自定义了构造函数后,默认的构造函数就没有了。
构造函数和一般函数在写法上不同,在运行上也有不同:
- 构造函数是在对象一建立就运行。给对象初始化;而一般方法是对象调用才执行,给是对象添加对象具备的功能。
- 一个对象建立,构造函数只运行一次;而一般方法可以被该对象调用多次。
什么时候定义构造函数呢?
当分析事物时,该事物存在具备一些特性或者行为,那么将这些内容定义在构造函数中。
构造函数的特点:
- 函数名与类名相同
- 不用定义返回值类型(区别void)
- 不可以写return语句
- 多个构造函数是以重载的形式存在的
构造代码块
构造代码块和构造函数一样,也是为对象进行初始化用的。
共同点是在对象一建立的时候他们都在运行,区别在于构造代码块要优先于构造函数执行,同时,构造代码块是给所有对象进行统一的初始化,而构造函数则是给对应的对象进行初始化。
this关键字
this代本类对象的引用,也就是它所在函数所属对象的引用,简单说:哪个对象在调用this所在的函数,this就代表哪个对象。
this关键字的使用:
1.当成员变量和局部变量重名时,在方法中使用this时,表示的是该方法所在类中的成员变量。例如上面局部变量和成员变量同名的示例。
2.用于构造函数之间进行调用。注意:只能定义在构造函数的第一行,构造函数之间不允许相互调用,会形成死循环。
static关键字
static关键字用于修饰成员(成员变量和成员函数)。
被修饰后的成员具备以下特点:
- 随着类的加载而加载,消失而消失。
- 优先于对象存在
- 被所有对象所共享
- 可以直接被类名调用,格式为:类名.静态成员
使用注意
静态方法只能访问静态成员,非静态方法既可以访问静态也可以访问非静态。
因为静态优先于对象存在,所以静态方法中不可以写this,super关键字。
主函数是静态的
静态有利有弊
利处:对对象的共享数据进行单独空间的存储,节省空间。没有必要每一个对象中都存储一份。
可以直接被类名调用。
弊端:生命周期过长。
访问出现局限性。(静态虽好,只能访问静态)
什么使用静态?要从两方面下手:因为静态修饰的内容有成员变量和函数。
什么时候定义静态变量(类变量)呢?
当对象中出现共享数据时,该数据被静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中。
什么时候定义静态函数呢?
当功能内部没有访问到非静态数据(没有操作对象的特有数据),那么该功能可以定义成静态的。
静态代码块
示例1
1 class StaticCode 2 { 3 static 4 { 5 System.out.println("a"); 6 } 7 } 8 class StaticCodeDemo 9 { 10 static 11 { 12 System.out.println("b"); 13 } 14 public static void main(String[] args) 15 { 16 17 new StaticCode(); 18 new StaticCode();//随类加载只执行一次且优先于主函数执行 19 System.out.println("over"); 20 } 21 static 22 { 23 System.out.println("c"); 24 } 25 } 26 //运行结果 27 //b c a over
示例2
1 class StaticCode 2 { 3 int num = 9; 4 StaticCode()//无参数类型的构造函数 5 { 6 System.out.println("b"); 7 } 8 static//静态代码块------给类初始化 9 { 10 System.out.println("a"); 11 } 12 13 { 14 System.out.println("c"+this.num);//构造代码块-------给对象初始化 15 } 16 17 StaticCode(int x)//有参数类型的构造函数---------给对应对象初始化 18 { 19 System.out.println("d"); 20 } 21 public static void show() 22 { 23 System.out.println("show run"); 24 } 25 } 26 27 class StaticCodeDemo 28 { 29 static 30 { 31 System.out.println("f"); 32 } 33 public static void main(String[] args) 34 { 35 new StaticCode(4); 36 } 37 38 } 39 40 //运行结果:f a c9 d
特点:随着类的加载而执行,只执行一次,优先于主函数执行。类似构造代码块。用于给类进行初始化。表示:一个类进入内存,不需要对象的情况下,需要先做什么事情,较少使用。
注意:可能不止一个。位置不固定,可能在末尾。新建对象和调用类方法都可以加载类,但是创建一个没有实体指向的空变量不会加载类,例如,StaticCode s = null;,因为没有指向、没有意义。只有用到了类中的内容,例如,构造函数等,类才会被加载。
执行顺序:加载类—》静态变量—》静态代码块—》主函数—》加载对象—》加载属性—》构造代码块—》构造函数
静态代码块内部只能放静态成员,构造代码块内部能放各种成员变量。
对象的初始化
Person p = new Person(“zhangsan”,20);
该句话的执行步骤如下:
1.因为new用到了Person类,所以会先找到Person.class文件并加载到内存中,静态变量加载到方法区。同时,栈内存中分配空间给变量p。
2. 会执行该类中的静态代码块,如果有的话,同时给Person.class类进行初始化。
3. 在堆内存中开辟空间,分配内存地址。
4. 在堆内存中建立对象的特有属性(实例变量),并进行默认初始化。
5. 对属性进行显示初始化。
6. 对对象进行构造代码块初始化。
7. 对对象进行对应的构造函数初始化。
8. 将内存地址赋给栈内存中的p变量,p指向对象。
面向对象的特征
封装
封装:就是隐藏对象的属性和实现的细节,控制在程序中属性的读和写的访问级别,仅对外提供公共的访问方式。
好处:
•将变化隔离。
•便于使用。
•提高重用性。
•提高安全性。
封装原则:
•将不需要对外提供的内容都隐藏起来。
•把属性都隐藏,提供公共方法对其访问。
private(私有)关键字是一个权限修饰符。用于修饰成员(成员变量和成员函数),被私有化的成员只在本类中有效。private可以将成员变量私有化,对外提供对应的 set方法(返回值为void且有参数)和get方法(没有参数)对其进行访问,提高对数据访问的安全性。私有仅仅是封装的一种表现形式。
继承
多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承单独的那个类即可。多个类可以称为子类,单独这个类称为父类或者超类。
通过extends 关键字让类与类之间产生继承关系。
写法:class SubDemo extends Demo{}
- 继承的出现提高了代码的复用性。
- 继承的出现让类与类之间产生了关系,提供了多态的前提。
子类可以直接访问父类中的非私有的属性和行为。定义继承要注意不能仅为了获取其他类的功能,简化代码而继承,必须是类与类之间有所属关系才可以继承(is a)。
使用继承体系中的功能:先查阅体系中父类的描述,因为父类中定义的是该体系中共性功能,通过了解共性功能就可以知道该体系的基本功能。具体调用时,要创建最子类的对象。因为有可能父类不能创建对象,如抽象类;而且创建子类对象可以使用更多的功能,包括基本功能和特有功能。总的说就是查阅父类功能,创建子类对 象使用功能。
Java语言中:java只支持单继承,不支持多继承。
因为多继承容易带来安全隐患:当多个父类中定义了相同功能,当功能内容不同时,子类对象不确定要运行哪一个。但是java保留这种机制。并用另一种体现形式来完成表示。多实现。
java支持多层继承。也就是一个继承体系。
继承出现后,子父类成员的特点:
类中成员:
1,变量。
如果子父类中出现非私有的同名成员变量时,子类要访问本类的变量用this,一般可以省略。子类要访问父类中的同名变量用super,不可以省略。父类private成员变量可以被继承但无法被访问。
2,函数。
当子类出现和父类一模一样的函数时,当子类对象调用该函数,会运行子类函数的内容。如同父类的函数被覆盖一样。这种情况是函数的另一个特性:重写(覆盖)
当子类继承父类,沿袭了父类的功能,到子类中,但是子类虽具备该功能,但是功能的内容却和父类不一致,这时,没有必要定义新功能,而是使用覆盖特殊,保留父类的功能定义,并重写功能内容。
- 子类覆盖父类,必须保证子类权限大于等于父类权限,才可以覆盖,否则编译失败。
- 静态只能覆盖静态。
注意区分:
重载:同一个类中,只看同名函数的参数列表。
重写:子父类方法要一模一样。(包括返回值类型)
3,构造函数。
子类不能覆盖父类构造函数,因为类名不一样。在对子类对象进行初始化时,父类的构造函数也会运行,那是因为子类的构造函数默认第一行有一条隐式的语句super();
super()会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();(只能写在第一行)
为什么子类一定要访问父类中的构造函数?
因为父类中的数据子类可以直接获取。所以子类对象在建立时,需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时,必须要先访问一下父类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。
如果要访问父类中指定的构造函数,可以通过手动定义super显示语句的方式来指定。当然子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。
final关键字
1,可以修饰类,函数,变量。
2,被final修饰的类不可以被继承。为了避免被继承,被子类复写功能。
3,被final修饰的方法不可以被复写。
4, 被final修饰的变量是一个常量只能赋值一次,既可以修饰成员变量,也可以修饰局部变量。当在描述事物时,一些数据的出现值是固定的,那么这时为了增强 阅读性,都给这些值起个名字。方便于阅读。而这个值不需要改变,所以加上final修饰。作为常量:常量的书写规范所有字母都大写,如果由多个单词组成, 单词间通过_连接。
5,内部类定义在类中的局部位置上是,只能访问该局部被final修饰的局部变量。
抽象类
当多个类中出现相同功能,但是功能主体不同,这时可以进行向上抽取。这时,只抽取功能定义,而不抽取功能主体。例如void work() ,工人和程序员都需要工作,但是工作的内容不会相同。不抽取主体只抽取方法再通过方法的覆盖来实现多态的属性。是一种运行时绑定。
抽象类的特点:
1,抽象方法一定在抽象类中。抽象类中可以不定义抽象方法,这样做仅仅是不让该类建立对象。
2,抽象方法和抽象类都必须被abstract关键字修饰。
3,抽象类不可以用new创建对象。因为调用抽象方法没意义。
4,抽象类中的抽象方法要被使用,必须由子类复写起所有的抽象方法后,建立子类对象调用。如果子类只覆盖了部分抽象方法,那么该子类还是一个抽象类。
接口
接口是对外暴露的规则,是程序的功能扩展。
格式:
interface {}
接口中的成员修饰符是固定的:
- 成员常量:public static final----全局常量
- 成员函数:public abstract
接口可以理解为一个特殊的抽象类,当类中的方法都是抽象的,该类可以通过接口的形式来表示。接口中的方法都是没有方法体的,便于以后的覆盖。
类与接口之间是“实现”关系,implements。父类中有非抽象内容可以直接拿来用,子类只有将接口中的内容全部实现后才能实例化,否则是抽象类。接口 是不可以创建对象的,因为有抽象方法。覆盖接口中的方法必须用public,因为接口中的方法都是共有的,抽象类的权限不确定。
接口可以被类多实现。一个类可以同时现实多个接口。也是对多继承的不支持的转换形式。依然需要覆盖每个接口的方法。即使多个接口有相同名称的方法也没有问题,因为没有方法体,不会产生矛盾,子类可以全部覆盖。子类在继承父类的同时,还可以实现多个接口。
类之间是继承关系;类和接口之间是实现关系;接口之间是继承关系,接口之间可以多继承,但是不能有重载函数。
接口的使用思路:
子类继承父类的全部功能;但是,有的子类需要某些功能,有的子类不需要某些功能,可以将这些功能作为接口,需要的用,不需要的不用,防止不需要的子类也带上这些功能,而且其他的子类也可以使用这些接口;如果所有的子类都需要这些功能,但是具体的内容不同,可以使用抽象类,子类自己进行覆盖,或者使用一般类, 少部分的子类通过覆盖获得自己所需要的功能。
基本功能定义在类中,扩展功能定义在接口中。例如培训班的学员基本功能都要学习,扩展功能有部分学员需要抽烟。
抽象类和接口异同
相同:
1,都可以在内部定义抽象方法。
2,通常都在顶层。
3,都不可以实例化,都需要子类来实现。
不同:
1,抽象类中可以定义抽象方法和非抽象方法,而接口中只能定义抽象方法。
2,抽象类只能单继承。接口的出现可以多实现,也就是说接口的出现避免了单继承的局限性。
3,继承和实现的关系不一致。继承:is a,实现:like a
多态
多态可以理解为事物存在的多种体现形态。 比如动物的体现形态:猫、狗等。
猫这个对象对应的类型是猫类型
•猫 x = new 猫();
同时猫也是动物中的一种,也可以把猫称为动物。
•动物 y = new 猫();
动物是猫和狗具体事物中抽取出来的父类型。
父类型引用指向了子类对象,这就是多态的体现。
多态的前提必须是类与类之间有关系。要么继承,要么实现。通常还有一个前提:方法存在覆盖。
好处:大大提高了程序的扩展性,便于后期维护。
弊端:但是只能使用父类的引用访问父类的成员。
1 Animal a = new Cat();//类型提升。 向上转型。 2 a.eat(); 3 4 //如果想要调用猫的特有方法时,如何操作?强制将父类的引用转成子类类型。向下转型。 5 Cat c = (Cat)a; 6 c.catchMouse(); 7 //千万不要出现这样的操作,就是将父类对象转成子类类型。 8 // Animal a = new Animal(); 9 // Cat c = (Cat)a;错误的。 10 11 //多态自始至终都是子类对象在做着变化。 12 13
自己写了个小代码加深下多态的理解
1 class Polymorphic 2 { 3 public static void main(String[] args) 4 { 5 Boss boss=new Boss(); 6 boss.command(new MDWorker()); 7 boss.command(new MTWorker()); 8 } 9 } 10 //父类员工类 11 abstract class Worker 12 { String name; 13 int age; 14 15 abstract void salaried();//领薪水的方法 16 abstract void doProject();//做项目的方法 17 18 } 19 20 //市场部员工子类 21 class MDWorker extends Worker 22 { 23 24 public void salaried(){ 25 System.out.println("领3K薪水!"); 26 } 27 public void doProject(){ 28 System.out.println("做市场调差项目!"); 29 } 30 public void report(){ 31 System.out.println("特有功能写报告!"); 32 } 33 34 35 } 36 //技术部员工子类 37 class MTWorker extends Worker 38 { public void salaried(){ 39 System.out.println("领4K薪水!"); 40 } 41 public void doProject(){ 42 System.out.println("做技术测试项目!"); 43 } 44 public void coding(){ 45 System.out.println("特有功能写代码!"); 46 } 47 } 48 //老板类 49 class Boss 50 { 51 52 public void command(Worker w)//接收父类的引用 53 { 54 55 w.doProject(); 56 w.salaried(); 57 //w.report();编译不通过。想调用子类特有功能必须向下转型。 58 if(w instanceof MDWorker) 59 { 60 MDWorker md = (MDWorker)w;//父类引用强转为市场部子类对象,调用写报告的特有方法。 61 md.report(); 62 } 63 else if(w instanceof MTWorker) 64 { 65 MTWorker mt = (MTWorker)w; 66 mt.coding(); 67 } 68 69 } 70 }
在多态中成员函数的特点:
在编译时期:参阅引用型变量所属的类中是否有调用的方法。如果有编译通过,如果没有编译失败。
在运行时期:参阅对象所属的类中是否有调用的方法。
简单总结就是:成员函数在多态调用时,编译看左边,运行看右边。
在多态中,成员变量的特点:
无论编译和运行,都参考左边(引用型变量所属的类)。
在多态中,静态成员函数和静态成员函数的特点:
无论编译和运行,都参考左边(引用型变量所属的类)。
接口实现多态
1 实现 被使用 2 类——--——>接口——--——>主程序 3 将相似的类中的方法抽象出来放在接口。 4 主程序只需要使用接口的方法建立接口的引用,类只需实现了接口,有新类出现只要将接口的引用指向新类,无需改动主程序和接口,就降低了程序的耦合性。
Object类
Object类:是所有对象的直接或者间接父类,唯一没有父类的类,传说中的上帝。该类中定义的是所有对象都具备的功能。
注意:实际应用中一般都有复写object父类中的方法。
equals()方法
1 Object类中的equals()方法如下: 2 3 public boolean equals(Object obj) 4 { 5 return (this == obj); 6 }
Object类中的equals()方法等价于==。只有当继承Object的类覆写了equals()方法之后,子类实现了用equals()方法比较两个对象是否相等,才可以说equals()方法与==的不同。
toString()
1 Object类中的toString()方法定义如下: 2 3 public String toString() 4 { 5 return getClass().getName() + "@" + Integer.toHexString(hashCode()); 6 }
覆写equals和toString例子
1 class CarDemo 2 { 3 public static void main(String[] args) 4 { 5 Car c1 = new Car("2013", "宝马"); 6 Car c2 = new Car("2013", "宝马"); 7 System.out.println(c1.equals(c2)); 8 System.out.println(c1); 9 } 10 } 11 class Car { 12 private String year; 13 private String type; 14 Car(String year, String type){ 15 this.year= year; 16 this.type =type; 17 } 18 //复写equals()方法 19 public boolean equals(Object obj){ //如果比较双方指向同一个对象,则直接返回true。 20 if( this == obj) 21 return true; 22 if(obj != null && getClass() == obj.getClass())//使用getClass方法来判断运行时对象是否是同类对象,还要防止对null的对象执行getClass操作。 23 { 24 Car c = (Car)obj;//强转转换向下转型,才能访问子类中year和type。 25 if((this.year== c.year) && (this.type == c.type)) 26 return true; 27 } 28 return false; 29 } 30 //复写toString()方法 31 public String toString(){ 32 return ("这是"+year+"年生产的"+type+"汽车。"); 33 } 34 }
运行结果
转载于:https://www.cnblogs.com/xscn/p/3194589.html
java面向对象(封装-继承-多态)相关推荐
- (十)Core Java 面向对象(封装,继承,多态,接口) -02 (96)
目录 : 24 ). 面向对象(聚集关系) 25 ). 面向对象(子父类中变量的特点) 26 ). 面向对象(子父类中函数的特点-覆盖) 27 ). 面向对象(子父类中构造函数的特点 ...
- 大数据笔记8—java基础篇4(面向对象-封装-继承-多态)
面向对象 一.面向对象 1.面向过程 1.2.举例 1.3.总结 二.面向对象 1.简述 2.举例 3.思想特点 2.1.类的定义格式 2.1.1.简述 2.2.2.格式 2.3.3.示例 三.类的使 ...
- java面向对象——包+继承+多态(一)
文章目录 包(package) 概念: 创建包 注意事项: 导入包中的类: 直接导入 import语句导入 注意事项: 静态导入(了解即可) 包的访问权限 常见的系统包 继承 继承的语法规则 注意要点 ...
- 面向对象封装继承多态五大基本原则魔法方法反射
目录 面向对象 三大基本特征 五大基本原则 魔法方法 反射 面向对象 什么是面向对象 使用模板的思想,将世界万事万物使用对象来表示一个类型 面向对象和面向过程的区别: 面向对象的不就是使用程序处理事情 ...
- Java的封装继承多态简介与实例
封装 所谓封装就是访问权限控制,不允许调用者直接访问类的属性,使用private修饰,将属性藏起来 此时若创建对象,直接修改属性值,则会报错 想要对属性进行读写则需要在类中添加get/set方法 此时 ...
- 猜丁壳(面向对象 封装 继承 多态)
创建三个包: util包中的Constans是用来存储常量的: util包中的MyUtil是用来存储工具类的: service包中的Player定义玩家的共同属性及方法: service包中的Comp ...
- c语言编程 菲薄拉,C语言设计模式-封装-继承-多态
快过年了,手头的工作慢慢也就少了,所以,研究技术的时间就多了很多时间,前些天在CSDN一博客看到有大牛在讨论C的设计模式,正好看到了,我也有兴趣转发,修改,研究一下. 记得读大学的时候,老师就告诉我们 ...
- Day55-每日一道Java面试题-Java 面向对象编程三大特性: 封装 继承 多态
Java 面向对象编程三大特性: 封装 继承 多态 封装 封装把一个对象的属性私有化,同时提供一些可以被外界访问的属性的方法,如果属性不想被外界访问,我们大可不必提供方法给外界访问.但是如果一个类没有 ...
- Java继承_Hachi君浅聊Java三大特性之 封装 继承 多态
Hello,大家好~我是你们的Hachi君,一个来自某学院的资深java小白.最近利用暑假的时间,修得满腔java语言学习心得.今天小宇宙终于要爆发了,决定在知乎上来一场根本停不下来的Hachi君个人 ...
- python多态的三种表现形式_python小结----面向对象的三大特征(封装,继承,多态)
面向对象的三大特征: 封装,继承,多态 面向对象的编程思想核心:高类聚,低耦合–程序的设计模式范畴 封装 什么是封装: 在面向对象编程的思想中,对代码进行高度封装,封装又叫包装 封装就是指将数据或者函 ...
最新文章
- 问题 c: 插入排序_插入排序:它是什么,以及它如何工作
- 隐马尔科夫模型HMM自学 (3)
- 一本很好的书LearnOpenGL
- Go基础:格式化输出--Printf、Sprintf、Fprintf
- js文件改变之后浏览器缓存问题怎么解决?
- Yii的beforeAction
- iOS之身份证号码全校验与校验位自动补全
- sh变量特性(3)默认特性
- php title限制字数,dedecms:title解决字数限制的两种方法
- mysql表的relationship_sqlalchemy 配置多连接读写库后的relationship设置
- java字节码指令集简介
- 分享一下我作为面试官面试了几个java程序员后的感受
- 分享一款Latex在线编辑器 | 附Latex常用模版
- Advised,Advisor,Advice,Pointcut
- 微信域名防红是怎么做出来的,原理是什么?_域名微信防封
- 利用python和递归实现赶鸭子问题
- PHP 数组基本概念
- JAVA NIO实现客户端与服务端通信
- 浅谈区块链技术对未来行业的影响
- Photoshop脚本 蒙尘与划痕滤镜的使用
热门文章
- 【学亮IT手记】Java 8新特性实例介绍
- 数据类型之集合 set 运算关系
- NHibernate教程(14)--使用视图
- Data Structures(Chapter 3 of The Algorithm Design Manual)
- namenode 优化 mv慢的问题
- Hessian学习(springboot环境)
- javascript:控制一个元素高度始终等于浏览器高度
- 【Linux】虚拟服务器之LVS
- python数据类型:序列(字符串,元组,列表,字典)
- 单平台软件开发多系统APP