精华内容
下载资源
问答
  • 多态性面向对象(OOP)三大特性:封装、继承、多态。多态性(polymorphism)指同一行为具有多种不同表现形式,在面向对象程序设计中...面向对象多态性存在的三个必要条件继承重写父类引用指向子类对象多态性的实现方式...

    多态性

    面向对象(OOP)三大特性:封装、继承、多态。

    多态性(polymorphism)指同一行为具有多种不同表现形式,在面向对象程序设计中表现为同一消息可以根据发送对象的类型不同,做出多种不同的行为。

    多态性的优点

    多态性能够从一定程度上消除类型之间的耦合关系,通过统一接口方式,不同类的对象可以直接替换,程序更加灵活,可扩展。

    面向对象多态性存在的三个必要条件

    继承

    重写

    父类引用指向子类对象

    多态性的实现方式

    重写(Override)与重载(Overload)

    静态多态性:方法重载(Method Overloading)

    方法重载(Method Overloading)允许类具有多个相同名称的方法,但是方法参数列表不同。

    重载形式:

    case 1: 参数数量变化(有效)

    add(int, int)

    add(int, int, int)

    case 2: 参数数据类型变化(有效)

    add(int, int)

    add(int, float)

    case 3: 参数数据类型顺序变化(有效)

    add(int, float)

    add(float, int)

    bad case 1: 仅改变返回类型(无效)

    int add(int, int)

    float add(int, int)

    Java 方法签名由方法名称和其后的参数列表共同决定,仅改变返回类型编译器无法重载。 不过方法重载(Method Overloading)允许改变返回类型和存取权限,但两者不属于方法签名。

    方法重载(Method Overloading)式多态性,即方法调用取决于调用时传递的参数(数量、类型、顺序),属于编译时静态多态性。

    动态多态性:方法重写(Method Overriding)

    方法重写(Method Overriding)允许子类对父类可以访问的方法,实现自定义行为,但是方法签名需要保持一致。重写的优点在于,无需修改父类代码即可改变子类继承的方法。

    重写形式:

    重写依赖继承,通过父类引用,指向子类对象实现动态多态性。

    public class Animal{

    public void sound(){

    System.out.println("Animal is making a sound");

    }

    }

    public class Cat extends Animal{

    @Override

    public void sound(){

    System.out.println("Meow");

    }

    public static void main(String args[]){

    Animal obj = new Cat();

    obj.sound();

    }

    }

    输出:

    Meow

    重写(覆盖)规则:

    方法签名(方法名称和参数列表)必须一样,返回类型需要兼容。

    不能降低方法的存取权限。

    static, private, final 标记的方法以及类的构造方法不能被重写(覆盖)。

    分析原因:

    Java 通过方法签名标识方法,因此重写需要确保是子类继承自父类的同一方法。

    子类不可以降低父类方法的存取权限(可见性),但可以升级。继承反映一种 “is a” 关系,子类是父类,支持父类所有对外开放的行为。降低方法的存取权限,使得父类作为统一接口方式调用方法的能力被破坏。

    private, final 标记的方法以及父类的构造方法无法继承,故无法重写。

    static 标记的方法为静态方法属于类,通过类名.方法名形式调用,无需依赖对象。

    静态方法和属性会被子类继承,子类同样允许定义同名静态方法和属性,区别于实例方法“重写”和属性“重名”,这种情况被称为“隐藏”。此时子类中调用同名的父类静态方法和属性,需要指明父类名.方法名或父类名.变量名。

    静态绑定与动态绑定

    多态性的类型可以分为运行时和编译时,方法重写(Method Overriding)代表运行时动态多态性,方法重载(Method Overloading)代表编译时静态多态性。

    方法调用与方法体的关联称为绑定,有两种类型的绑定:在编译时发生的静态绑定(Static Binding or Early Binding)和在运行时发生的动态绑定(Dynamic Binding or Late Binding)。

    static, private, final 标记的方法以及类的构造方法是静态绑定的,在编译时确定所属类的类型,因此这些方法无法覆盖。其他非标记的方法可以称为“虚函数”,Java 中其实并没有“虚函数”的概念,所有普通函数(方法)默认都相当于 C++ 的”虚函数”允许覆盖(Override),因此虚函数(Virtual Method)能够根据运行时具体对象的类型进行动态绑定实现动态多态性,例如方法重写(Method Overriding)。

    静态绑定示例:

    class Human{

    public static void walk()

    {

    System.out.println("Human walks");

    }

    }

    class Boy extends Human{

    public static void walk(){

    System.out.println("Boy walks");

    }

    public static void main( String args[]) {

    /* Reference is of Human type and object is

    * Boy type

    */

    Human obj = new Boy();

    /* Reference is of Human type and object is

    * of Human type.

    */

    Human obj2 = new Human();

    obj.walk();

    obj2.walk();

    }

    }

    输出:

    Human walks

    Human walks

    声明为 static 的方法不能被重写,但是能够被再次声明(隐藏)。

    Static Binding vs Dynamic Binding

    静态绑定发生在编译时,而动态绑定发生在运行时。

    静态绑定使用的是类信息:类的类型决定调用方法,而动态绑定使用的是对象信息:对象的类型决定调用方法。

    方法重载使用静态绑定,而方法重写使用动态绑定。

    综合练习

    多态性示例程序:

    class A {

    public String show(D obj) { // 方法一

    return ("A and D");

    }

    public String show(A obj) { // 方法二

    return ("A and A");

    }

    }

    class B extends A {

    public String show(B obj) { // 方法三

    return ("B and B");

    }

    public String show(A obj) { // 方法四

    return ("B and A");

    }

    }

    class C extends B {

    }

    class D extends B {

    }

    public class Main {

    public static void main(String[] args) {

    A a1 = new A();

    A a2 = new B();

    B b = new B();

    C c = new C();

    D d = new D();

    System.out.println("1--" + a1.show(b));

    System.out.println("2--" + a1.show(c));

    System.out.println("3--" + a1.show(d));

    System.out.println("4--" + a2.show(b));

    System.out.println("5--" + a2.show(c));

    System.out.println("6--" + a2.show(d));

    System.out.println("7--" + b.show(b));

    System.out.println("8--" + b.show(c));

    System.out.println("9--" + b.show(d));

    }

    }

    运行结果:

    1--A and A

    2--A and A

    3--A and D

    4--B and A

    5--B and A

    6--A and D

    7--B and B

    8--B and B

    9--A and D

    详细分析:

    A、B、C、D 各类继承关系如图所示:

    3c4fbe07e389df8e1674cd101adca968.png

    A a1 = new A(); 正常创建对象 a1,涉及函数重载 show(),a1 具有调用方法一 show(D obj) 和方法二 show(A obj) 的能力。

    a1.show(b) 由编译器进行静态绑定(前期绑定)方法二 show(A obj)。

    a1.show(c) 由编译器进行静态绑定(前期绑定)方法二 show(A obj)。

    a1.show(d) 由编译器进行静态绑定(前期绑定)方法一 show(D obj)。

    A a2 = new B(); 多态创建父类引用,指向子类对象,a2 向上转型具有调用 A 类方法一 show(D obj) 和方法二 show(A obj) 的能力,其中子类 B 重写父类 A 的方法二 show(A obj) 为方法四 show(A obj)。记住向上转型存在缺点,即不能调用子类中有,父类没有的方法,如方法三 show(B obj)。

    a2.show(b) 运行时动态绑定(后期绑定)方法四 show(A obj)。

    a2.show(c) 运行时动态绑定(后期绑定)方法四 show(A obj)。

    a2.show(d) 由编译器进行静态绑定(前期绑定)方法一 show(D obj)。

    B b = new B(); 正常创建对象 b,涉及函数重载 show(),b 具有调用方法三 show(B obj) 和方法四 show(A obj) 的能力。同时 B 继承自 A 因此拥有方法一 show(D obj) 和方法二 show(A obj) 其中方法二被方法四重写覆盖。

    b.show(b) 由编译器进行静态绑定(前期绑定)方法三 show(B obj)。

    b.show(c) 由编译器进行静态绑定(前期绑定)方法三 show(B obj)。

    b.show(d) 由编译器进行静态绑定(前期绑定)方法一 show(D obj)。

    展开全文
  • Java 多态多态是同一个行为具有多个不同表现形式或形态能力。多态优点 消除类型之间耦合关系 可替换 可扩充 接口 灵活 简化 多态存在三个必要条件继承 重写 父类引用指向子类对象 比如: ...

    Java 多态

    多态是同一个行为具有多个不同表现形式或形态的能力。

    多态的优点

    1. 消除类型之间的耦合关系
    2. 可替换性
    3. 可扩充性
    4. 接口性
    5. 灵活性
    6. 简化性

    多态存在的三个必要条件

    继承
    重写
    父类引用指向子类对象
    比如:
    Parent p = new Child();
    当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;如果有,再去调用子类的同名方法。
    多态的好处:可以使程序有良好的扩展,并可以对所有类的对象进行通用处理。

    虚方法

    我们将介绍在Java中,当设计类时,被重写的方法的行为怎样影响多态性。
    我们已经讨论了方法的重写,也就是子类能够重写父类的方法。
    当子类对象调用重写的方法时,调用的是子类的方法,而不是父类中被重写的方法。
    要想调用父类中被重写的方法,则必须使用关键字super。

    多态的实现方式

    方式一:重写:
    方式二:接口
    方式三:抽象类和抽象方法

    Java 抽象类

    在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。
    抽象类除了不能实例化对象之外,类的其它功能依然存在,成员变量、成员方法和构造方法的访问方式和普通类一样。
    由于抽象类不能实例化对象,所以抽象类必须被继承,才能被使用。也是因为这个原因,通常在设计阶段决定要不要设计抽象类。
    父类包含了子类集合的常见的方法,但是由于父类本身是抽象的,所以不能使用这些方法。
    在Java中抽象类表示的是一种继承关系,一个类只能继承一个抽象类,而一个类却可以实现多个接口。

    抽象类

    在Java语言中使用abstract class来定义抽象类

    抽象方法

    如果你想设计这样一个类,该类包含一个特别的成员方法,该方法的具体实现由它的子类确定,那么你可以在父类中声明该方法为抽象方法。
    Abstract关键字同样可以用来声明抽象方法,抽象方法只包含一个方法名,而没有方法体。
    抽象方法没有定义,方法名后面直接跟一个分号,而不是花括号。
    声明抽象方法会造成以下两个结果:
    如果一个类包含抽象方法,那么该类必须是抽象类。
    任何子类必须重写父类的抽象方法,或者声明自身为抽象类。
    继承抽象方法的子类必须重写该方法。否则,该子类也必须声明为抽象类。最终,必须有子类实现该抽象方法,否则,从最初的父类到最终的子类都不能用来实例化对象。

    抽象类总结规定

    1. 抽象类不能被实例化(初学者很容易犯的错),如果被实例化,就会报错,编译无法通过。只有抽象类的非抽象子类可以创建对象。
    2. 抽象类中不一定包含抽象方法,但是有抽象方法的类必定是抽象类。
    3. 抽象类中的抽象方法只是声明,不包含方法体,就是不给出方法的具体实现也就是方法的具体功能。
    4. 构造方法,类方法(用static修饰的方法)不能声明为抽象方法。
    5. 抽象类的子类必须给出抽象类中的抽象方法的具体实现,除非该子类也是抽象类

    Java 封装

    在面向对象程式设计方法中,封装(英语:Encapsulation)是指,一种将抽象性函式接口的实作细节部份包装、隐藏起来的方法。
    封装可以被认为是一个保护屏障,防止该类的代码和数据被外部类定义的代码随机访问。
    要访问该类的代码和数据,必须通过严格的接口控制。
    封装最主要的功能在于我们能修改自己的实现代码,而不用修改那些调用我们代码的程序片段。
    适当的封装可以让程式码更容易理解与维护,也加强了程式码的安全性。

    封装的优点

    1. 良好的封装能够减少耦合。
    2. 类内部的结构可以自由修改。
    3. 可以对成员变量进行更精确的控制。
    4. 隐藏信息,实现细节。

    重点内容实现Java封装的步骤

    1. 修改属性的可见性来限制对属性的访问(一般限制为private),例如:
      public class Person {
      private String name;
      private int age;
      }
      这段代码中,将 name 和 age 属性设置为私有的,只能本类才能访问,其他类都访问不了,如此就对信息进行了隐藏。
    2. 对每个值属性提供对外的公共方法访问,也就是创建一对赋取值方法,用于对私有属性的访问,例如:
      public class Person{
      private String name;
      private int age;

      public int getAge(){
      return age;
      }

      public String getName(){
      return name;
      }

      public void setAge(int age){
      this.age = age;
      }

      public void setName(String name){
      this.name = name;
      }
      }
      采用 this 关键字是为了解决实例变量(private String name)和局部变量(setName(String name)中的name变量)之间发生的同名的冲突。

    Java 接口

    接口(英文:Interface),在JAVA编程语言中是一个抽象类型,是抽象方法的集合,接口通常以interface来声明。一个类通过继承接口的方式,从而来继承接口的抽象方法。
    接口并不是类,编写接口的方式和类很相似,但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
    除非实现接口的类是抽象类,否则该类要定义接口中的所有方法。
    接口无法被实例化,但是可以被实现。一个实现接口的类,必须实现接口内所描述的所有方法,否则就必须声明为抽象类。另外,在 Java 中,接口类型可用来声明一个变量,他们可以成为一个空指针,或是被绑定在一个以此接口实现的对象。

    Java接口的作用与优点:

    接口的最主要的作用是达到统一访问,就是在创建对象的时候用接口创建,【接口名】 【对象名】=new 【实现接口的类】,这样你像用哪个类的对象就可以new哪个对象了,不需要改原来的代码,就和你的USB接口一样,插什么读什么,就是这个原理。就像你问的,都有个method1的方法,如果我用接口,我上面就可以one.method1();是吧?那样我new a();就是用a的方法,new b()就是用b的方法
    这样不方便吗?
    这个就叫统一访问,因为你实现这个接口的类的方法名相同,但是实现内容不同
    我用接口来定义对象不就可以做到统一访问了吗?接口主要针对多个类实现它来说的,要是只有一个类当然可以不用接口了.你这样想,我做一个USB接口,有个read()抽象方法,然后mp3类实现,U盘类实现,移动硬盘类实现,这样我用的时候用USB a=new 【类名】;这样a.read();要是我类名里写U盘,就读U盘,写mp3就读mp3,而这个名字可以从属性文件里读,你写哪个就用哪个了,呵呵。

    接口与类相似点:

    一个接口可以有多个方法。
    接口文件保存在 .java 结尾的文件中,文件名使用接口名。
    接口的字节码文件保存在 .class 结尾的文件中。
    接口相应的字节码文件必须在与包名称相匹配的目录结构中。

    接口与类的区别:

    接口不能用于实例化对象。
    接口没有构造方法。
    接口中所有的方法必须是抽象方法。
    接口不能包含成员变量,除了 static 和 final 变量。
    接口不是被类继承了,而是要被类实现。
    接口支持多重继承。

    接口特性

    接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract(只能是 public abstract,其他修饰符都会报错)。
    接口中可以含有变量,但是接口中的变量会被隐式的指定为 public static final 变量(并且只能是 public,用 private 修饰会报编译错误。
    接口中的方法是不能在接口中实现的,只能由实现接口的类来实现接口中的方法。

    抽象类和接口的区别

    1. 抽象类中的方法可以有方法体,就是能实现方法的具体功能,但是接口中的方法不行。
    2. 抽象类中的成员变量可以是各种类型的,而接口中的成员变量只能是 public static final 类型的。
    3. 接口中不能还有静态代码块以及静态方法(用 static 修饰的方法),而抽象类是可以有静态代码块和静态方法。
    4. 一个类只能继承一个抽象类,而一个类却可以实现多个接口。

    接口的声明

    接口的声明语法格式如下:
    [可见度] interface 接口名称 [extends 其他的类名] {
    // 声明变量
    // 抽象方法
    }

    接口的实现

    当类实现接口的时候,类要实现接口中所有的方法。否则,类必须声明为抽象的类。
    类使用implements关键字实现接口。在类声明中,Implements关键字放在class声明后面。
    实现一个接口的语法,可以使用这个公式:
    Animal.java 文件代码:
    …implements 接口名称[, 其他接口, 其他接口…, …] …
    重写接口中声明的方法时,需要注意以下规则:
    类在实现接口的方法时,不能抛出强制性异常,只能在接口中,或者继承接口的抽象类中抛出该强制性异常。
    类在重写方法时要保持一致的方法名,并且应该保持相同或者相兼容的返回值类型。
    如果实现接口的类是抽象类,那么就没必要实现该接口的方法。
    在实现接口的时候,也要注意一些规则:
    一个类可以同时实现多个接口。
    一个类只能继承一个类,但是能实现多个接口。
    一个接口能继承另一个接口,这和类之间的继承比较相似。

    接口的继承

    一个接口能继承另一个接口,和类之间的继承方式比较相似。接口的继承使用extends关键字,子接口继承父接口的方法。

    接口的多重继承

    在Java中,类的多重继承是不合法,但接口允许多重继承,。
    在接口的多重继承中extends关键字只需要使用一次,在其后跟着继承接口。 如下所示:
    public interface Hockey extends Sports, Event
    以上的程序片段是合法定义的子接口,与类不同的是,接口允许多重继承,而 Sports及 Event 可能定义或是继承相同的方法

    标记接口

    最常用的继承接口是没有包含任何方法的接口。
    标识接口是没有任何方法和属性的接口.它仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。
    标识接口作用:简单形象的说就是给某个对象打个标(盖个戳),使对象拥有某个或某些特权。
    例如:java.awt.event 包中的 MouseListener 接口继承的 java.util.EventListener 接口定义如下:
    package java.util;
    public interface EventListener
    {}
    没有任何方法的接口被称为标记接口。标记接口主要用于以下两种目的:
    1.建立一个公共的父接口:
    正如EventListener接口,这是由几十个其他接口扩展的Java API,你可以使用一个标记接口来建立一组接口的父接口。例如:当一个接口继承了EventListener接口,Java虚拟机(JVM)就知道该接口将要被用于一个事件的代理方案。
    2.向一个类添加数据类型:
    这种情况是标记接口最初的目的,实现标记接口的类不需要定义任何接口方法(因为标记接口根本就没有方法),但是该类通过多态性变成一个接口类型。

    Java 包(package)

    为了更好地组织类,Java 提供了包机制,用于区别类名的命名空间。

    包的作用

    1、把功能相似或相关的类或接口组织在同一个包中,方便类的查找和使用。
    2、如同文件夹一样,包也采用了树形目录的存储方式。同一个包中的类名字是不同的,不同的包中的类的名字是可以相同的,当同时调用两个不同包中相同类名的类时,应该加上包名加以区别。因此,包可以避免名字冲突。
    3、包也限定了访问权限,拥有包访问权限的类才能访问某个包中的类。
    Java 使用包(package)这种机制是为了防止命名冲突,访问控制,提供搜索和定位类(class)、接口、枚举(enumerations)和注释(annotation)等。

    包语句的语法格式为:

    package pkg1[.pkg2[.pkg3…]];
    例如,一个Something.java 文件它的内容
    package net.java.util
    public class Something{

    }
    那么它的路径应该是 net/java/util/Something.java 这样保存的。 package(包) 的作用是把不同的 java 程序分类保存,更方便的被其他java 程序调用。
    一个包(package)可以定义为一组相互联系的类型(类、接口、枚举和注释),为这些类型提供访问保护和命名空间管理的功能。
    以下是一些 Java 中的包:
    1.java.lang-打包基础的类
    2.java.io-包含输入输出功能的函数
    开发者可以自己把一组类和接口等打包,并定义自己的包。而且在实际开发中这样做是值得提倡的,当你自己完成类的实现之后,将相关的类分组,可以让其他的编程者更容易地确定哪些类、接口、枚举和注释等是相关的。
    由于包创建了新的命名空间(namespace),所以不会跟其他包中的任何名字产生命名冲突。使用包这种机制,更容易实现访问控制,并且让定位相关类更加简单。

    创建包

    创建包的时候,你需要为这个包取一个合适的名字。之后,如果其他的一个源文件包含了这个包提供的类、接口、枚举或者注释类型的时候,都必须将这个包的声明放在这个源文件的开头。
    包声明应该在源文件的第一行,每个源文件只能有一个包声明,这个文件中的每个类型都应用于它。
    如果一个源文件中没有使用包声明,那么其中的类,函数,枚举,注释等将被放在一个无名的包(unnamed package)中。

    import 关键字

    为了能够使用某一个包的成员,我们需要在 Java 程序中明确导入该包。使用 “import” 语句可完成此功能。
    在 java 源文件中 import 语句应位于 package 语句之后,所有类的定义之前,可以没有,也可以有多条,其语法格式为:
    import package1[.package2…].(classname|*);
    如果在一个包中,一个类想要使用本包中的另一个类,那么该包名可以省略。

    package 的目录结构

    类放在包中会有两种主要的结果:
    包名成为类名的一部分,正如我们前面讨论的一样。
    包名必须与相应的字节码所在的目录结构相吻合。
    下面是管理你自己 java 中文件的一种简单方式:
    将类、接口等类型的源码放在一个文本中,这个文件的名字就是这个类型的名字,并以.java作为扩展名。例如:
    // 文件名 : Car.java

    package vehicle;

    public class Car {
    // 类实现
    }
    接下来,把源文件放在一个目录中,这个目录要对应类所在包的名字。
    ….\vehicle\Car.java
    现在,正确的类名和路径将会是如下样子:
    类名 -> vehicle.Car
    路径名 -> vehicle\Car.java (在 windows 系统中)
    通常,一个公司使用它互联网域名的颠倒形式来作为它的包名.例如:互联网域名是 xxxxx.com,所有的包名都以 com.xxxxx开头。包名中的每一个部分对应一个子目录。
    例如:有一个 com.xxxxxx.test 的包,这个包包含一个叫做 Sites.java 的源文件,那么相应的,应该有如下面的一连串子目录:
    ….\com\xxxxxx\test\Sites.java
    编译的时候,编译器为包中定义的每个类、接口等类型各创建一个不同的输出文件,输出文件的名字就是这个类型的名字,并加上 .class 作为扩展后缀。 例如:
    // 文件名: Site.java

    package com.xxxxx.test;
    public class xxxxxx{

    }
    class Google {

    }
    现在,我们用-d选项来编译这个文件,如下:
    $javac -d . xxxxxx.java
    这样会像下面这样放置编译了的文件:
    .\com\xxxxx\test\xxxxx.class
    .\com\xxxxxx\test\Google.class
    你可以像下面这样来导入所有 \com\xxxxxx\test\ 中定义的类、接口等:
    import com.xxxxxx.test.*;
    编译之后的 .class 文件应该和 .java 源文件一样,它们放置的目录应该跟包的名字对应起来。但是,并不要求 .class 文件的路径跟相应的 .java 的路径一样。你可以分开来安排源码和类的目录。
    \sources\com\xxxxx\test\xxxxx.java
    \classes\com\xxxxx\test\Google.class
    这样,你可以将你的类目录分享给其他的编程人员,而不用透露自己的源码。用这种方法管理源码和类文件可以让编译器和java 虚拟机(JVM)可以找到你程序中使用的所有类型。
    类目录的绝对路径叫做 class path。设置在系统变量 CLASSPATH 中。编译器和 java 虚拟机通过将 package 名字加到 class path 后来构造 .class 文件的路径。
    \classes 是 class path,package 名字是 com.runoob.test,而编译器和 JVM 会在 \classes\com\runoob\test 中找 .class 文件。
    一个 class path 可能会包含好几个路径,多路径应该用分隔符分开。默认情况下,编译器和 JVM 查找当前目录。JAR 文件按包含 Java 平台相关的类,所以他们的目录默认放在了 class path 中。

    设置 CLASSPATH 系统变量

    用下面的命令显示当前的CLASSPATH变量:
    Windows 平台(DOS 命令行下):C:> set CLASSPATH
    UNIX 平台(Bourne shell 下):# echo $CLASSPATH
    删除当前CLASSPATH变量内容:
    Windows 平台(DOS 命令行下):C:> set CLASSPATH=
    UNIX 平台(Bourne shell 下):# unset CLASSPATH; export CLASSPATH
    设置CLASSPATH变量:
    Windows 平台(DOS 命令行下): C:> set CLASSPATH=C:\users\jack\java\classes
    UNIX 平台(Bourne shell 下):# CLASSPATH=/home/jack/java/classes; export CLASSPATH

    #Java包(package)的命名规范,java中package命名规则
    Java的包名都有小写单词组成,类名首字母大写;包的路径符合所开发的 系统模块的 定义,比如生产对生产,物资对物资,基础类对基础类。以便看了包名就明白是哪个模块,从而直接到对应包里找相应的实现。

    由于Java面向对象的特性,每名Java开发人员都可以编写属于自己的Java Package,为了保障每个Java Package命名的唯一性,在最新的Java编程规范中,要求开发人员在自己定义的包名前加上唯一的前缀。由于互联网上的域名称是不会重复的,所以多数开发人员采用自己公司在互联网上的域名称作为自己程序包的唯一前缀。例如: com.sun.swt.……。
    
    从而,我们知道,一般公司命名为“com.公司名.项目名.模块名....”。
    那,我们个人的项目又怎么命名呢?
    经过我对“个人的”单词搜索,有“individual、personal、private、one-man”,进一步对以上4个单词词意的分析,并在保证了唯一性,使用每个单词的前4个字母作为前缀,正好和“com”也做了区分。如下:
    indi :
         个体项目,指个人发起,但非自己独自完成的项目,可公开或私有项目,copyright主要属于发起者。
         包名为“indi.发起者名.项目名.模块名.……”。
    pers :
         个人项目,指个人发起,独自完成,可分享的项目,copyright主要属于个人。
         包名为“pers.个人名.项目名.模块名.……”。
    priv :
         私有项目,指个人发起,独自完成,非公开的私人使用的项目,copyright属于个人。
         包名为“priv.个人名.项目名.模块名.……”。
    onem :
         与“indi”相同,推荐使用“indi”。
    
    另外,我为了区分团队项目和前面所说项目的区分,还有了一下扩展:
    team :
         团队项目,指由团队发起,并由该团队开发的项目,copyright属于该团队所有。
         包名为“team.团队名.项目名.模块名.……”。
    com :
    

    公司项目,copyright由项目发起的公司所有。
    包名为“com.公司名.项目名.模块名.……”。

    展开全文
  • Logtalk是一种声明性的面向对象的逻辑编程语言,它扩展并利用了Prolog语言,并具有适合大型编程的功能集。 Logtalk支持现代代码封装和代码重用机制,同时保留Prolog的声明性编程功能。 Logtalk以高度可移植的代码...
  • Java中面向对象的特征

    2021-01-26 10:27:48
    封装是保证软件部件具有优良的模块性的基础,封装的目标就是要实现软件部件的"高内聚,低耦合",防止程序相互依赖性而带来的变动影响。 在面向对象的编程语言中,对象封装的最基本单位,面向对象封装比传统语言...

    封装

    封装是保证软件部件具有优良的模块性的基础,封装的目标就是要实现软件部件的"高内聚,低耦合",防止程序相互依赖性而带来的变动影响。
    在面向对象的编程语言中,对象是封装的最基本单位,面向对象的封装比传统语言的封装更为清晰,更为有力。
    面向对象的封装就是把描述一个对象的属性和行为的代码封装在一个“模块中”,也就是一个类中,属性用变量定义,行为用方法进行定义,方法可以直接访问同一个对象中的属性。把握一个原则:把对同一事物进行操作的方法和相关的方法放在同一个类中,把方法和它操作的数据放在同一个类中。

    继承

    在定义和实现一个类的时候,可以在一个已经存在的类的基础之上来进行,把这个已经存在的类所定义的内容作为自己的内容,并可以加入若干新的内容,或修改原来的方法使之更适合特殊的需求,这就是继承。继承是子类自动共享父类数据和方法的机制,这是类之间的一种关系,提高了软件的可重用性和可扩展性

    多态

    多态是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定。即:一个引用变量到底会指向那个类的实例对象,该引用变量发出的方法调用到底是那个类中实现的方法,必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类。
    这样,不用修改源程序代码,就可以让引用变量绑定到各种不同的类实现上,从而导致引用调用的具体方法随之改变,即不修改程序代码就可以改变程序运行时所绑定的具体代码让程序可以选择多个运行状态,这就是多态性。
    多态性增强了软件的灵活性和扩展性。

    多态的实现

    在刚刚开始就提到了继承在为多态的实现做了准备。子类Child继承父类Father,我们可以编写一个指向子类的父类类型引用,该引用既可以处理父类Father对象,也可以处理子类Child对象,当相同的消息发送给子类或者父类对象时,该对象就会根据自己所属的引用而执行不同的行为,这就是多态。及多态性就是相同的消息使得不同的类做出不同的响应。

    Java实现多态有三个必要条件:继承,重写,向上转型

    • 继承:在多态中必须存在有继承关系的子类和父类。
    • 重写:子类对父类中某些方法进行重新定义,在调用这些方法时就会调用子类的方法。
    • 向上转型:在多态中需要将子类的引用赋给父类对象,只有这样该引用才能具备技能调用父类的方法和子类的方法。

    实现形式:继承和接口

    基于继承的实现机制主要表现在父类和继承该父类的一个或者多个子类对某些方法的重写,多个子类对同一方法的重写可以表现出不同的行为,继承都是单继承,只能为一组相关的类提供一致的服务接口。
    但是接口可以多继承多实现,他能够利用一组相关或者不相关的接口进行组合与扩充,能够对外提供一致的服务接口,所以它相对于继来说有更好的灵活性。


    以上,封装,继承,多态称之为面向对象的三大特征。
    除此之外,抽象也可以算是一个特征

    抽象

    抽象就是找出一些事物的相似和共性之处,然后将这些事物归为一个类,这个类只考虑这些事物的相似和共性之处,并且会忽略与当前主题和目标主题无关的哪些方面,将注意力集中在与当前目标有关的方面。例如,看到一只蚂蚁和大象,你能够想象出他们的相同之处,那就是抽象。抽象包括行为抽象和状态抽象两个方面。例如:定义一个person类,定义他们的一些属性,name/age/sex等等。

    展开全文
  • * 在面向对象编程中,为了确保数据在整个程序生命周期内有效,一般会将数据封装对象内,而对于函数式对象是不具有改变任何状态类, * 例如不可变的对象就需要保证对象在创建时数据有效,此时会用到...
    
    
    /**
      * Created by hhy on 2017/11/27.
      */
    /**
      * 函数式对象之先决条件
      * 在面向对象编程中,为了确保数据在整个程序生命周期内的有效性,一般会将数据封装到对象内,而对于函数式对象是不具有改变任何状态的类,
      * 例如不可变的对象就需要保证对象在创建时数据的有效性,此时会用到先决条件,使用先决条件的格式如下所示。
      * final def require(requirement:Boolean,message:=>Any):Unit
      * 其中require是限制条件,布尔类型返回false或者true  message是不满足条件时候的错误信息,可以是任意类型,require返回类型为Unit
      * 先决条件时对传递给方法或者构造器的值进行的限制,也就是说调用者必须满足这一条件,才能正确的调用。
      * */
    class Person(head:Int,hand:Int,foot:Int,name:String){
      //先决条件 boolean类型
      require(head>0&&head<2,"error input of hand,please input hand retring")
      //当传入的值不满足时候程序运行异常,异常信息为“error input...”
      require(foot>=0&&foot<3,foot)
      //定义Working方法
      def Working(fangFa:String)={
        val total=head+hand+foot
        println(name+"is a"+fangFa+" and working by \n\t" +head+" head to think and " +
          "\n\t"+hand+"handsto cooperate something and \n\t"+ foot+"foots to walk!")
        println(name+"are use total Organ:"+total)
        total
      }
      //在伴生对象中调用
      object FunctionObject{
        def main(args:Array[String]):Unit={
          val people=new Person(1,2,2,"Tom")
          people.Working("Programmmer")
        }
      }
      /**
        * 函数式对象之自指向
        * This关键字指向当前执行方法被调用的对象实例,或者如果使用构造器的话,就是正被构建的对象实例
        * 在下面定义的方法 < 中传入了一个SubConstructor类型的参数,其中this.A  this.B中的this是指调用方法的对象实例,
        * this可以省略;但是方法selfDiction中第一个this可以省略  但是第二天this不可以省略了
        * */
      class SubConstructor(n:Int,m:Int){
        require(m!=0)
        def this(a:Int)=this(a,10)
        def compare(a:Int,b:Int)=if(b==0)a%b else a
        val X=compare(n,m)
        def A=n*X
        def B=m*X
        //定义方法<
        def <(that:SubConstructor)=this.A*that.B<that.A*this.B
        def selfDiction(that:SubConstructor):SubConstructor=if(this.<(that))that else this
      }
      //单例对象
      object SubConstructor{
        def main(args: Array[String]): Unit = {
          val subAdd=new SubConstructor(4,6)
          val add=subAdd.compare(7,5)
          print(add)
          println(subAdd.X)
        }
      }
    
    
      /**
        * 函数式对象之辅助构造器
        *在定义类的时候“()”后面的内容会被定义为主构造器,那就是主构造器与类定义混合在一起,
        * 在一个类中,如果没有明确定义主构造器的话,则默认构造一个无参数的主构造器。
        * 辅助构造器扩充了主构造器的内容,在Java中构造器的名称和类名保持一致,但Scala中是以this为名称的,并且定义开始于def this(...)
        * 在scala中,可以有若干个辅助构造器,当一个辅助构造器在执行的时候会首先调用相同类下的其他构造器,可以是主构造器也可以是
        * 已经创建的其他辅助构造器,而辅助构造器的调用起始于是主构造器的调用的结束
        * */
      class constructorAnx{
        private var name=""
        private var age=0
        //定义辅助构造器
        def this(name:String){
          //调用主构造器
          this()
          this.name=name
          println(name)
        }
        //定义另一个辅助构造器
        def this(name:String,age:Int){
          //调用前一个辅助构造器
          this(name)
          this.name=name
          this.age=age
          println(name+" , "+age)
        }
      }
      //伴生对象
      object constructorAnx{
        def main(args: Array[String]): Unit = {
          //主构造器
          val bigDate=new constructorAnx
          //辅助构造器
          val hadoop=new constructorAnx("Hadoop")
          val spark=new constructorAnx("Spark",4)
        }
      }
    
    
      /**
        * 函数式对象之scala标识符
        * Scala的标识符包含了字母、数字、下划线、首字符为字母或者下划线,scala命名遵循驼峰式的习惯,如HashMap、SparkContext
        * 需要注意的是“_”虽然是合法的,但是“_”还有其他用途  以免冲突
        * Scala与Java区别是常量名,Java中常量名都是大写  但是Scala中只是首字母大写
        * 操作标识符由若干个操作字符组成,通常是一些七位可打印的ASCII字符,这些字符不包括字母 括号  数字 下划线以及回退字符等,
        * 操作标识符也可以属于数学符号或者其他符号的Unicode集,例如+,-, ->,<>等。
        * */
    
    }
    
    展开全文
  • 对象具有封装性的条件包括(ACD)。 A、有一个清晰的边界 B、对象是不可继承的 C、有确定的接口(即协议) D、受保护的内部实现 面向对象中,类与类之间通常有 关联 聚集 泛化 细化 4种关系。 复杂问题(大型...
  • 1.12 封装继承和多态

    2021-03-02 11:04:50
    1. 修改属性可见来限制对属性访问(一般限制为private)。 2. 对每个属性提供对外公共访问方法。 继承 继承是面向对象的特性,继承就是子类继承父类特征和行为。 多态 多态是指同一个行为具有多种不同...
  • 类 与 对象

    2018-10-30 20:49:30
    面向对象概述 面向对象的程序设计(OOP...面向对象的程序设计具有3个基本特征:封装、继承、多态,可以大大增强程序可靠、代码重用和程序可维护,从而提高程序开发效率。 (1)封装(encapsulation)...
  • 一、面向对象  面向对象是软件开发一种方法。它具有三个基本特点:封装、继承、多态。 二、封装 1、封装:是指隐藏对象的... 在这个实例中我们封装了Person一些属性,这里可以在方法中加入一些条件,如age必
  • JavaSE-面向对象

    2018-12-08 13:53:42
    面向对象与面向过程 区别: 面向对象的程序设计具有更高灵活,便于程序扩展和升级。面向过程主要是针对特定需求满足某业务条件下设计。 面向对象的三大特征 继承 封装 多态 ...
  • 2.理解类的封装性。实验条件:电脑一台、能上网查阅资料。实验内容与步骤:要求:设计和实现一个学生类,满足以下要求:1、学生具有学号、姓名、性别、年龄和专业等属性;2、可以修改和获取年龄和专业等信息;3、...
  • 大纲 面向对象的标准基本概念:对象,类,属性,方法和接口OOP独特功能 ...面向对象的编程方法/语言应该具有概念作为中心概念。语言应该能够为类和它特征提供断言(即规范:前置条件,后置条件和...
  • 1、子类继承了非私有(private)父类方法和属性;然后同名会被重写覆盖,不会继承; 2、子类无法继承父类静态方法和属性,也无法重写...接口类和类都可以指向子类实例化对象,就具有了不同方法。 封装: 对数据
  • 作用的条件是什么? 通过封装与组合来设计,具有“高内聚,低耦合”的特点。封装是利用访问控制符来实现的,而组合则通过对象内部的属性引用来实现。 protected修饰符有何特点? 访问权限为包内,类内和子类。...
  • 然后在解决视频问题解答中检查了CRN单元的灵活性,这是一个具有挑战性的问题,需要共同理解视频内容和自然语言处理。 CRN单元的插图以及为VideoQA建立HCNR的模型的结果: CRN单元 HCRN架构 请查看我们的以获取...
  • 特别是在本模块中,学生学习如何在软件中对对象建模,定义描述对象类别类以及如何适当利用诸如​​继承,组成,封装,多态,抽象类和接口之类概念。 除了学习基本Java语法以及如何用Java表达OO概念外,还...
  • 【05-面向对象(下)】

    2018-07-03 21:42:31
    •打印对象和toString方法:toString方法是系统将会输出该对象“自我描述”信息,用以告诉外界对象具有的状 态信息。 •Object 类提供toString方法总是返回该对象实现类类名 + @ +hashCode值。 •==...
  • Objective-C语言是面向对象的高级编程语言,因此,它具有面向对象编程所具有的一些特性,即:封装性、继承性和多态性。 今天介绍一下Objective-C中多态性。 多态3个条件: 继承:各种cell继承自BaseCell 重写:...
  • Java 特性之多态

    2018-07-13 17:30:09
    多态面向对象(OOP)三大特性:封装、继承、多态。多态(polymorphism)指同一行为具有多种不同表现形式,在面向对象程序设计中表现为同一消息可以根据发送对象的类型不同,做出多种不同行为。多态优点多态...
  • C++之友元函数和友元类

    千次阅读 2015-03-04 20:00:31
    在介绍类和对象时,已经说过类具有封装性,类中的私有成员一般只有通过该类中的成员函数才可以访问,而程序中的其他函数时无法直接访问类中的私有成员的。如果在一定的条件下需要访问类的私有成员,就必须通过对象来...
  • 具有面向对象数据库管理系统优点:容易表达对象各种复杂关系、通过对象的封装在数据库中实现方法与数据关联,对对象的标识、对象的多态和夜盖等都提供了支持。相对于对象数据库管理系统有比较高性能...
  • Java三大特性

    2019-11-09 20:42:36
    Java三大特性为:继承、多态和封装。 1、 继承:子类继承父类特征和行为,使得子类对象(实例)具有父类实例域和方法,或子类从父类集成方法,使得...3、封装封装是指一种将抽象函式接口实现细节部分...
  • 其用意是针对一组算法,将每一个算法封装具有共同接口独立类中,从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端情况下发生变化。 策略模式优点: 开闭原则; 避免使用多重条件转移...
  • 频率较高Java面试题

    2017-04-19 14:56:40
    继承:是从已有类中获得信息创建新类过程,提供信息类叫做父类(超类,基类),继承类为子类(派生类), 继承具有传递。 多态(最精髓东西):不同类型的对象对同一消息做出不同响应,条件:方法...
  • 创建对象是面向对象系统中最常见活动之一,因此应该有一些通用原则以用于创建职责分配,如果分配好,设计就能够支持低耦合,提高清晰度,封装性和可复用性。 如果下列条件之一为真,将创建类A实例职责...
  • Java产生与流行是当今Internet发展客观要求,Java是一门各方面性能都很好编程语言,它基本特点是简单、面向对象、分布式、解释、健壮、安全、结构中立、可移植、性能很优异、多线程、动态,...
  • 一个纯面向对象程序设计语言将具有严格继承。 通过对象、类,我们实现了封装,通过子类我们可以实现继承。例如,公共汽车、出租 车、货车等都是汽车,但它们是不同汽车,除了具有汽车共性外,它们还具有...
  • 此处代码在单个函数中具有很高复杂。 测试不完整-无法满足消费者所有需求 任务 降低圈复杂度。 将纯功能与I / O分开 避免重复-功能几乎相同功能 完成测试-覆盖所有条件。 要采取有效措施,我们需要知道...

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 229
精华内容 91
关键字:

对象具有封装性的条件