精华内容
下载资源
问答
  • java封装继承多态

    千次阅读 多人点赞 2018-12-20 16:04:19
    java封装继承多态 面向对象 面向对象的三个特征: 封装(Encapsulation); 继承(Inheritance); 多态(Polymorphism)。 我的总结: 面向过程:强调的是具体的功能实现;(执行者) 面向对象:强调的是具备...

    java封装继承多态

    1. 面向对象

    面向对象的三个特征:
    封装(Encapsulation);
    继承(Inheritance);
    多态(Polymorphism)。

    我的总结:
    面向过程:强调的是具体的功能实现;(执行者)
    面向对象:强调的是具备功能的对象。(管理者)

    2、类
    类(class)是Java 语言的最小编程单位,也是设计和实现Java 程序的基础,本部分将深入介绍类的相关知识。
    类的概念
    类是一组事物共有特征和功能的描述。类是对于一组事物的总体描述,是按照面向对象技术进行设计时最小的单位,也是组成项目的最基本的模块。类的概念是抽象的,类似于建筑设计中的图纸,是对于现实需要代表的具体内容的抽象。类只包含框架结构,而不包含具体的数据。所以类代表的是总体,而不代表某个特定的个体。

    我的总结:类是抽象的,对象是具体的,实实在在的!

    类的定义:
    [修饰符] class 类名{
    1~n个构造方法;
    0~n个字段;
    0~n个方法
    }
    定义类,其实就是定义类里面的对象

    对象包含:
    状态;(属性)
    功能、行为;(方法)
    通过类来描述对象;
    状态——–成员变量;
    功能、行为——方法;

    class Person{
    //属性
    private String name;
    private int age;
    private int sal;
    //方法
    public void show(){
    System.out.println(“个人情况:”+name+age+sal);
    }
    }
    3、构造方法
    构造方法:用来构造类的实例(每一个类都默认有一个无参的构造方法,得使用new调用)
    字段:类或对象所包含的数据,对类状态的一种描述;
    方法:类或对象的特征或行为

    作用:
    给类中的字段进行初始化,可以用来创建对象。

    特点:
    方法名与类名相同
    不用定义返回值类型
    不需要写return语句

    我的总结:
    注意:
    默认构造方法的特点。
    多个构造方法是以重载的形式存在的。

    构造方法的重载:(需要哪个就去适配哪个,调用哪个)
    this([实参]);调用当前类的构造方法
    注意: this([实参]);必须放在构造器的第一行;

    对象的产生格式:
    类名称 对象名 = new 类名称();
    因为有(),所以是方法,实际上它就是构造方法,并且是非私有的构造方法。
    如:CellPhone cp = new CellPhone();

    class Person{
        private String name;
        private int age;
        private int sal;
    
        public void show(){
            System.out.println("个人情况:"+name+age+sal);
        }
    
        public Person(String name) {
            super();
            this.name = name;
        }
    
        public Person(String name, int age) {
            super();
            this.name = name;
            this.age = age;
        }
    
    
        public Person(String name, int age, int sal) {
            super();
            this.name = name;
            this.age = age;
            this.sal = sal;
        }
    }
    

    4、static关键字
    特点:
    随着类的加载而加载
    优先于对象存在
    被所有对象所共享
    可以直接被类名调用
    使用注意:
    静态方法只能访问静态成员
    但是非静态成员可以访问静态成员;
    静态方法中不可以使用this,super关键字
    主方法(main)是静态的(可以利用类名去调用静态的main方法,很正常!但是会陷入死循环,导致内存溢出,jvm自动停止!)
    public static void main(String[] agrs){}

    可修饰字段,方法。
    用static 修饰的成员表示它属于这个类共有,而不是属于该类的单个实例。
    static 修饰的字段 == 类字段
    static 修饰的方法 == 类方法

    没使用static修饰的字段和方法,成员属于类的单个实例,
    不属于类。
    没有static 修饰的字段 == 实例字段
    没有static 修饰的方法 == 实例方法

    类和实例访问字段和方法的语法:
    访问类成员: 类.字段 类.方法
    访问实例成员: 实例.字段 实例.方法

    我的总结:
    static 修饰的字段和方法,既可以通过类调用,也可以使用实例调用;
    没static 修饰的字段和方法,只能使用实例来调用(建议使用:类名来调用; 其实在底层,对象调用类成员,也会转换类名调用)
    static关键字不能与this,super同时连用!

    5、匿名对象
    一个没有名字的对象, 创建了一个对象出来,没有赋给一个变量;
    特点:
    对方法或字段只进行一次调用时;
    可作为实际参数进行传递;
    只在堆里面开辟存储区域,
    只能使用一次, 使用完就被销毁了;
    何时使用?只拿来用一次!!
    new Person();表示匿名对象,没有名字的对象
    new Person().age = 17;//使用一次之后就被销毁了

    6、this关键字
    特点:this表示当前对象。
    当前对象 ←→ 当前正在调用实例成员的对象
    换言之:谁调用了方法,谁就是当前对象。

    什么时候使用this关键字呢?
    方法间的相互调用;
    this.字段;
    构造器中相互调用,但是此时this([参数])必须写在构造方法第一行。
    this不能用在static修饰的方法里和static修饰的代码块里;

    Eg:构造方法中的this.name = name;

    7、面向对象之封装
    封装的两个含义:
    1.把对象的状态和行为看成一个统一的整体,将二者存放在一个独立的模块中(类);
    2.”信息隐藏”, 把不需要让外界知道的信息隐藏起来,尽可能隐藏对象功能实现细节,字段;

    封装机制在程序中的体现是:把描述对象的状态用字段表示,描述对象的行为用方法表示,把字段和方法定义在一个类中,并保证外界不能任意更改其内部的字段值,也不允许任意调动其内部的功能方法。

    程序中的一种体现:通常将类中的成员变量私有化(private),通过对外提供方法(setXxx,getXxx),可对该变量(xxx)进行访问。
    boolean 类型的变量没有getXX,只有 isXX;

    class Person1{
        private String name;
        private int age;
        private int sal;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    

    8、访问修饰符
    private 类访问权限:本类内部可以访问,不能继承到子类;
    default 什么都不写,包访问权限:本类内部可以访问,同包其他类也可以访问,同包可继承;
    protected 子类访问权限:本类内部可以访问,不同包的子类也可以访问,同包其他类也可以访问,能继承到子类;
    public 公共访问权限:任何地方都可以访问,能继承到子类;

    9、类的设计分析
    分析思路:
    根据要求写出类所包含的字段;
    所有的字段都必须私有化;
    封装之后的字段可通过setter和getter设值和取得;
    按需求可添加若干构造方法;
    根据需求可添加相应的方法;
    类中的所有方法都不要直接处理(输出打印),而是交给调用者去处理。

    10、面向对象之继承
    首先有反映一般事物特性的类,然后在此基础上反映出特殊事物的类;
    也就是说:继承是一种从一般到特殊的关系;

    特点:
    1、提高了代码的复用性。
    2、让类与类之间产生关系,有了这个继承关系才有了多态的特性。
    3、Java语言中只支持单继承(有别于C语言)。
    因为多继承容易带来安全隐患(父类多了, 功能相同的话,就会出现调用不确定性吗,覆写一个方法,到底覆写的谁的?)。
    ps:接口可以实现多继承
    4、Java支持多层继承,object是每个类的超类,实现树形结构。

    我的总结:
    继承是多态的前提。
    对类而言,只支持单继承。

    格式:
    [修饰符] class SubClass extends SuperClass

    按照这种关系,我们把SuperClass类称为父类或基类,把SubClass称为子类或派生类或拓展类;

    我的总结:
    java.lang.Object是所有类的父类,
    Object要么是直接父类要么是间接父类。

    Eg:
    学生属于人的一种特殊情况,此时我把人的共性写在Person类里面,为了让学生拥有这些共性(别的比如老师也可以有这些共性),然后我就让学生来拓展Person类。

    我的总结:
    子类与父类的关系:
    子类拓展父类(子类是父类的一种特殊情况)
    主要是以父类为基础,然后添加属于自己的字段和方法。

    父类的私有成员子类不能继承到;父类的构造方法不能被继承;
    Java只支持单继承,不支持多继承;//不然的话,比如show方法,继承了多个,不知道到底调用那一个。
    一个类有且只有一个直接父类;
    一个类没显示的继承其他的一个类的时候,默认的直接父类就是Object类;
    Student 的直接父类是Person,Object类也是Student类的父类,但是是间接父类;
    一旦一个类显示的继承了其他的一个类的时候,此时默认的直接父类Object就会被取消;
    Java里一个类只能有一个直接父类;java.lang.Object是所有类的父类,Object要么是直接父类要么是间接父类。

    子类对象实例化过程
    在继承操作中,对于子类对象的实例化:
    子类对象在实例化之前必须首先调用父类中的构造方法之后再调用自身的构造方法。

    11、子类访问父类和方法覆写
    子类不能直接访问父类的私有成员;
    但是子类可以调用父类中的非私有方法来间接访问父类的私有成员。
    Person类中有私有字段name,Student继承Person
    new Sudent().name; ×
    new Student().getName(); √

    子类拓展父类(子类是父类的一种特殊情况)
    主要是以父类为基础,然后添加属于自己的字段和方法。

    方法覆写产生原因:
    当父类中某个方法不适合于子类时,子类出现父类一模一样的方法.
    判断必杀技:子类方法前加上@Override能编译通过,表明是方法的覆写。
    调用被覆盖的父类方法:使用super.方法名(实参);
    方法覆写时应遵循的原则(一同两小一大):
    (一同):方法签名必须相同;
    (两小):
    子类方法的返回值类型比父类方法的返回值类型更小或相等
    子类方法声明抛出的异常应比父类方法申明抛出的异常更小或相等;
    (一大):子类方法的访问权限应比父类方法更大或相等;

    子类需要覆写父类方法。
    当父类的某个方法不适合于子类本身的特征行为时就当覆写父类中应当改变的方法。

    12、super关键字和调用父类构造方法
    表示父类对象的默认引用
    如果子类要调用父类被覆盖的实例方法,可用super作为调用者调用父类被覆盖的实例方法。
    使用super调用父类方法
    使用super调用父类的构造方法

    调用构造方法
    本类中调用另一个重载构造方法用this(参数列表)
    子类构造方法调用父类构造方法用super(参数列表)
    子类调用父类的构造方法时:
    super必须放在第一句
    Java在执行子类的构造方法前会先调用父类无参的构造方法,其目的是为了对继承自父类的成员做初始化操作。
    子类在创建对象的时候,默认调用父类的无参构造方法,要是子类构造方法中显示指定调用父类其他构造方法,就调用指定的父类构造方法,取消调用父类无参构造方法。

    package reviewDemo;
    
    class A{
        String name;
        A(){
            System.out.println("父类默认隐式的构造方法!");
        }
    
        A(String name){
            System.out.println("父类显式的构造方法!");
        }
    }
    class B extends A{
    
        B(){
            super(null);
            System.out.println("子类默认隐式的构造方法!");
        }
    }
    public class Demo10 {
        public static void main(String[] args) {
            new B();
        }
    }
    

    13、面向对象之多态
    多态:指同一个实体同时具有多种形式
    好比,你去面馆吃面,说我要吃面,那么;老板给我牛肉面,鸡蛋面等都可以,
    这就是说”面”有多种形态,也就是说实体有多种形态;
    编译时的类型由声明该变量时使用的类型决定,运行时的类型由实际赋给变量的对象决定。
    如果编译时类型和运行时类型不同,就出现多态。

    Eg:
    前提:Student extends Person:

    Person p = new Person(); 
    Student s = new Student(); 
    Person p = new Student();//多态
    

    引用关系:父类变量指向子类实例对象

    实现多态的机制:
    父类的引用变量可以指向子类的实例对象,而程序调用的方法在运行期才动态绑定,就是引用变量所指向的真正实例对象的方法,也就是内存里正在运行的那个对象的方法,而不是引用变量的类型中定义的方法。

    多态的作用:
    把不同的子类对象都当作父类来看,可以屏蔽不同子类对象之间的差异,写出通用的代码,做出通用的编程,以适应需求的不断变化。
    只修改方法的实现,不必修改方法的声明
    继承是多态产生的前提条件;

    分类:
    编译时多态:方法重载
    运行时多态:方法覆写

    package test;
    
    class Dog{
        void eat(){
            System.out.println("一般的狗吃一般的狗粮!");
        }
    }
    class HashDog extends Dog{
        void eat(){
            System.out.println("哈士奇吃哈士奇的狗粮!");
        }
    }
    class ZangAoDog extends Dog{
        void eat(){
            System.out.println("藏獒吃藏獒的狗粮!");
        }
    }
    

    //定义一个动物园喂的方法

    class Zoo{
    
        void feed(Dog d){
            d.eat();
        }
    
    }
    public class Demo11 {
        public static void main(String[] args) {
    
            Dog hd = new HashDog();
    
            Dog zd = new ZangAoDog();
    
            Zoo z = new Zoo();
            z.feed(hd);
            z.feed(zd);
        }
    }
    

    输出:
    哈士奇吃哈士奇的狗粮!
    藏獒吃藏獒的狗粮!

    14、引用变量类型转换
    向上转型(子类→父类):(自动完成)
    父类名称 父类对象 = 子类实例 ;

    向下转型(父类→子类):(强制完成)
    子类名称 子类对象 = (子类名称)父类实例 ;

    对象名 instanceof 类

    判断指定的变量名此时引用的真正类型是不是当前给出的类或子类;
    我的总结:对象的类型和类必须有继承关系

    class A extends B{}
    
    B = new A();
    If(b instanceof A){ ...
    }
    
    展开全文
  • 详解java封装继承多态

    2020-08-26 04:46:57
    主要介绍了java封装继承多态,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • java 封装 继承 多态

    千次阅读 2019-03-16 21:15:08
    面向对象编程(Object Oriented Programming)有三大特性:封装继承多态。在这里,和大家一起加深对三者的理解。 封装 封装可以拆开理解,装,是把数据和方法放进了类里;封,把装进去的数据和成员方法加上访问...

    面向对象编程(Object Oriented Programming)有三大特性:封装、继承、多态。在这里,和大家一起加深对三者的理解。

    封装
    封装可以拆开理解,装,是把数据和方法放进了类里;封,把装进去的数据和成员方法加上访问权限。对于外界,内部细节是透明的,暴露给外面的是它的访问方法。

    继承
    继承,是为了重用父类代码。两个类若具有is a的关系就可以用extends另外,继承也为实现多态做了铺垫。

    多态
    现实事物经常会体现出多种形态,如学生,学生是人的一种,一个具体的同学新垣结衣,即使学生,也是人,出现两种形态。java面向对象,同样可以描述一个事物多种形态。如,Student类继承了Person类,一个student的对象既是Student,同时也是Person。
    多态的定义格式:(死记这句话)父类的引用变量指向子类对象
    格式:

    父类类型 变量名 = new 子类类型();
    

    父类类型可以是普通类、抽象类、接口。因此又可以细分为三种形式:

    //1、父类类型为普通类
    class Father{}
    class Son extends Father{}
    //多态
    Father f = new Son();   	//父类类型指向子类对象(注意:new Son()   为一个对象,子类对象)
    
    //2、父类为抽象类
    abstract class Father{
    	public abstract void sing();
    }
    class Son extends Father{
    	public void sing(){
    		System.put.println("父类为抽象类");
    	}
    }
    //多态
    Fatehr f = new Son();
    
    
    //3\父类为接口
    interface Father{
    	public abstract void sing();
    }
    class Son implements Father{
    	public void sing(){
    		System.put.println("父类为抽象类");
    	}
    }
    //多态
    Fatehr f = new Son();
    

    程序中定义的引用变量(java有两大数据类型,内部数据类型和引用数据类型)所指向的具体类型和通过该引用变量发出的方法调用编译时不确定,而是在程序运行期间确定,即一个引用变量到低指向哪个类的实例对象,该引用变量发出的方法调用到底是哪个类中实现的方法,必须在程序运行期间才能决定。
    在理解多态时,总是逃不掉“向上转型”。
    问题的核心在于,一般情况下,在子类继承父类后,子类具有父类的所有成员和方法。但是在向上转型之后,子类中一些独有的成员和方法对于该父类类型的引用变量则“不可见”。

    实例

    package binaryheap.test;
    
    import java.awt.image.SinglePixelPackedSampleModel;
    
    //创建一个Animal类
    class Animal {
    	public void run() {
    		System.out.println("Animal在奔跑!!!");
    		sing();
    	}
    
    	public void sing() {
    		System.out.println("Animal在唱歌~~~");
    	}
    
    }
    
    //创建一个子类继承父类
    class Lion extends Animal {
    
    	// 重载run()方法,和父类中的run()方法不是一个
    	// 向上转型时会丢失该方法
    	public void run(String anotherAnimal) {
    
    		System.out.println(("Lion在追一只" + anotherAnimal));;
    		sing();
    	}
    
    	// 重写
    	public void sing() {
    		System.out.println("Lion在唱歌~~~");
    	}
    
    }
    
    public class BH {
    
    	public static void main(String[] args) {
    		// 创建一个父类引用,但是指向Lion对象
    		Animal animal = new Lion();
    		animal.run();
    	}
    }
    

    结果:

    Animal在奔跑!!!
    Lion在唱歌~~~
    

    Animal animal = new Lion(); 向上转型后的Animal类型的引用,丢失了重载的方法run(),即子类中的run(),指向的是父类的run(),因此输出“Animal在奔跑”,而不是“Lion在奔跑”。run()方法中调用了sing()方法,因为sing()方法被重写,引用能够找到sing()方法,因此引用调用此sing()方法(动然调用),输出“Lion在唱歌”。

    多态成员的特点:
    1、多态成员变量(子类、父类中出先相同的成员变量时,多态调用该变量时):

    • 编译时期:引用变量所属的类(父类)中是否有被调用的成员变量。没有的话——编译失败
    • 运行时期:调用引用变量所属的类(父类)中的成员变量(此时肯定编译成功了,不然无法运行,因此父类中肯定有此成员变量,那么久调用)
    • 总结:编译运行均看“=”号左边

    2、多态成员方法(重点)

    • 编译时期:引用变量所属的类(父类)类中没有该调用的方法,编译失败
    • 运行时期:引用变量所指向的对象所属的类(子类),运行该子类的成员方法
    • 总结:编译看左,运行看右

    实现多态的必要条件为:继承重写向上转型(或者说父类引用指向子类对象)。其实现机制为:调用那个方法是由被引用对象的类型决定,而不是引用变量的类型决定的,并且这个被调用的方法必须是被子类重写过的。
    总结

    1. 使用父类的引用指向子类对象
    2. 该引用只能调用父类中定义的方法和变量
    3. 若子类重写了父类的一个方法(只能重写方法,不能重写变量,否则编译时期会报错),那么调用的时候会调用子类的这个方法。

    此外,在多态引用时,可能会涉及到超类的构造方法。调用超类的构造方法的顺序是先调用最远的超类的构造方法。

    展开全文
  • Java封装继承多态

    2019-06-02 10:00:15
    封装: 封装: Encaplation 用private将不期望被外界访问的方法和属性隐藏起来 **封装对于类的开发者和使用者都有好处:** 对于类开发者: 能够让数据得倒保密 得到隐藏 从而更加安全 对于类的使用者: 能够让使用...

    封装:

    封装:

    Encaplation
    用private将不期望被外界访问的方法和属性隐藏起来
    	**封装对于类的开发者和使用者都有好处:**
    
    • 对于类开发者:
      能够让数据得倒保密 得到隐藏 从而更加安全
    • 对于类的使用者:
      能够让使用者将经理 全部集中在核心业务逻辑上

    类的开发应当高内聚 低耦合
    ------------ 内聚:独立完成功能的能力 - 自强不息 自己的事情自己做
    -------------耦合:模块与模块之间的依赖关系

    所有的属性应当用private修饰
    -------------并且提供两个public方法 setter getter
    可以给设置和得到属性一种统一的方式 有助于代码的解耦
    可以让程序员拿回主动权 让程序员决定 是否需要用户设置和得到属性

    所有方法应当考虑:
    一个方法究竟是给外界提供的核心方法 还是给核心方法服务的方法
    核心方法用public修饰
    给核心方法服务的方法应当用private对外屏蔽

    class Teacher{
    	private String name;
    	private int age;
    	public void setName(String name){
    		this.name = name;
    	}
    
    	public String getName(){
    		return name;
    	}
    	public void setAge(int age){
    		this.age = age;
    	}
    	public int getAge(){
    		return age;
    	}
    
    	//吃饭的方法
    	private void eat(){
    		System.out.println("吃饭啦!");
    	}
    	//睡觉的方法
    	private void Sleep(){
    		System.out.println("睡觉啦!");
    	}
    	//还会LOL
    	private void LOl(){
    		System.out.println("LOL!");
    	}
    	//我的核心方法
    	public void teach(){
    		sleep();
    		eat();
    		LOL();
    		SYstem.out.println("I am a techer!");
    	}
    
    }
    

    继承:

    extend 建立两个类之间 is a的关系

    • *:Java中的类 全部继承Object
    • *:Java当中的类只支持单根继承 接口是允许多重继承的

    关于继承:

    关于私有属性 有没有继承 能不能继承 算不算继承

    • 私有属性在子类的存储空间当中它是切实存在的
    • 但是是由于Java当中创建对象的流程所决定的
    • private 访问控制权限修饰符

    多态:

    Polymorphism

    • 静态多态 编译多态:java当中的方法重载
    • 动态多态 运行时多态:一个对象总有多种称呼他的类型 一个事物总有多种存在的形态
      *: 动态多态出现肯定会伴随着一种语法:
      + 父亲类型 = 子类对象;
      + 接口类型 = 实现类对象;

    多态需要注意什么?
    对象是在内存中客观存在的 不会因为改变称呼它的类型而发生任何便把
    但是编译器看等号左边的类型进行语法检查

    多态存在的价值?
    *:能够让先开发完成的类型在不做任何修改的情况下 跟之后开发出来的新的类型结合起来使用 而且不需要改变
    *:多态的存在能够降低人与人 组与组之间的耦合关系

    
    
    public class TestPoly{
    	public static void main(String[] args ){
    		Restaurant = new Restaurant();
    		Chinese xiaoBo = new Chinese();
    		American xiaoAo = new American();
    		kfc.service(xiaoBo);
    		kfc.service(xiaoAo);
    	}
    }
    
    class Restaurant{//餐厅
    
    //传统方式 过耦合
    	public void service(Chinese xiaoAo){
    		xiaoAo.eat();
    	}
    	public void service(Japanse xiaoAn){
    		xiaoAn.eat();
    	}
    	public void service(American xiaoAa){
    		xiaoAa.eat();
    	}
    
    //多态的应用
    
    	public void service(People xiaoRen){
    		xiaoRen.eat();
    	}
    }
    
    
    	//多态
    	public void service(People )
    class People{
    	public void eat(){
    		System.out.println("人类吃饭!");
    	}
    }
    
    class Chinese extends People{
    	public void eat(){
    		System.out.println("中国人吃水饺");
    	}
    }
    
    class American extends People{
    	public void eat(){
    		System.out.prinlnt("美国人吃牛排");
    	}
    }
    
    
    
    展开全文
  • Name : James Age : 20
  • Java封装继承多态实例以及文件流操作,自己整理的东西,用了单态模式实现了多态,并且贯彻了OOP思想,用到了文件流的写入与读取,希望对大家有帮助
  • Java封装继承多态及面向对象的一些理解 Java基本特性三个:封装、继承、多态。但是初看这三个字面意思非常难理解其精髓。即使看了很多例子也是一知半解的感觉。本文主要就自己理解说一下这三个特性的含义。 ...

    Java封装继承多态及面向对象的一些理解

    Java基本特性三个:封装、继承、多态。但是初看这三个字面意思非常难理解其精髓。即使看了很多例子也是一知半解的感觉。本文主要就自己理解说一下这三个特性的含义。

    • 封装
      理解封装先要理解关联关系依赖关系。在一个类里面加一些属性、方法。但是重点来了,关键就是这些属性是什么,他们可能也是类,那就会存在关联关系。关联关系又分为单向、双向、组合、聚合关系。这是一系列has a的关系。这个封装类可能就具备了这些has类的特性或者功能;当然也可能依赖其他对象进行使用,这是use a的关系。那对应New的实例对象,就复杂多样,完全就是一个全新的概念。基于这些特性,封装把方法封装在内部,把业务逻辑封装,把数据处理、计算过程封装,而对外只暴露一个方法(或者叫API接口),以实现解耦,外部不需要知道内部的实现,比如SSH里面的分层的概念。还有就是这些是继承和多态的基础知识,所以要先理解封装。

    • 继承

      这个相对来说好理解,就是父亲—>儿子,儿子会父亲的,然后又可以有自己的东西。但是重点又来了,继承不是乱用的,非常容易增加耦合性。要解释这个耦合性又要去理解Java类单继承和接口的多实现两个概念。单继承还好理解,但是多实现这个概念理解非常有难度。这里又要说道Java基本原则,都是继承于Object。这个就是单继承,它不能继承两个父类。但是问题就在这里,由于不能继承两个,那Java的复用特性会大打折扣的,我就是要继承两个怎么办,Java给出的解决办法就是接口多实现。接口又是什么,有这么一句话继承是对象的抽象,接口是方法的抽象。我的理解是一个纵向的扩展,一个横向的扩展。所以现在大家都喜欢接口,因为可以实现多个。如果你要继承,一旦要扩展共有的新的特性或者功能,那就要改父类,违背开闭原则。又多了开闭原则的概念,所以说继承看似简单,其实是封装的一个升华。面向对象的高度体现。什时候用继承?又有一句话就是:所有用子类传值的地方都可以用父类替代,那就用继承。

    • 多态
      多态个人觉得是最难理解的,因为它是建立在封装和继承之上的进一步提高。多态的体现正是面向对象的体现。建一个类不叫面向对象,用类实现多态才是精髓。重点来了,简单的多态就是利用继承实现多态,我可以传父类多个子类向上转型。但是这只是一小部分多态的体现,关键体现在接口。接口,这个词取的非常博大精深,所用实现了接口的类,跟这个接口多态,由于又可以多实现接口,这个极大的让多态活跃于各大代码中。要充分理解多态,个人觉得要结合设计模式,这个是最直接最好的方式。设计模式里面,可以说把封装、继承、多态结合起来的实际案例。

    面向对象
    再唠叨一下面向对象,面向对象相对于面向过程来说,对事物的抽象化,然后又实例化。听起来很拗口,但是是精髓所在。举个例子,比如程序里面要实现猫叫。传统的编程基本上就是一两行搞定,写一个方法或者直接在主程序里面写输出猫叫alert(“喵”)。但是如果有100个地方要用到,那你就要写100遍没错,但如果100个地方都要改成“喵喵叫”,那你就悲剧要改100个地方了,虽然有工具全局替换什么的,但是难免有漏错的地方,这就是面向过程。而面向对象,它统一的定义一个抽象类猫,具体猫是其中的一个对象,new一下就有。好了,这100个地方都是引用这个类,new自己的小猫,并且让它叫。最后猫都叫了,但是执行的方法都是这个类里面的猫叫方法!这下改成喵喵叫,你只要改一个地方了。

    展开全文
  • 九、Java封装继承多态

    2019-09-02 19:36:35
  • 细品java封装继承多态

    2020-04-02 22:13:46
    目录: 1.封装 2.继承 3.多态 1.封装
  • java继承的关键字是:extends 继承可以获得父类的属性和方法而且子类还可以具有自己的特殊的功能。 ** 例:这是一个圆public class Circle {private double radius; public Circle(double r){ this.radius=r...
  • java中,我们对类的封装,对方法的封装,在其他类中只需要调用这个类或者方法就行。 通俗点理解,我们在启动汽车的时候。汽车对里面的零件构造进行了封装,只要提供给我们一个钥匙口,我们只需要用钥匙启动就行...
  • 继承则是为了在保持封装特性的同时,去突破访问限制,例如protected这个访问权限的存在,不同包的子类可以访问不同包的父类的protected成员。 有了继承关系,就可以通过向上和向下转型以实现多态。 现在的我只觉得...
  • java封装 继承 多态的简单实例

    千次阅读 2015-10-30 16:40:53
    * 封装 */ class A { private String name; /* * 封装name */ public String getName() { return name; } public void setName(String name) { this.name = name; } } .....
  • JAVA基础之封装继承多态 文章目录系列文章目录前言一、封装二、继承三、多态总结 前言 封装,继承,多态是JAVA面向对象的三大特性,也是最基本的知识 提示:以下是本篇文章正文内容,下面案例可供参考 一、封装 ...
  • 说到继承我们首先会想到继承的关键字:extends. 通过继承可以获得父类的属性和方法,子类具有父类的功能,同时也具有自己的特殊功能。 ...Java只支持单继承,但也支持多重继承,例如:C→B→A C是
  • Java类的封装继承多态 OOP思想不再多做介绍 下面对一些重点描述一下 Java的权限修饰符 修饰实例方法、类方法、类变量、实例变量的: private public default protected 修饰类的: public private 局部变量没有访问...
  • java封装 继承多态

    2011-10-23 22:16:46
    java封装 继承多态 程序设计 类与对象
  • 封装继承多态总结

    2013-12-06 09:29:22
    封装继承多态总结
  • 面向对象的三个基本特征是:封装继承多态。 1.封装继承,多天的理解。 封装:将其信息属性和方法具体实现隐藏起来,只提供调用方法的接口,既封装 继承:将一个已有类中的属性和方法保留,可再加上自己...
  • 面向对象的三个基本特征是:封装继承多态。 我们知道,封装可以隐藏实现细节,使得代码模块化;继承可以扩展已存在的代码模块(类);它们的目的都是:代码重用。而多态则是为了实现另一个目的——接口重用!...
  • 封装 继承 多态 对象有三大特性:封装继承多态。 对象 Java是一门面向对象的语言,对象,在java中表达的形式就是类(class),包含了数据,行为的一个独立的编程单元。 也就是说,Java编程语言是建基于Class...
  • OC封装继承多态演示

    2017-04-07 21:49:26
    只是一个简单的小例子,演示了OC中的封装继承多态,在Windows下打成的zip压缩包
  • 一、继承关系:子类自动拥有父类非私有属性与方法(java只能单继承)//继承public class OOPTest2{public static void main(String[] args){Dog d = new Dog();System.out.println(d.age);d.play();}}class Animal{...
  • java继承封装多态

    2012-11-16 11:29:57
    java 继承多态、向上向下数据转换。
  • java语言的核心思想是面向对象,在代码的表现与运用上面体现着封装 继承 多态 抽象,这四大特性性。 封装,Package,是把集成电路装配为芯片最终产品的过程,简单地说,就是把Foundry生产出来的集成电路裸片...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 90,588
精华内容 36,235
关键字:

java封装继承多态

java 订阅