ICode9

精准搜索请尝试: 精确搜索
首页 > 编程语言> 文章详细

java语言的基本特性以及编程细节

2020-07-08 19:01:35  阅读:186  来源: 互联网

标签:java 继承 子类 编程 细节 num Child 父类 public


前言

java语言的学习是一个体系,所以如果想要对java的编程有一个很精通的一个掌握,它离不开很多基础的知识点,比如JVM的原理、java多线程并发编程、数据结构等等。所以我这里对我学习的java的课程进行定期的总结,来记录我学习java的一些想法和心得。也希望能通过我的这些分享,给需要的学习某方面知识的人一些帮助。

java基础的回顾总结

java语言最明显的几个特点就是:封装、继承和多态,下面来具体聊一聊这三个特性。

封装

封装,它是一中信息隐藏技术。面向对象计算始于这个基本概念,即现实世界可以被描绘成一系列完全自治、封装的对象,这些对象通过一个受保护的接口访问其他对象。在java中通过关键字private,protected和public实现封装。所以说,封装把对象的所有组成部分组合在一起,封装定义程序如何引用对象的数据,封装实际上使用方法将类的数据隐藏起来,控制用户对类的修改和访问数据的程度。 适当的封装可以让程式码更容易理解和维护,也加强了程式码的安全性。

继承

继承是从已有的类中派生出新的类,新的类能吸收已有类的数据属性和行为,并能扩展新的能力。 新类的定义可以增加新的数据或新的功能,也可以用父类的功能,但不能选择性地继承父类,就是说子类会继承父类的所有成员属性和方法。继承只能单一继承,一个类只能继承一个父类,而不能有多个继承类,多继承的方式只能通过接口来实现
在我们日常编程中,合理的使用继承特性,能够消除代码的复制,从而达到简化代码以及程序逻辑的作用。
这里我们来说一下继承的特性。

  1. 继承关系是传递的。若类C继承类B,类B继承类A(多层继承),则类C既有从类B那里继承下来的属性与方法,也有从类A那里继承下来的属性与方法,还可以有自己新定义的属性和方法。继承来的属性和方法尽管是隐式的,但仍是类C的属性和方法。继承是在一些比较一般的类的基础上构造、建立和扩充新类的最有效的手段。
  2. 继承简化了人们对事物的认识和描述,能清晰体现相关类间的层次结构关系。
  3. 继承提供了软件复用功能。若类B继承类A,那么建立类B时只需要再描述与基类(类A)不同的少量特征(数据成员和成员方法)即可。这种做法能减小代码和数据的冗余度,大大增加程序的重用性。
  4. 继承通过增强一致性来减少模块间的接口和界面,大大增加了程序的易维护性。
    下面我们来通过一段代码来说明子类和父类的继承关系。
package com.young.basic;

public class ExtendsDemo {
    //main
    public static void main(String aa[]) {
    //new 一个对象B()
        new B();
        new C();
    }
}

//建一个A类
class A {
    //成员变量 其中num是实参
    int num = 0;
    private String name = "default name";

    public A(){
        System.out.println("父类无参数构造方法");
    }

    //成员方法,其中 i 是形参
    public A(int i) {
        //输入int型文件输出下面
        System.out.println("aaaaaaaaaaaaaaaaaaa");
        System.out.println("i= " + i);
        //把输入的i赋值给成员变量num
        num = i;
    }

    public String getName() {
        return name;
    }

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

//B继承A
class B extends A {
    int num = 0;

    //成员方法B.
    public B() {
        //继承类A的方法.因为B继承了A必然继承了A的特性.所以输入int值10令方法实现.
        super(10);
        System.out.println("bbbbbbbbbbbbbbbbbbbb");
        //这里的num是类B的.
        System.out.println("num= " + num);
        //如果想显示类A的num则需要用下列的super.num.这里注意num在类A中需是成员变量才可以.
        System.out.println("super.num= " + super.num);
        //子类继承的私有name只能通过继承的公有方法来访问和修改;如果没有提供公共方法,则不能访问和修改
        System.out.println("子类的name = " + this.getName());
    }

    @Override
    public void setName(String name) {
        super.setName(name);
        System.out.println("这是子类B的重写的");
    }
}

class C extends A{

    public C(){
        System.out.println("子类C无参数构造函数");
        System.out.println("cccccccccccccccc");
    }
}

运行结果:

aaaaaaaaaaaaaaaaaaa
i= 10
bbbbbbbbbbbbbbbbbbbb
num= 0
super.num= 10
子类的name = default name
父类无参数构造方法
子类C无参数构造函数
cccccccccccccccc

从上边例子中我们能看出,

  1. 子类是不继承父类的构造器(构造方法或者构造函数)的,它只是调用(隐式或显式)。如果父类的构造器带有参数,则必须在子类的构造器中显式地通过super关键字调用父类的构造器并配以适当的参数列表。如果父类的构造器有没有参数的,则在子类的构造器中不需要使用super关键字调用父类构造器,系统会自动调用父类的无参构造器。
  2. 如果父类中的成员变量是私有的(private),子类是不能访问的和修改的,除非父类提供了公共方法来进行访问和修改。
  3. 子类可以重写(override)父类的方法,从而使子类具有自己独特的功能。这其实是我们后边讲的多态的一种体现

多态

在面向对象语言中,接口的多种不同的实现方式即为多态。那么在Java语言中,多态,意味着一个对象有着多重特征,可以在特定的情况下,表现不同的状态,从而对应着不同的属性和方法。多态的这种思想使Java语言更加的灵活,很多设计模式和spring框架中都使用到了多态技术。
具体的表现在这些方面:

  1. 父类定义子类来构建
  2. 接口定义实现类来构建
  3. 抽象类定义实体类来构建
  4. 类方法的重载(overload)和重写(override)

----------------------2020年07月08日18:54:40 未完待续---------------------------------------------

我们还是通过一段代码来了解:

public class PolymorphismDemo {
    public static void main(String[] args) {
        IParent p1 = new Child_A();
        IParent p2 = new Child_B();
        doSimpleCall(p1);
        doSimpleCall(p2);

        Child_A child_a = new Child_A();
        Child_B child_b = new Child_B();
        //child_a 没有重写父类的eat方法,所以执行的是父类的eat方法
        child_a.eat();
        //child_b重写了父类的eat方法,所以执行自己的eat方法
        child_b.eat();
        //child_b对eat方法进行了重载,增加了一个输入参数
        child_b.eat("popcorn");
    }

    //这里我们并不知道具体穿给我们的是哪个实现Parent的类
    public static void doSimpleCall(IParent p){
        p.simpleCall();
    }

}

interface IParent//父类接口
{
    public void simpleCall();
}

//父类
class Parent{
    public void eat(){
        System.out.println("parent is eating");
    }
}

class Child_A extends Parent implements IParent
{
    public void simpleCall()
    {
        System.out.println("I am Child_A");
        //具体的实现细节;
    }

}

class Child_B extends Parent implements IParent
{
    public void simpleCall()
    {
        System.out.println("I am Child_B");
        //具体的实现细节;
    }

    @Override
    public void eat() {
        System.out.println("Child_B is eating");
    }

    //这里通过增加一个String类型的参数对eat方法进行方法的重载
    public void eat(String food){
        System.out.println("Child_b is eating" + food);
    }
}

代码运行结果:

I am Child_A
I am Child_B
parent is eating
Child_B is eating
Child_b is eating popcorn

---------------2020年07月08日 未完待续--------------------------------------

标签:java,继承,子类,编程,细节,num,Child,父类,public
来源: https://www.cnblogs.com/mr-ziyoung/p/13256260.html

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有