精华内容
下载资源
问答
  • 2019-12-01 14:46:43
    一:概念
    封装:
    	在java中,我们对类的封装,对方法的封装,在其他类中只需要调用这个类或者方法就行。
    	通俗点理解,我们在启动汽车的时候。汽车对里面的零件构造进行了封装,只要提供给我们一个钥匙口,我们只需要用钥匙启动就行。
    
    继承:
    	在java中,我们是在父子类之间定义继承关系的。只要子类继承父类,就可以调用父类中的方法(注:父类私有的方法子类无法调用)。
    	通俗点理解,我们家庭中,也是这种组成关系。(注:父亲私有的东西不能用)
    	
    多态:
    	编译时多态:函数的重载,构造方法之间
    	运行时多态:函数的重写,父子类之间(向上造型-基于继承)
    
    二:作用
    封装:
    	1:提高了代码的复用性
    	2:提高了代码的安全性
    
    继承:
    	1:提高了代码的复用性
    	2:提高了代码的安全性
    
    多态:
    	提高了代码的灵活性
    	提高了代码的耦合性(配合反射)
    	
    
    
    
    更多相关内容
  • 详解java封装继承多态

    2020-08-26 04:46:57
    主要介绍了java封装继承多态,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 一、怎么理解JAVA封装继承多态他是一个“司机”,他的平时行为还有“开车”,我们再次划分出了“哺乳动物”这个类,一个类只能继承另一个类(或抽象类)但可以实现多个接口。打个比方封装,“鱼”等等),接着,...

    d29d29f02be85d3bc67cd34718e1682a.png

    一、怎么理解JAVA中封装、继承、多态

    他是一个“司机”,他的平时行为还有“开车”,我们再次划分出了“哺乳动物”这个类,一个类只能继承另一个类(或抽象类)但可以实现多个接口。

    打个比方封装,“鱼”等等),接着,最后有“马”。 多态,正如上面朋友所说一重写,二重载。

    用汉字来打个比方,很显然,比如“开”这个字,在不同的时候各有的意思,比如“开门”、继承、多态 继承,先说说我对类的理解,类起到的作用有:分类(你所用某个类创建的对象实际上该类的个案)和模板的作用,那么继承则起到了对类再次分类的作用,比如,即先有了“动物”,再有“哺乳动物”,我们把某种东西划分出来,有个类“动物”,“张三”,他是一个“人”,因此他继承了“人”;与此同时,“开窗”,甚至有“开车”,“开饭”等,具有相同名称但操作不同。具体的实现我就不累述了。

    说说接口吧,“哺乳动物”继承“动物”,再往下“马”又继承了“哺乳动物”这个类。在这里,我们从下往上讲,首先,叫做“马”(当然还有“牛”,我们发现,“马”,“羊”等还有很多共同的特点,于是,再次分类,我们则有了“动物”。

    但在实际开发中,我们一般是从上往下定义的,在JAVA不支持多继承的,实际上接口起到了类似多继承的作用。

    二、怎么理解JAVA中封装、继承、多态

    封装、继承、多态 继承,先说说我对类的理解,类起到的作用有:分类(你所用某个类创建的对象实际上该类的个案)和模板的作用,那么继承则起到了对类再次分类的作用,比如,有个类“动物”,“哺乳动物”继承“动物”,再往下“马”又继承了“哺乳动物”这个类。

    在这里,我们从下往上讲,首先,我们把某种东西划分出来,叫做“马”(当然还有“牛”,“鱼”等等),接着,我们发现,“马”,“羊”等还有很多共同的特点,于是,我们再次划分出了“哺乳动物”这个类,再次分类,我们则有了“动物”。但在实际开发中,我们一般是从上往下定义的,即先有了“动物”,再有“哺乳动物”,最后有“马”。

    多态,正如上面朋友所说一重写,二重载。用汉字来打个比方,比如“开”这个字,在不同的时候各有的意思,比如“开门”,“开窗”,甚至有“开车”,“开饭”等,具有相同名称但操作不同。

    具体的实现我就不累述了。 说说接口吧,在JAVA不支持多继承的,实际上接口起到了类似多继承的作用,一个类只能继承另一个类(或抽象类)但可以实现多个接口。

    打个比方,“张三”,他是一个“人”,因此他继承了“人”;与此同时,他是一个“司机”,他的平时行为还有“开车”,很显然,这并不能从“人”这个类里继承下来。怎么办?。

    三、java中的封装,继承,多态怎么理解

    假设 SystemDAOI 是父类,SystemDAOImpl 是这个类的实现,即子类。

    比如如下所示:

    public abstract class SystemDAOI {//该父类的定义,也可以理解是封装

    public abstract void getCar();//定义获得汽车

    }

    public class SystemDAOImpl extends SystemDAOI {//我是子类

    /*

    * 由于该类继承SystemDAOI,所以必须实现父类定义的方法。

    */

    @override

    public void getCar(){

    //..写一些代码实现如何获得汽车。

    }

    //在此子类新定义同名方法,但参数不一样,这种叫多态

    public void getCar(int money) {

    //。。写一些代码根据参数值(money)如何获得汽车。

    }

    }

    如果你是初学者,不懂没关系,多做几次习题,多多思考,这些基础都是潜移默化的。不必太担心自己不会。

    四、java中的封装、继承、多态的

    封装,继承,多态,这是JAVA面向对象编程的三大特性了。

    1。封装:是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。

    封装是类的特征之一,应该很好理解,像一些私有的,别的类不可以访问了啊,都有访问权限的,比较安全了。2。

    继承:指这样一种能力:它可以使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展。 继承有三种方式,实现继承、接口继承和可视继承。

    3。多态:简单的说就是,允许将子类类型的指针赋值给父类类型的指针。

    实现多态,有二种方式,方法覆盖,方法重载。JAVA博大精深,不是一言两语就可以说清的,我就不在这里多言了,简单的说了一点点,希望亲能采纳~。

    五、java中的封装,继承,多态怎么理解

    假设 SystemDAOI 是父类,SystemDAOImpl 是这个类的实现,即子类。

    比如如下所示:public abstract class SystemDAOI {//该父类的定义,也可以理解是封装 public abstract void getCar();//定义获得汽车}public class SystemDAOImpl extends SystemDAOI {//我是子类 /* * 由于该类继承SystemDAOI,所以必须实现父类定义的方法。 */ @override public void getCar(){ //..写一些代码实现如何获得汽车。

    } //在此子类新定义同名方法,但参数不一样,这种叫多态 public void getCar(int money) { //。

    写一些代码根据参数值(money)如何获得汽车。 }}如果你是初学者,不懂没关系,多做几次习题,多多思考,这些基础都是潜移默化的。

    不必太担心自己不会。

    六、关于JAVA类的封装,继承,多态

    public class Account{ private String acctNumber; private String customerName; private String acctOpenTime; private String customerIdNum; private double balance; public Account(String accoutnNumber){ this.acctNumber = accoutnNumber; } public Account openAccount(String accountNumber){ return new Account(accountNumber); } public void save(double money){ this.balance += money; } public void query(){ System.out.println("Balance is: " + balance); //。

    . }}。

    七、如何理解封装、继承、多态

    你好象发错地方了吧!!这是个编程问题!!!不过还是给你个答案吧! 继承的好处是代码重用.哲学上讲事物都是有共性和特性的.把共性函数代码放入到父类中,把特性函数代码放入到子类中,当然是否共性要以参照点的标准.OO中所谓的抽象我自己理解为哲学中的共性在同一个行业中,他们各业务流程往往有很大的相似性,但往往我们都是到一个项目中就重新写一套流程代码,或者粘贴以前的代码.可能有很多代码都是以前写过的重复代码.造成重复劳动.如果采用继承应该这样,首先在父类中做一个基本上大部分行业项目都必要的简洁的主流程.在子类中针对具体项目的特殊性做主流程充分的完善的补充.这样在每个项目中,只针对项目的特殊性编写代码,大大降低重复劳动.当然根据具体流程的复杂多可以划分多的继承层次,呈现一种继承的树结构,但一定的要保证层次一定要有实际的意义.2,为什么要封装高内聚低偶合的思想简单的理解同一模块内的提高内聚,不同模块降低偶合.如果说一个类代表一个模块或是一个业务流,那么A类内部要提高内聚,类的属性可以看成是内的局部变量.提高数据的重用.公共函数尽量能被其他主函数,尽量达到功能内聚.如果说是A类和B类,并且是不同模块(也许是同一个模块下的两个子模块),那么B是不能使用A的函数和属性的,紧进行数据偶合.封装的作用就体现在这里.再现实中就项目中经常遇到这种情况,某项业务增加或修改一种类型的业务流,自己本身调试成功了,但是缺影响了此业务下其他的业务流,不得不测试所有得其他原本正常的业务流并不得不针对此做类型判断的补丁,这种补丁很肯能导致程序结构的不合理.3.为什么多态个人认为多态的好处体现在代码的可扩充性,比如一个业务有多个业务流,为了区别不同的类型就的使用判断,那么新添加一个流程就得在过程执行主流程(往往是final,必然是面向过程的)中添加一个”if then”或是重载一个函数在目前项目中mvc得控制器就是典型的多态.想想如果我们不使用多态那么怎么办?因为对PO对象是新添加的,那么必须针对新的PO对象在代码中做IF判断,才能用他本身的对象类型指向他.造成过程执行主流程不断的要变更自己的代码.总结: OO中继承和多态互相依赖又互相矛盾,没有继承就不可能有多态,多态的使用往往又在面向过程的代码中.继承是使子类可以使用父类的功能,而多态使父类能使用子类的功能. OO并非只是在编码阶段来处理,实际上在概要设计,详细设计,数据库设计的时候就应该OO的思想来设计.提高软件可重用性和可扩充性.对于想对一个行业做标准化产品软件而言,很重要.找本ThinkInJAVA 或C核心编程!!!对这介绍的很详细!!!!!面向对象语言!!!。

    八、java类的封装、继承与多态性

    如果你的这个设计没有特殊要求的话,一楼的算是正解了,如果要求封装和简写代码的话;可以参考下这个public class Calculator{ int sum=0; public int cal(int a,int b,string sign){ if(sign.equals("+")){sum=a+b; System.out.println(sum); }else if(sign.equals("-")){sum=a-b; System.out.println(sum); }else if(sign.equals("*")){sum=a*b; System.out.println(sum); }else if(sign.equals("/") && b!=0){sum=a/b; System.out.println(sum); }return sum;} public static void main(String args[]){ Calculator c=new Calculator(); c.cal(3,2,"+");c.cal(3,2,"-");c.cal(3,2,"*");c.cal(3,2,"/");} }。

    九、java中的封装、继承、多态的

    封装,继承,多态,这是JAVA面向对象编程的三大特性了。

    1。封装:是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。封装是类的特征之一,应该很好理解,像一些私有的,别的类不可以访问了啊,都有访问权限的,比较安全了。

    2。继承:指这样一种能力:它可以使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展。

    继承有三种方式,实现继承、接口继承和可视继承。

    3。多态:简单的说就是,允许将子类类型的指针赋值给父类类型的指针。

    实现多态,有二种方式,方法覆盖,方法重载。

    JAVA博大精深,不是一言两语就可以说清的,我就不在这里多言了,简单的说了一点点,希望亲能采纳~

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

    千次阅读 2021-08-09 20:30:58
    Java 代码实现 public class Homework1801 { public static void main(String[] args) { //创建员工对象 SalariedEmployee a = new SalariedEmployee("赵四",8,4000); HourlyEmployee b =new HourlyEmployee("王五...

    题目描述

    某公司的雇员分为以下若干类:
    Employee:这是所有员工总的父类,
    属性:员工的姓名,员工的生日月份。
    方法:getSalary(intmonth)
    根据参数月份来确定工资,如果该月员工过生日,则公司会额外奖励100 元。
    SalariedEmployee:Employee 的子类,拿固定工资的员工。
    属性:月薪
    HourlyEmployee: Employee 的子类, 按小时拿工资的员工,每月工作超出160 小时的部分按照1.5 倍工资发放。
    属性:每小时的工资、每月工作的小时数
    SalesEmployee:Employee 的子类,销售人员,工资由月销售额和提成率决定。
    属性:月销售额、提成率
    BasePlusSalesEmployee:SalesEmployee 的子类,有固定底薪的销售人员,工资 由底薪加上销售提成部分。
    属性:底薪。
    根据要求创建 SalariedEmployee 、 HourlyEmployees 、SaleEmployee 和 BasePlusSalesEmployee四个类的对象各一个,并计算某个月这四个对象的工资。
    注意:要求把每个类都做成完全封装,不允许非私有化属性。

    Java 代码实现

    public class Homework1801 {
        public static void main(String[] args) {
            //创建员工对象
            SalariedEmployee a = new SalariedEmployee("赵四",8,4000);
            HourlyEmployee b =new HourlyEmployee("王五",9,20,270);
            SalesEmployee c = new SalesEmployee("孙六",5,40000,0.1);
            BasePlusSalesEmploy d = new BasePlusSalesEmploy("张三",7,40000,0.1,1000);
    
            System.out.println(a.getName()+"的工资是:"+a.getSalary(8));
            System.out.println(b.getName()+"的工资是:"+b.getSalary(8));
            System.out.println(c.getName()+"的工资是:"+c.getSalary(8));
            System.out.println(d.getName()+"的工资是:"+d.getSalary(8));
    
        }
    }
    //员工的父类
    class Employee{
        //姓名
        private String name;
        //生日
        private int birth;
        //构造方法
        public Employee(){}
        public Employee(String name, int birth) {
            this.name = name;
            this.birth = birth;
        }
        //getter setter方法
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
        public int getBirth() {
            return birth;
        }
    
        public void setBirth(int birth) {
            this.birth = birth;
        }
        //工资方法
        public double getSalary(int month){
            return (this.birth == month)?100:0;
        }
    }
    //SalariedEmployee:拿固定工资的员工
    class SalariedEmployee extends Employee{
        //月薪
        private double monthMoney;
        //无参数构造方法
    
        public SalariedEmployee() {
        }
        //有参数构造方法
        public SalariedEmployee(String name, int birth, double monthMoney) {
            super(name, birth);
            this.monthMoney = monthMoney;
        }
    
        public double getMonthMoney() {
            return monthMoney;
        }
    
        public void setMonthMoney(double monthMoney) {
            this.monthMoney = monthMoney;
        }
    
        //工资方法
        public double getSalary(int month) {
            return monthMoney + super.getSalary(month);
        }
    }
    //HourlyEmployee:按小时拿工资的员工
    class HourlyEmployee extends Employee{
        //每小时的工资
        private double hourMoney;
        //每月工作的小时数
        private int hourWork;
        //无参数构造方法
        public HourlyEmployee() {
        }
        //有参数构造方法
        public HourlyEmployee(String name, int birth, double hourMoney, int hourWork) {
            super(name, birth);
            this.hourMoney = hourMoney;
            this.hourWork = hourWork;
        }
    
        public double getHourMoney() {
            return hourMoney;
        }
    
        public void setHourMoney(double hourMoney) {
            this.hourMoney = hourMoney;
        }
    
        public int getHourWork() {
            return hourWork;
        }
    
        public void setHourWork(int hourWork) {
            this.hourWork = hourWork;
        }
    
        //工资方法
        public double getSalary(int month) {
            if (hourWork > 160){
                return 160 * hourMoney + (hourWork - 160) * 1.5 * hourMoney + super.getSalary(month);
            }else {
                return hourMoney * hourWork + super.getSalary(month);
            }
        }
    }
    //SalesEmployee:按月销售额和提成率拿工资的员工
    class SalesEmployee extends Employee{
        //月销售额
        private double saleMoney;
        //提成率
        private double commissionRate;
        //无参构造
        public SalesEmployee() {
        }
        //有参构造
        public SalesEmployee(String name, int birth, double saleMoney, double commissionRate) {
            super(name, birth);
            this.saleMoney = saleMoney;
            this.commissionRate = commissionRate;
        }
        //getter setter方法
        public double getSaleMoney() {
            return saleMoney;
        }
    
        public void setSaleMoney(double saleMoney) {
            this.saleMoney = saleMoney;
        }
    
        public double getCommissionRate() {
            return commissionRate;
        }
    
        public void setCommissionRate(double commissionRate) {
            this.commissionRate = commissionRate;
        }
        //工资方法
        public double getSalary(int month) {
            return saleMoney * commissionRate + super.getSalary(month);
        }
    }
    //BasePlusSalesEmploy:有固定底薪和提成的员工
    class BasePlusSalesEmploy extends SalesEmployee{
        //底薪
        private double baseMoney;
        //无参构造
        public BasePlusSalesEmploy() {
        }
        //有参构造
        public BasePlusSalesEmploy(String name, int birth, double saleMoney, double commissionRate, double baseMoney) {
            super(name, birth, saleMoney, commissionRate);
            this.baseMoney = baseMoney;
        }
        //getter setter方法
        public double getBaseMoney() {
            return baseMoney;
        }
    
        public void setBaseMoney(double baseMoney) {
            this.baseMoney = baseMoney;
        }
        //工资方法
        public double getSalary(int month) {
            return super.getSalary(month) + baseMoney;
        }
    }
    

    实现效果

    赵四的工资是:4100.0
    王五的工资是:6500.0
    孙六的工资是:4000.0
    张三的工资是:5000.0

    展开全文
  • 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封装继承多态

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

    2022-03-22 20:27:32
    封装(数据的隐藏) 通常,应禁止直接访问一个对象中数据的实际表示,而应通过操作接口来访问,这称为信息隐藏。 记住这句话就够了:属性私有,get/set package MIanxing; /* 封装的优点: 1.提高程序点的安全性...
  • NULL 博文链接:https://lingf.iteye.com/blog/1450831
  • 细品java封装继承多态

    千次阅读 多人点赞 2020-04-02 22:13:46
    目录: 1.封装 2.继承 3.多态 1.封装
  • 面向对象有三大特性:封装继承多态。通过简单易于理解的案例和概念,依次学习该三大特性。
  • Java封装继承多态及面向对象的一些理解 Java基本特性三个:封装、继承、多态。但是初看这三个字面意思非常难理解其精髓。即使看了很多例子也是一知半解的感觉。本文主要就自己理解说一下这三个特性的含义。 ...
  • Java封装继承多态实例以及文件流操作,自己整理的东西,用了单态模式实现了多态,并且贯彻了OOP思想,用到了文件流的写入与读取,希望对大家有帮助
  • java 封装 继承 多态

    千次阅读 2019-03-16 21:15:08
    面向对象编程(Object Oriented Programming)有三大特性:封装继承多态。在这里,和大家一起加深对三者的理解。 封装 封装可以拆开理解,装,是把数据和方法放进了类里;封,把装进去的数据和成员方法加上访问...
  • java的题目 继承的测试题大神大神来看看
  • JAVA面向对象基础测试题 提示本题为第一阶段JAVA面向对象基础部分练习题包括对象类继承封装多态接口内部类等等java核心基础适合初学者对面向对象基础的知识进行测试以便查漏补缺 1. 程序执行的结果是 01 public ...
  • Java 封装继承多态

    千次阅读 2021-03-07 14:27:26
    Java 封装继承多态1.封装封装的理解:将类的某些信息隐藏在类的内部,不允许外部程序直接访问,并通过该类提供的方法来实现对隐藏信息的操作和访问。(简单的说就是隐藏对象的信息,留出访问的接口)。特点:1....
  • 鬲昌大承实验报告学生姓名: 学 号:专业班级:实验类型:口验证 □综合 □设计 □创新 实验日期: 实验成绩:一、实验项目名称抽象、封装与类(一)二、实验目的掌握抽象、封装继承多态熟练掌握如何白定义一个类...
  • 更好的阅读体验:Java封装继承多态的理解 1.封装 封装:就是隐藏对象的属性和实现细节,仅对外提供公共访问方式。让使用者知道的才暴露出来,不需要让使用者知道的全部隐藏起来 封装的好处:避免使用者直接...
  • 封装 多是对属性而言的 数据的隐藏,仅暴露少量方法给外部使用 关键:私有属性:get/set 举例 #student package OOP; public class student { private String name; private int id; private char sex; } #demo1 ...
  • Java封装+继承+多态 代码实例练习

    千次阅读 2021-11-27 17:49:58
    * 封装+继承+多态练习 */ public class Application { public static void main(String[] args) { /* * 封装:在类中将成员变量进行私有化,对外部提供公用的get和set方法以便于外部对类的私有成员变量进行访问...
  • JAVA 封装继承多态 三大特性以及实操
  • 封装继承多态
  • 【面试题】Java三大特性封装继承多态总结
  • java封装继承多态

    千次阅读 2022-01-28 17:07:35
    ​ 今天总结一下关于Java的三大特性,封装继承多态。其实关于三大特性对于从事编程人员来说都是基本的了,毕竟只要接触Java这些都是先要认识的,接下来就系统总结一下。 二,封装 ​ 先来说说特性之一:封装 ...
  • Java中的封装继承多态(详解)

    千次阅读 多人点赞 2021-05-21 22:07:08
    目录封装继承 封装 所谓的封装就是把类的属性和方法使用private修饰,不允许类的调用者直接访问,我们定义如下一个类,可以看到所有的成员变量和成员方法都使用private修饰了,我们现在来使用一下这个类。 当我们...
  • 封装继承多态和抽象 1、封装 封装给对象提供了隐藏内部特性和行为的能力,对象提供了一些能被其他对象访问的方法来改变它的内部数据。java中提供3中修饰符public、private和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; } } .....
  • 封装继承多态总结

    2013-12-06 09:29:22
    封装继承多态总结
  • 继承封装多态 上一篇主要讲了类和对象,这次我们的主要讲述面向对象的三大特性:继承封装多态。 首先在每个特点开始最前方我会放一下图谱,按照图谱结果开始进行逐步讲解,只是图谱未免太干干巴巴因此我们...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 109,664
精华内容 43,865
关键字:

java封装继承多态

java 订阅