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

前言

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)

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

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

在上边代码中，将子类的对象赋值给父类的变量的方式就叫做向上造型，但是反过来父类的对象不能赋值给子类。向上造型和类型转换不一样，类型转换一般是针对基本类型来说的。

编程细节

在编写Java程序时如果能注意一些编程细节，会对整个项目的开发带来积极的作用，是你编写的程序更容易的被读懂和维护。在这里推荐在java的开发工具中安装一个阿里巴巴开发规约插件p3c，有时间的也可以去阅读《阿里巴巴Java开发手册》和《effective java》。
---------------2020年07月08日 未完待续--------------------------------------