精华内容
下载资源
问答
  • 面向对象基本概念

    万次阅读 多人点赞 2019-02-06 21:56:15
    面向对象就是:把数据及数据的操作方法放在一起,作为一个相互依存的整体...对象即为人各种具体物体抽象后的一个概念,人们每天都要接触各种各样的对象,如手机就是一个对象。 面向对象编程(OOP:object-orie...

    面向对象就是:把数据及对数据的操作方法放在一起,作为一个相互依存的整体——对象。对同类对象抽象出其共性,形成类。类中的大多数数据,只能用本类的方法进行处理。类通过一个简单的外部接口与外界发生关系,对象与对象之间通过消息进行通信。程序流程由用户在使用中决定。对象即为人对各种具体物体抽象后的一个概念,人们每天都要接触各种各样的对象,如手机就是一个对象。

    面向对象编程(OOP: object-oriented programming)

    面向对象

     

    面向对象与面向过程的区别

    项目名称 面向对象程序设计 面向过程程序设计(也叫结构化编程)
    定义 面向对象顾名思义就是把现实中的事务都抽象成为程序设计中的“对象”,其基本思想是一切皆对象,是一种“自下而上”的设计语言,先设计组件,再完成拼装。 面向过程是“自上而下”的设计语言,先定好框架,再增砖添瓦。通俗点,就是先定好main()函数,然后再逐步实现mian()函数中所要用到的其他方法。
    特点 封装、继承、多态 算法+数据结构
    优势 适用于大型复杂系统,方便复用、 适用于简单系统,容易理解
    劣势 比较抽象、性能比面向过程低 难以应对复杂系统,难以复用,不易维护、不易扩展
    对比 易维护、易复用、易扩展,由于面向对象有封装、继承、多态性的特性,可以设计出低耦合的系统,使系统 更加灵活、更加易于维护  性能比面向对象高,因为类调用时需要实例化,开销比较大,比较消耗资源;比如单片机、嵌入式开发、 Linux/Unix等一般采用面向过程开发,性能是最重要的因素。 
    设计语言 Java、Smalltalk、EIFFEL、C++、Objective-、C#、Python等 C、Fortran
    使用场景

    30种编程语言的比较选择问题https://blog.csdn.net/ljy1988123/article/details/7782700

    类与对象的主要区别

    对象:对象是类的一个实例(对象不是找个女朋友),有状态和行为。例如,一条狗是一个对象,它的状态有:颜色、名字、品种;行为有:摇尾巴、叫、吃等。 

    :类是一个模板,它描述一类对象的行为和状态。

    1、面向对象三大主要特征(理解)

    ①封装

    两层含义:一层含义是把对象的属性和行为看成一个密不可分的整体,将这两者“封装”在一个不可分割的独立单元(即对象)中;另一层含义指“信息隐藏”,把不需要让外界知道的信息隐藏起来,有些对象的属性及行为允许外界用户知道或使用,但不允许更改,而另一些属性或行为,则不允许外界知晓,或只允许使用对象的功能,而尽可能隐藏对象的功能实现细节。

    封装的优点

    • 良好的封装能够减少耦合,符合程序设计追求“高内聚,低耦合”。

    • 类内部的结构可以自由修改。

    • 可以对成员变量进行更精确的控制。

    • 隐藏信息实现细节。

    实现Java封装的步骤

    1. 修改属性的可见性来限制对属性的访问(一般限制为private),例如:

    public class Person { 
        private String name; 
        private int age; 
    }

    这段代码中,将 name 和 age 属性设置为私有的,只能本类才能访问,其他类都访问不了,如此就对信息进行了隐藏。

    2. 对每个值属性提供对外的公共方法访问,也就是创建一对赋取值方法,用于对私有属性的访问,例如:

    public class Person{ 
        private String name;
        private int age; ​ 
        private boolean alive;
    
        public int getAge(){
            return age; 
        } 
    
        public void setAge(int age){ 
            this.age = age; 
        } ​
    
        public String getName(){ 
            return name; 
        } ​
     
        public void setName(String name){ 
            this.name = name; 
        }
    
        public boolean isAlive() {
    		return alive;
    	}
    
    	public void setAlive(boolean alive) {
    		this.alive = alive;
    	}
    
    }

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

    封装同时可以提高代码的安全性,例如普通的类属性不是private修饰就直接可以通过“对象名.属性 = xxx”对其赋值,但当我们用private修饰该属性后就不能这样对其做任意的修改了,而且我们还可以在其对外的访问方法中进行合法值校验。比如上例中的setAge()就可以更改为:

    public void setAge(int age){
        if(age > 120)
            System.out.println("Age setting error");
        else
            this.age = age;
    }

     封装的使用细节:

    1. 一般使用private访问权限
    2. 提供相应的get、set方法来访问相关属性,这些方法通常是public修饰的。以提供对属性的赋值与读取操作。(注意!boolean变量的get方法是is开头。)
    3. 一些只用于本类的辅助性方法,可以使用private修饰,希望其他类调用的方法用public修饰。

    this与super关键字:

    1、this关键字代表当前对象

    2、super可以理解为是指向自己超(父)类对象的一个指针,而这个超类指的是离自己最近的一个父类。  

     this与super对比

    • this.属性 操作当前对象的属性
    • this.方法 调用当前对象的方法 
    • 引用构造函数:调用本类中另一种形式的构造函数(应该为构造函数中的第一条语句)。
    • 普通的直接引用:与this类似,super相当于是指向当前对象的父类,这样就可以用super.xxx来引用父类的成员。
    • 子类中的成员变量或方法与父类中的成员变量或方法名同名时,表示调用父类的成员
    • 引用构造函数:调用父类中的某一个构造函数(应该为构造函数中的第一条语句)。默认在构造函数第一条语句是“super();”,无论写与否。
    • super(参数):调用基类中的某一个构造函数(应该为构造函数中的第一条语句)
    • this(参数):调用本类中另一种形成的构造函数(应该为构造函数中的第一条语句)
    • 调用super()必须写在子类构造方法的第一行,否则编译不通过。每个子类构造方法的第一条语句,都是隐含地调用 super(),如果父类没有这种形式的构造函数,那么在编译的时候就会报错。
    • super() 和 this() 类似,区别是,super() 从子类中调用父类的构造方法,this() 在同一类内调用其它方法。
    • super() 和 this() 均需放在构造方法内第一行。
    • 尽管可以用this调用一个构造器,但却不能调用两个。
    • this 和 super 不能同时出现在一个构造函数里面,因为this必然会调用其它的构造函数,其它的构造函数必然也会有 super 语句的存在,所以在同一个构造函数里面有相同的语句,就失去了语句的意义,编译器也不会通过。
    • this() 和 super() 都指的是对象,所以,均不可以在 static 环境中使用。包括:static 变量,static 方法,static 语句块。
    • 从本质上讲,this 是一个指向本对象的指针, 然而 super 是一个 Java 关键字。

    ②继承

    继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类。

    继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。

    类的继承格式:

    class 父类 { }

    class 子类 extends 父类 { }

    继承的类型:需要注意的是 Java 不支持多继承,但支持多重继承。

     继承的好处:

    (1)提高类代码的复用性

    (2)提高了代码的维护性

    (3)使得类和类产生了关系,是多态的前提(它也是继承的一个弊端,类的耦合性提高了)

    继承的特性

    • 子类拥有父类非 private 的属性、方法。

    • 子类可以拥有自己的属性和方法,即子类可以对父类进行扩展。

    • 子类可以用自己的方式实现父类的方法,即重写父类方法。

    • Java 的继承是单继承,但是可以多重继承,单继承就是一个子类只能继承一个父类,多重继承就是,例如 A 类继承 B 类,B 类继承 C 类,所以按照关系就是 C 类是 B 类的父类,B 类是 A 类的父类,这是 Java 继承区别于 C++ 继承的一个特性。

    • 继承可以使用 extends 和 implements 这两个关键字来实现继承,而且所有的类都是继承于 java.lang.Object,当一个类没有继承的两个关键字,则默认继承object(这个类在 java.lang 包中,所以不需要 import)祖先类。

    • 提高了类之间的耦合性(继承的缺点,耦合度高就会造成代码之间的联系越紧密,代码独立性越差)。

     final关键字:

    表示最终的意思,可以修饰类、成员变量、成员方法

    • 修饰类:类不可以被继承
    • 修饰成员变量:变量为常量,值不可以改变
    • 修饰成员方法:方法不能被重写
    • final还可以修饰局部变量:①修饰基本数据类型,值不能改变;②修饰引用数据类型,地址值不能改变

     static关键字(静态):

    static表示静态的意思,既可以修饰成员变量,又可以修饰成员方法,还有一种特殊用法修饰类

    (1)、修饰成员变量表示静态变量:static变量也称作静态变量,静态变量和非静态变量的区别是:静态变量被所有的对象所共享,在内存中只有一个副本,它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的,在创建对象的时候被初始化,存在多个副本,各个对象拥有的副本互不影响。static成员变量的初始化顺序按照定义的顺序进行初始化。static不能修饰局部变量。

    (2)、修饰成员方法:static方法一般称作静态方法,由于静态方法不依赖于任何对象就可以进行访问,因此对于静态方法来说,是没有this的,因为它不依附于任何对象,既然都没有对象,就谈不上this了。并且由于这个特性,在静态方法中不能访问类的非静态成员变量和非静态成员方法,因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。

    (3)static代码块:static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方,类中可以有多个static块。在类初次被加载的时候,会按照static块的顺序来执行每个static块,并且只会执行一次。

    特点:
        1)随着类的加载而加载
        2)优先于对象存在
        3)被所有的对象所共享
            该特点是我们使用static的条件

    注意事项:
        1)在静态方法中,不能出现this/super
        2)静态方法只能访问静态成员;非静态方法既可以访问静态成员,也可以访问非静态成员
        3)工具类里面的成员一般来说是静态成员(目的:节约内存空间)

    静态变量和成员变量的区别
    1)所属不同
          静态变量属于类,也称为类变量
          成员变量属于对象,也称为实例变量
    2)内存中位置不同
          静态变量存在方法区
          成员变量存在堆中
    3)出现的时间不同
          静态变量随着类的加载而加载,随着类的消亡而消亡
          成员变量随着对象的创建而创建,随着对象的消失而消失
    4)调用方式不同
          静态变量通过类名调用,也可以通过对象名调用(不建议)
          成员变量只能通过对象名调用
    所以,成员变量可以称为对象的特有数据,静态变量称为对象的共享数据

    成员变量与局部变量的区别
    1)在类中的位置不同
           成员变量:在类中方法外面
           局部变量:在方法或者代码块中,或者方法的声明上(即在参数列表中)
    2)在内存中的位置不同,可以看看Java程序内存的简单分析
           成员变量:在堆中(方法区中的静态区)
           局部变量:在栈中
    3)生命周期不同
          成员变量:随着对象的创建而存在,随着对象的消失而消失
          局部变量:随着方法的调用或者代码块的执行而存在,随着方法的调用完毕或者代码块的执行完毕而消失
    4)初始值
          成员变量:有默认初始值
          局部变量:没有默认初始值,使用之前需要赋值,否则编译器会报错(The local variable xxx may not have been initialized)

    package se01.day02;
    
    //子父类静态代码块、构造代码块、构造方法
    class Fu{
    	String name;
    	int age;
    	
    	{
    		System.out.println("构造代码块Fu");
    	}
    	
    	static{
    		System.out.println("静态代码块Fu");
    	}
    	
    	public Fu() {
    		System.out.println("无参构造方法Fu");
    	}
    
    	public Fu(String name, int age) {
    		this.name = name;
    		this.age = age;
    		System.out.println("有参构造Fu");
    	}
    
    }
    public class Zi extends Fu{
    	int id;
    	{
    		System.out.println("构造代码块Zi");
    	}
    	static{
    		System.out.println("静态代码块Zi");
    	}
    	public Zi() {
    		System.out.println("无参构造方法Zi");
    	}
    
    	public Zi(String name, int age) {
    		this.name = name;
    		this.age = age;
    		System.out.println("有参构造Zi");
    	}
    	public static void main(String[] args) {
    		new Zi("小明",13);
    	}
    }
    
    ==========================执行结果为====================================
    静态代码块Fu
    静态代码块Zi
    构造代码块Fu
    无参构造方法Fu
    构造代码块Zi
    有参构造Zi

    static特殊用法(static修饰类):  如果一个类要被声明为static的,只有一种情况,就是静态内部类。如果在外部类声明为static,程序会编译都不会过。(在内部类中详细讲解)

    Question:在什么情况下需对属性和方法加上static关键字?

    在编写的代码中,static定义的属性出现几率不是特别高,一般只有在描述共享属性概念或者是不受实例化对象限制的属性时才会使用static定义属性,而大部分情况下依然都使用非static属性。

    产生实例化对象是因为在堆内存中可以保存属性信息,所以如果一个类中没有属性产生,就自然也没有必要去开辟堆内存保存属性内容了,所以这个时候就可以考虑类中的方法全部使用static声明。

    NOTICE:在JDK1.7之前,Java一直存在一个Bug,可以先执行静态代码块来代替主方法。按照标准来说,所有的程序应该都是从主方法开始执行,但是下例却先执行静态代码块

    	public static void main(String[] args) {
    		System.out.println("你好,世界");
    	}
    	
    	static{
    		System.out.println("Hello World");
    	}
    
    ===========输出结果为==============
    Hello World
    你好,世界

    ③多态

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

    多态的体现

    Java语言中含有方法重载与对象多态两种形式的多态:

    方法重载:在一个类中,允许多个方法使用同一个名字,但方法的参数不同,完成的功能也不同。

    对象多态:子类对象可以与父类对象进行转换,而且根据其使用的子类不同完成的功能也不同(重写父类的方法)。

    面试题:什么是多态?实现多态的方法有哪些?

    多态是面向对象的最后一个主要特征,它本身主要分为两个方面:
           ·方法的多态性:重载与覆写
                |-重载:同一个方法名称,根据不同的参数类型及个数可以完成不同的功能。
                |-覆写:同一个方法,根据操作的子类不同,所完成的功能也不同。
           ·对象的多态:父子类对象的转换。
                |-向上转型:子类对象变为父类对象,格式:父类 父类对象 = 子类实例,自动;
                |-向下转型:父类对象变为子类对象,格式:子类 子类对象 = (子类)父类实例,强制。

    多态的优点

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

    多态存在的三个必要条件

    • 继承
    • 重写
    • 父类引用指向子类对象

    比如:Parent p = new Child();

    多态的访问方式:
    (1)成员变量
        编译看左边,运行看左边
    (2)成员方法
        编译看左边,运行看右边
    (3)静态方法
        编译看左边,运行看左边

    多态的实现方式

    方式一:重载与重写:

    这个内容已经详细讲过,就不再阐述,详细请见上文。

    方式二:抽象类和抽象方法

    在Java中,一个没有方法体的方法称为抽象方法。而一个类中如果有抽象方法,那么这个类就称之为抽象类。

    格式:
        抽象类:abstract class 类名{}
        抽象方法:修饰符 abstract 返回值类型 方法名(参数列表){方法体;}

    特点:
        1)抽象类不一定有抽象方法,但是有抽象方法的类一定是抽象类
        2)抽象类不可以实例化(不能用new关键字创建抽象类实例)
        3)抽象类的子类,可以是抽象类,也可以是具体类。如果子类是具体类,需要重写抽象类里面所有抽象方法

    组成:
        1)成员变量
            可以是变量,可以是常量
        2)构造方法
            有构造方法
            抽象类不可以实例化,存在构造方法,有什么用?
            子类会调用父类的构造方法,对属性进行初始化赋值
        3)成员方法
            可以是抽象方法,也可以是具体方法

    抽象(abstract)不能与那些关键字共存?
    1).private :因为一个abstract方法需要被重写,所以不能修饰为private;
    2).final:因为一个abstract方法需要被重写。被final修饰的方法是不能被重写的,所以不能同final共存;
    3).static:因为一个abstract方法没有方法体。静态方法需要对方法体执行内容分配空间,所以不能同static共存;(abstract是没有实现  的,不能产生对象,而是static是属于类的,类本身是已经存在的对象)
    4).synchronized: 是同步的,然而同步需要具体的操作才能同步,但, abstract是只有声明没有实现的(即,使用synchronized关键字的是需要有具体的实现同步的操作的,但是使用abstract是只有声明而没有实现的,这样就产生了冲突)
    5).native:他们本身的定义就是冲突的,native声明的方法是移交本地操作系统实现的,而abstract是移交子类对象实现的,同时修饰的话,导致不知道谁实现声明的方法

    方式三:接口

    接口(英文:Interface),在JAVA编程语言中是一个抽象类型,是抽象方法的集合,接口通常以interface来声明。实际上是一个规范,它会要求你做什么,但不会要求你去怎么做。接口里面定义的是额外功能,但是不给出具体的实现。

    接口无法被实例化,但是可以被实现。一个实现接口的类,必须实现接口内所描述的所有方法,否则就必须声明为抽象类。

    接口与类相似点:

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

    接口与类的区别:

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

    接口特性:

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

    抽象类和接口的区别:

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

    接口的多继承

    接口和接口继承关系,可以单继承,多继承,多级继承

    标记接口

    标记接口是没有任何方法和属性的接口.它仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。

    Java中的标记接口有:

    1. java.io.Serializable这个接口是用来标记类是否支持序列化的,所谓的序列化就是将对象的各种信息转换成可以存储或者传输的一种形式。如果一个类没有实现该接口,却被拿去序列化的了,那么虚拟机就会抛出不支持序列化的异常
    2. Cloneable接口在深度拷贝的时候经常被用到,在调用java.lang.Object类中clone方法的过程中,如果对象没有实现Cloneable接口,那么虚拟机就会抛出一个CloneNotSupportedException异常。
    3. java.util.RandomAccess这个接口的作用是判断集合是否能快速访问,也就是通过索引下标能否快速的移动到对应的元素上。我们在使用某个集合类中,集合中的元素可以通过索引index下标快速的访问到,那么在该类的定义处,一般会有一个RandomAccess接口的实现标签。

      比如:java.util.ArrayList<E>有这个接口,java.util.LinkedList<E>就没有

      1 public class ArrayList<E> extends AbstractList<E>
      2         implements List<E>, RandomAccess, Cloneable, java.io.Serializable
      3 {
      4 //...
      5 }
      1 public class LinkedList<E>
      2     extends AbstractSequentialList<E>
      3     implements List<E>, Deque<E>, Cloneable, java.io.Serializable
      4 {
      5     ...
      6 }

    2、数组的使用以及初始化操作

    数组是用来存储多个相同数据类型值的容器。

    数组初始化
    1)动态初始化
        只指定数组的长度,由系统分配默认值
        格式:
        数据类型[] 数组名 = new 数据类型[长度];     或者      数据类型 数组名[] = new 数据类型[长度]
        默认值:
        byte、short、int、long,默认0
        float、double,默认0.0
        boolean,默认false
        char,默认'\u0000'
        String,默认null(所有引用数据类型默认都是null)
    2)静态初始化
        指定数组里面每个元素的初始值,不指定数组的长度
        格式:
            数据类型[] 数组名 = new 数据类型[]{元素1,元素2...};
        简写:
            数据类型[] 数组名 = {元素1,元素2...};

    简单实例:

    public static void main(String[] args) {
    		  double[] myList = {1.9, 2.9, 3.4, 3.5};
    		  
    	      // 打印所有数组元素
    	      for (int i = 0; i < myList.length; i++) {
    	         System.out.print(myList[i] + " ");
    	      }
    	      System.out.println("\n=================");
    	      for (double d : myList) {
    			System.out.print(d + " ");
    		}
    	      System.out.println("\n=================");
    	      // 计算所有元素的总和
    	      double total = 0;
    	      for (int i = 0; i < myList.length; i++) {
    	         total += myList[i];
    	      }
    	      System.out.println("Total is " + total);
    	      // 查找最大元素
    	      double max = myList[0];
    	      for (int i = 1; i < myList.length; i++) {
    	         if (myList[i] > max) max = myList[i];
    	      }
    	      System.out.println("Max is " + max);
    	}
    
    
    运行结果:
    1.9 2.9 3.4 3.5 
    =================
    1.9 2.9 3.4 3.5 
    =================
    Total is 11.7
    Max is 3.5
    

     冒泡排序(相邻的元素进行比较,大值往后排):

    	public static void bubbleSort(int[] arr){
    		int temp = 0;
    		for (int i = 0; i < arr.length-1; i++) {
    			for (int j = 0; j < arr.length-1-i; j++) {
    				if(arr[j]>arr[j+1]){
    					temp = arr[j];
    					arr[j] = arr[j+1];
    					arr[j+1] = temp;
    				}
    			}
    		}
    	}

     选择排序(前面元素与后面的元素诸葛逐个进行比较,小值往前排):

    	public static void selectSort(int[] arr){
    		int temp = 0;
    		for (int i = 0; i < arr.length-1; i++) {
    			for (int j = i+1; j < arr.length; j++) {
    				if(arr[i]>arr[j]){
    					temp = arr[i];
    					arr[i] = arr[j];
    					arr[j] = temp;
    				}
    			}
    		}
    		System.out.println(Arrays.toString(arr));
    	}

     多维数组

    多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每一个元素都是一个一维数组,例如:

    String str[][] = new String[3][4];

    多维数组初始化的方式与一维数组初始化方式类似,也分动态和静态两种方式。

    不规则数组

    “ 不规则 ” 数组 , 即数组的每一行有不同的长度。典型的案例是杨辉三角

    //不规则数组,杨辉三角
    public class LotteryArray {
    	public static void main(String[] args) {
    		final int NMAX = 10; //最大行数
    		int[][] odds = new int[NMAX][];
    		for (int n = 0; n < NMAX; n++)
    			odds[n] = new int[n + 1]; //初始化,开辟空间
    		for (int n = 0; n < odds.length; n++) {
    			for (int k = 0; k < odds[n].length; k++) {
    				/*
    				 * int lotteryOdds = 1;
    				 * for (int i = 1; i <= k; i++) 
                                     *     lotteryOdds = lotteryOdds * (n - i + 1) / i;
    				 * odds[n][k] = lotteryOdds;
    				 */
    				// 第一个和最有一个都是1,其余的都是它的上一个和它的上一个的前一个的和
    				if (k == 0 || k == odds[n].length - 1) {
    					odds[n][k] = 1;
    				} else {
    					odds[n][k] = odds[n - 1][k - 1] + odds[n - 1][k];
    				}
    
    			}
    		}
    		for (int[] row : odds) {
    			for (int odd : row)
    				System.out.printf("%4d", odd);
    			System.out.println();
    		}
    
    	}
    }
    
    
    =======================结果显示============================
       1
       1   1
       1   2   1
       1   3   3   1
       1   4   6   4   1
       1   5  10  10   5   1
       1   6  15  20  15   6   1
       1   7  21  35  35  21   7   1
       1   8  28  56  70  56  28   8   1
       1   9  36  84 126 126  84  36   9   1

    数组工具类Arrays

    修饰符和类型 方法和描述
    static <T> List<T>

    asList(T... a)

    返回由指定数组支持的固定大小的列表。

    static int

    binarySearch(byte[] a, byte key)

    使用二进制搜索算法在指定的字节数组中搜索指定的值。

    static int

    binarySearch(byte[] a, int fromIndex, int toIndex, byte key)

    使用二进制搜索算法搜索指定值的指定字节数组的范围。

    char[]、double[]、float[]、int[]、long[]、Object[]、short[]...同样适用

    static boolean[]

    copyOf(boolean[] original, int newLength)

    使用false复制指定的数组,截断或填充(如果需要),以使副本具有指定的长度。

    static byte[]

    copyOf(byte[] original, int newLength)

    使用零复制指定的数组,截断或填充(如有必要),以使副本具有指定的长度。

    char[]、double[]、float[]、int[]、long[]...同样适用

    static char[]

    copyOfRange(boolean[] original, int from, int to)

    将指定数组的指定范围复制到新数组中。

    static double[]

    copyOfRange(boolean[] original, int from, int to)

    将指定数组的指定范围复制到新数组中。

    boolean[]、char[]、float[]、int[]、long[]同样

    static boolean equals(boolean[] a, boolean[] a2)

    如果两个指定的布尔数组彼此相等,则 返回true。

    byte[]、char[]、double[]...同样适用

    static void fill(boolean[] a, boolean val)

    将指定的布尔值分配给指定的布尔数组的每个元素。

    byte[]、char[]、double[]...同样适用

    static void parallelSort(byte[] a)

    将指定的数组按升序排序。java8新特性,并行排序。

    static void sort(float[] a)

    将指定的数组按升序排序。串行排序。

    static void sort(float[] a, int fromIndex, int toIndex)

    按升序对数组的指定范围进行排序。

    int[]、short[]、long[]、double[]...同样适用

    static String toString(boolean[] a)

    返回指定数组内容的字符串表示形式。

    3、java基本数据类型和引用传递区别

    简概: ①形参为基本数据类型形参改变,实参不会发生改变
     ②形参为引用数据类型形参改变,实参也会跟着改变(有特例)

    详述:https://blog.csdn.net/sugar_no1/article/details/86506510

     

    展开全文
  • 具有相同或相似性质的一组对象的抽象就是类,类是一类事物的描述,是抽象的、概念上的意义; 对象是实际存在的该类事物的每个个体,因此也称为实例; 对象的抽象是类,类的具体化就是对象,也可以说类的...

    具有相同或相似性质的一组对象的抽象就是类,类是对一类事物的描述,是抽象的、概念上的意义;


    对象是实际存在的该类事物的每个个体,因此也称为实例;


    对象的抽象是类,类的具体化就是对象,也可以说类的实例就是对象。类用来描述一系列对象,概述了每个对象应包括的数据,并概述了每个对象的行为特征。


    面向对象的三个基本特征:

    一、封装
            对象要有一个明确的边界;边界的划分(对象各司其职、对象的粒度、对象的可重用性)
            具体来说:
                    1.属性: 私有 private(提供set和get方法)
                    2.方法: 公开或私有public/private
                    3.方法声明 --> 公开
                      方法实现 --> 隐藏
                     实现改变时,对对象的使用者没有影响。
     
    二、继承
            共性放到父类,特性放到子类;子类,父类 --> 其实就是特殊 --> 一般
            1.关键字: extends  例如:Dog extends Animal{}
            2.java中一个类最多只能有一个直接的父类,即单继承(具有简单性、树形结构),
              C++中是单继承
              java中要实现多继承,通过接口来实现。
            3.父类中所有属性和方法都能继承给子类;父类中的私有方法不能继承给子类。
            4.java中的访问修饰符
                

    访问修饰符

    访问权限

     继承 

    private       

    本类内部                  

    不能继承

    default       

    本类+同包 

    同包子类可以继承           

    protected     

    本类+同包+不同子包  

    可以继承

    public        

    公开

    可以继承

     

            5.构造对象过程
                       (1)分配空间
                       (2)递归地构造父类对象
                                    a. 父类 初始化属性
                                    b. 父类 构造方法
                       (3)初始化属性
                       (4)调用构造方法

            6.super  
                   用法:
                       super()  调用父类的构造方法,只能出现在构造方法的第一行
                       super.方法名   super表示父类的对象,通过它去调用父类的方法
                   注意:在写类的时候,一定要写默认无参的构造方法,如果一个构造方法的
                         第一句既不是this(),也不是super()时,那么就会在这里隐含的调用
                         他的父类的无参的构造方法,即隐含的有super()。

    三、多态
                运行时多态。
                子类的对象放在父类的引用中,例如 Animal a=new Dog,子类对象当父类对象来使用。
            1.多态原则:
                      (1)对象类型不变
                      (2)只能用引用调用其引用类型中定义的方法
                      (3)运行时,根据对象的实际类型去找子类覆盖之后的方法
                 例子:
                      有Animal类中有eat()和sleep()两个方法,sleep()中睡8小时;子类Dog中有
                      eat()方法,sleep()方法中睡6小时,还有wangwang()方法。
                      现创建Animal a=new Dog(); 不能调用a.wangwang(),调用a.sleep()输出睡6小时。

              2.对象的强制转换
                     格式: 引用 instanceof 类型
                            引用所指的对象是否与类相符,返回值boolean值。
                     用法:
                           Animal a=new Cat();
                           if(a instanceof Dog)
                           {
                              Dog d=(Dog)a;
                              d.wangwang();
                            }
                     说明:如果只有Dog d=(Dog)a;运行时错误,因为a是Cat而不是Dog (多态原则第一条)

              3.多态的灵活变换
                      (1)用于参数列表上:
                                   public void m(A a){} 可以用A类的任何子类对象作为参数
                      (2)用在返回值上:
                                  public A m(){}  这个方法可能返回A类的任何子类对


    展开全文
  • Js错误Error对象详解

    千次阅读 2018-05-16 21:02:27
    解释器会为每个错误情形创建并抛出一个Error对象,其中包含错误描述信息。 ECMAScript定义了六种类型的错误。除此之外,还可以使用Error构造方法创建自定义的Error对象,并使用throw语句抛出该对象。 六种错误:...

    一、概念

    error,指程序中的非正常运行状态,在其他编程语言中称为“异常”或“错误”。解释器会为每个错误情形创建并抛出一个Error对象,其中包含错误的描述信息。

    ECMAScript定义了六种类型的错误。除此之外,还可以使用Error构造方法创建自定义的Error对象,并使用throw语句抛出该对象。

    六种错误:

    • ReferenceError:找不到对象时
    • TypeError:错误的使用了类型或对象的方法时
    • RangeError:使用内置对象的方法时,参数超范围
    • SyntaxError:语法写错了
    • EvalError:错误的使用了Eval
    • URIError:URI错误

    二、错误处理

    即使程序发生错误,也保证不异常中断的机制。

    try{
        可能发生错误的代码
    }catch(err){
        只有发生错误时才执行的代码
    }finally{
        无论是否出错,肯定都要执行的代码
    }

    使用要点:

    • 使用try包裹的代码,即使不出错,效率也比不用try包裹的代码低;
    • 在try中,尽量少的包含可能出错的代码;
    • 无法提前预知错误类型的错误,必须用try catch捕获;
    • finally可以省略;

    三、抛出自定义错误

    何时:如果函数的定义者,需要告知调用者使用过程中的错误;

    如何:throw new Error("提示文字");

    // 程序猿甲:定义函数的人
    function round(num, d){
        if(!isNaN(num) && !isNaN(d)){
            num *= Math.pow(10, d);
            return num;
        }else{
            // 抛出自定义错误
            throw new Error("参数必须是数字");  
        }
    }
    
    // 程序猿乙:调用函数的人
    var d = parseInt(prompt('请输入数字'));
    try{
        alert(round(123.456, d));
    }catch(err){
        alert(err.message);  // 接住抛出的自定义错误
    }

    四、实例练习

    var n = 1;
    function fun(){
        try{
            n++;
            return n;
        }catch(err){    
            // 没错误,catch不执行
            n++;
            return n;    
        }finally{
            n++;
            return n;
        }
    }
    
    console.log(fun());// 3  return为finally的
    console.log(n);// 3
    var n = 1;
    function fun(){
        try{
            n++;
            return n;
        }catch(err){
            // 没错误,catch不执行
            n++;
            return n;
        }finally{
            n++;
        }
    }
    console.log(fun()); // 2  return为try的
    console.log(n); // 3 
    var n = 1;
    function fun(){
        try{
            n++;
            n += m;  //出错
            return n;   
        }catch(err){
            n++;
            return n;
        }finally{
            n++;
        }
    }
    console.log(fun());    // 3 return为catch的
    console.log(n);        // 4
    展开全文
  • 类与对象概念

    千次阅读 2008-04-27 19:29:00
    第4章 类 与 象4.1类与对象概念4.2封装机制4.3数据成员4.4成员方法第4章 类 与 象4.1类与对象概念程序设计所面对的问题域——客观世界,是由许多事物构成的,这些事物既可以是有形的(比如一辆汽车),也...
    第4章 类 与 对 象
    4.1
    类与对象的概念
    4.2
    封装机制
    4.3
    数据成员
    4.4
    成员方法
    第4章 类 与 对 象
    4.1
    类与对象的概念
    程序设计所面对的问题域——客观世界,是由许多事物构
    成的,这些事物既可以是有形的(比如一辆汽车),也可以是无形
    的(比如一次会议)。把客观世界中的事物映射到面向对象的程序
    设计中就是对象。对象是面向对象程序设计中用来描述客观事
    物的程序单位。客观世界中的许多对象,无论其属性还是其行
    为常常有许多共同性,抽象出这些对象的共同性便可以构成类。
    所以,类是对象的抽象和归纳,对象是类的实例。
    第4章 类 与 对 象
    4.1.1
    抽象原则
    所谓抽象(abstraction),就是从被研究对象中舍弃个别的、
    非本质的、或与研究主旨无关的次要特征,而抽取与研究工作
    有关的实质性内容加以考察,形成对所研究问题正确的、简明
    扼要的认识。例如,“马”就是一个抽象的概念,实际上没有任
    何两匹马是完全相同的,但是我们舍弃了每匹马个体之间的差
    异,抽取其共同的、本质性的特征,就形成了“马”这个概念。
    抽象是科学研究中经常使用的一种方法,是形成概念的必
    要手段。在计算机软件开发领域,抽象原则的运用非常广泛,
    概括起来,可分为过程抽象和数据抽象两类。
    第4章 类 与 对 象
    1.
    过程抽象
    过程抽象是指:软件开发者可以把任何一个完成确定功能
    的操作序列都看作是一个单一的实体,尽管它实际上可能是由
    一系列更低级的操作完成的。运用过程抽象,软件开发者可以
    把一个复杂的功能分解为一些子功能(模块),如果子功能仍比较
    复杂,则可以进一步分解。这使得开发者可以在不同的抽象层
    次上考虑问题,在较高层次上思考时可以不关心较低层次的实
    现细节。面向过程的程序设计采用的是过程抽象方法。
    使用过程抽象有利于控制、降低整个程序的复杂度,但
    是,这种方法允许在全系统的范围内进行功能的描述,本身自
    由度大,难于规范化和标准化,不易保证软件的质量,而且操
    作起来也有一定难度。
    第4章 类 与 对 象
    2.
    数据抽象
    数据抽象把系统中需要处理的数据和施加于这些数据之上
    的操作结合在一起,根据功能、性质、作用等因素抽象成不同
    的抽象数据类型。每个抽象数据类型既包含了数据,也包含了
    针对这些数据的授权操作,并限定数据的值只能由这些操作来
    观察和修改。因此,数据抽象是相对于过程抽象更为严格、更
    为合理的抽象方法。
    面向对象的程序设计就是采用数据抽象这一方法来构建程
    序中的类和对象的。它强调把数据和操作结合为一个不可分的
    系统单位——对象,对象的外部只需要知道这个对象能做什
    么,而不必知道它是如何做的。
    第4章 类 与 对 象
    4.1.2
    对象
    只要仔细研究程序设计所面对的问题域——客观世界,我
    们就可以看到:客观世界是由一些具体的事物构成的,每个事
    物都具有自己的一组静态特征(属性)和一组动态特征(行为)。例
    如,一辆汽车有颜色、型号、马力、生产厂家等静态特征,又
    具有行驶、转弯、停车等动态特征。把客观世界的这一事实映
    射到面向对象的程序设计中,则把问题域中的事物抽象成了对
    象(Object),事物的静态特征(属性)用一组数据来描述,事物的
    动态特征(行为)则用一组方法来刻画。因此,对象具有下述特
    征:
    第4章 类 与 对 象
    (1) 对象标识:即对象的名字,是用户和系统识别它的唯一
    标志。例如,汽车的牌照可作为每一辆汽车对象的标识。对象
    标识有“外部标识”和“内部标识”之分。外部标识供对象的定义
    者或使用者用,内部标识供系统内部唯一地识别每一个对象。
    在计算机世界中,我们可以把对象看成计算机存储器中一块可
    标识的区域,它能保存固定或可变数目的数据(或数据的集合)。
    (2) 属性:即一组数据,用来描述对象的静态特征。例如,
    汽车的颜色、型号、马力、生产厂家等。在Java程序中,把这
    一组数据称为数据成员。
    第4章 类 与 对 象
    (3) 方法:也称为服务或操作,它是对象动态特征(行为)的
    描述。每一个方法确定对象的一种行为或功能。例如,汽车的
    行驶、转弯、停车等动作可分别用move( )、rotate( )、stop( )等
    方法来描述。为避免混淆,本书中把方法称为成员方法。
    在Java程序中,类是创建对象的模板,对象是类的实例,任
    何一个对象都是隶属于某个类的。Java程序设计是从类的设计开
    始的,所以,在进一步讲述对象的知识之前,必须先掌握类的
    概念。
    第4章 类 与 对 象
    4.1.3

    对象是对事物的抽象,而类是对对象的抽象和归纳。人类在
    认识客观世界时经常采用的思维方法就是把众多的事物归纳成一
    些类。分类所依据的原则是抽象,即抽象出与当前目标有关的本
    质特征,而忽略那些与当前目标无关的非本质特征,从而找出事
    物的共性,把具有共同性质的事物归结为一类,得出一个抽象的
    概念——类。
    在面向对象的编程语言中,类是一个独立的程序单位,是具
    有相同属性和方法的一组对象的集合。类的概念使我们能对属于
    该类的全部对象进行统一的描述。例如,“树具有树根、树干、
    树枝和树叶,它能进行光合作用”。这个描述适合于所有的树,
    从而不必对每棵具体的树都进行一次这样的描述。因此,在定义
    对象之前应先定义类。描述一个类需要指明下述三个方面内容:
    第4章 类 与 对 象
    (1)
    类标识:类的一个有别于其他类的名字,这是必不可少的。
    (2)
    属性说明:用来描述相同对象的静态特征。
    (3)
    方法说明:用来描述相同对象的动态特征。
    第4章 类 与 对 象
    例如,下面是对dog类进行的描述:
    class dog // class指出这是一个类,dog是类标识
    {
    String name;
    int AverageWeight; 类的属性(静态特征)
    int AverageHeight;
    public void move( )
    { …… } 类的方法(动态特征)
    public void ShowDog( )
    { …… }
    }
    dog类
    第4章 类 与 对 象
    4.1.4
    类与对象的关系
    类给出了属于该类的全部对象的抽象定义,而对象则是符
    合这种定义的一个实体。类与对象之间的关系就如同一个模具
    与用这个模具铸造出来的铸件之间的关系一样。也就是说,我
    们可以把类与对象之间的关系看成是抽象与具体的关系。在面
    向对象的程序设计中,对象被称作类的一个实例(instance),而
    类是对象的模板(temp1ate)。类是多个实例的综合抽象,而实例
    又是类的个体实物。如图4.1所示为类与对象的关系。
    第4章 类 与 对 象
    图4.1 类与对象的关系
    抽象
    实例化
    对象:刘丽
    静态特征:刘丽

    讲师
    890.00
    动态特征:授课
    评职称
    调工资
    数据值
    执行的
    操作
    方法名数据结构
    类:教师
    属性:姓名
    性别
    职称
    工资
    服务:授课
    评职称
    调工资
    第4章 类 与 对 象
    4.1.5
    定义类的一般格式
    (1) 系统定义的类,即Java
    类库,它是系统定义好的类。类
    库是Java语言的重要组成部分。Java语言由语法规则和类库两部
    分组成,语法规则确定Java程序的书写规范;类库则提供了Java
    程序与运行它的系统软件(Java虚拟机)之间的接口。Java类库是
    一组由它的发明者SUN公司以及其他软件开发商编写好的Java程
    序模块,每个模块通常对应一种特定的基本功能和任务,且这
    些模块都是经过严格测试的,因而也总是正确有效的。当自己
    编写的Java程序需要完成其中某一功能的时候,就可以直接利用
    这些现成的类库,而不需要一切从头编写,这样不仅可以提高
    编程效率,也可以保证软件的质量。
    第4章 类 与 对 象
    (2) 用户自己定义的类。系统定义的类虽然实现了许多常见
    的功能,但是用户程序仍然需要针对特定问题的特定逻辑来定义
    自己的类。用户按照Java的语法规则,把所研究的问题描述成
    Java程序中的类,以解决特定问题。进行Java程序设计,首先应
    学会怎样定义类。
    在Java程序中,用户自己定义类的一般格式如下:
    class 类名
    {
    数据成员
    成员方法
    }
    第4章 类 与 对 象
    图4.2
    类的图形表示
    类名
    数据成员
    成员方法
    第4章 类 与 对 象
    可以看出,类的结构是由类说明和类体两部分组成的。类
    的说明部分由关键字class与类名组成,类名的命名遵循Java标
    识符的定义规则;类体是类声明中花括号所包括的全部内容,
    它又由数据成员(属性)和成员方法(方法)两部分组成。数据成员
    描述对象的属性;成员方法刻画对象的行为或动作,每一个成
    员方法确定一个功能或操作。图4.2为类的图形表示。
    第4章 类 与 对 象
    【示例程序c4_1.java】
    import java.awt.*; //引用系统类库中的awt包
    import java.applet.*; //引用系统类库中的applet包
    public class c4_1 extends Applet // 由applet类派生的c4_1类
    { int a=5; //数据成员a
    double b=23.4; //数据成员b
    public void paint(Graphics g) //成员方法paint
    { //以下使用g对象的drawString方法
    g.drawString("a="+a,25,25);
    g.drawString("b="+b,25,35);
    }
    }
    第4章 类 与 对 象
    图4.3 程序c4_1的运行结果
    第4章 类 与 对 象
    4.1.6 Java
    类库
    要想掌握好Java的面向对象编程技术,编写出高质量的程
    序,必须对Java的类库有足够的了解。Java的类库是系统提供的
    已实现的标准类的集合,是Java编程的API(Application Program
    Interface),它可以帮助开发者方便、快捷地开发Java程序。Java
    类库的主要部分是由它的发明者SUN公司提供的,这些类库称为
    基础类库(JFC),也有少量则是由其他软件开发商以商品形式提供
    的。有了类库中的系统类,编写Java程序时就不必一切从头做
    起,避免了代码的重复和可能的错误,也提高了编程的效率。一
    个用户程序中系统标准类使用得越多、越全面、越准确,这个程
    序的质量就越高;相反,离开了系统标准类和类库,Java程序几
    乎寸步难行。
    第4章 类 与 对 象
    所以,学习Java语言程序设计,一是要学习其语法规则,
    即第2~3章中的基本数据类型、基本运算和基本语句等,这是
    编写Java程序的基本功;二是要学习使用类库,这是提高编程
    效率和质量的必由之路,甚至从一定程度上来说,能否熟练自
    如地掌握尽可能多的Java类库,决定了一个Java程序员编程能力
    的高低。我从第7章起主要讲述类库的使用。
    第4章 类 与 对 象
    在Java系统中,系统定义好的类根据实现的功能不同,可
    以划分成不同的集合。每个集合称为一个包,所有包合称为类
    库。根据功能的不同,Java类库的每个包中都有若干个具有特
    定功能和相互关系的类和接口。例如,java.lang
    包中包含了运
    行Java
    程序必不可少的系统类,它们包括基本数据类型、基本
    数学方法、字符串处理、线程、异常处理等类;java.awt
    包中
    包括了Java
    语言用来构建图形用户界面(GUI)
    的类库。
    第4章 类 与 对 象
    使用类库中系统定义好的类有三种方式:一种是直接使用
    系统类,例如在字符界面向系统标准输出设备输出字符串时使
    用的方法System.out.println( ),就是系统类System的动态属性
    out的方法;另一种方式是继承系统类,在用户程序里创建系统
    类的子类,例如每个Java Applet的主类都是java.applet包中的
    applet类的子类;最后一种方式是创建系统类的对象,例如图
    形界面的程序中要接受用户的输入时,就可以创建一个系统类
    TextField类的对象来完成这个任务。
    第4章 类 与 对 象
    无论采用哪种方式,使用系统类的前提条件是这个系统类
    应该是用户程序可见的类。为此用户程序需要用import
    语句引
    入它所用到的系统类或系统类所在的包。例如使用图形用户界
    面的程序,应该用语句:
    import java.awt.*;
    import java.awt.event.*;
    引入java.awt包和java.awt.event包。
    第4章 类 与 对 象
    类库包中的程序都是字节码形式的程序,利用import语句
    将一个包引入到程序里,就相当于在编译过程中将该包中所有
    系统类的字节码加入到用户的Java程序中,这样用户的Java程
    序就可以使用这些系统类及其中的各种功能了。
    第4章 类 与 对 象
    下面列出一些在Java程序设计中经常使用的包。
    1
    .java.lang

    java.1ang包是Java语言的核心类库,包含了运行Java程序
    必不可少的系统类,如基本数据类型、基本数学函数、字符串
    处理、线程、异常处理类等。每个Java程序运行时,系统都会
    自动地引入java.1ang包,所以这个包的加载是缺省的。
    第4章 类 与 对 象
    2
    .java.io

    java.io包中包含了实现Java程序与操作系统、用户界面以
    及其他Java程序之间进行数据交换所使用的类,如基本输入/输
    出流、文件输入/输出流、过滤输入/输出流、管道输入/输出流、
    随机输入/输出流等。凡是需要完成与操作系统有关的较底层的
    输入输出操作的Java程序,都要用到java.io包。
    第4章 类 与 对 象
    3
    .java.awt

    java.awt包是Java语言用来构建图形用户界面(GUl)的类
    库,它包括了许多界面元素和资源。利用java.awt包,开发人员
    可以很方便地编写出美观、方便、标准化的应用程序界面。
    java.awt包主要在三个方面提供界面设计支持:①低级绘图操
    作, 如Graphics 类等; ② 图形界面组件和布局管理, 如
    Checkbox类、Container类、LayoutManager接口等;③界面用户
    交互控制和事件响应,如Event类。
    第4章 类 与 对 象
    4
    .java.awt.event

    java.awt.event包是对JDK1.0版本中原有的Event类的一个扩
    充,它使得程序可以用不同的方式来处理不同类型的事件,并
    使每个图形界面的元素本身可以拥有处理它上面事件的能力。
    5
    .java.awt.image

    java.awt.image包是用来处理和操纵来自于网上的图片的Java
    工具类库。
    6
    .java.applet

    java.applet包是用来实现运行于Internet浏览器中的Java
    Applet的工具类库,它仅包含少量几个接口和一个非常有用的类
    Java.applet.Applet。
    第4章 类 与 对 象
    7
    .java.net

    java.net包是Java语言用来实现网络功能的类库。由于Java
    语言还在不停地发展和扩充,它的功能,尤其是网络功能,也
    在不断地扩充。目前已经实现的Java网络功能主要有:底层的
    网络通信,如实现套接字通信的Socket类、ServerSocket类;编
    写用户自己的Telnet、FTP、邮件服务等实现网上通信的类;用
    于访问Internet上资源和进行CGl网关调用的类,如URL等。利
    用java.net包中的类,开发者可以编写自己的具有网络功能的程
    序。
    第4章 类 与 对 象
    8
    .java.rmi
    包、java.rmi.registry
    包和java.rmi.server

    这三个包用来实现RMI(Remote Method Invocation,远程方
    法调用)功能。利用RMI功能,用户程序可以在远程计算机(服务
    器)上创建对象,并在本地计算机(客户机)上使用这个对象。
    9
    .java.util

    java.util包中包括了Java语言中的一些低级的实用工具,如
    处理时间的Date类,处理变长数组的Vector类,实现栈的Stack
    类和实现哈希(散列)表的HashTable类等,使用它们开发者可以
    更方便快捷地编程。
    第4章 类 与 对 象
    10
    .java.sql

    java.sql包是实现JDBC(Java Database Connection)的类库。
    利用这个包可以使Java程序具有访问不同种类的数据库(如
    Oracle,Sybase,DB2,SQLServer等)的功能。只要安装了合适
    的驱动程序,同一个Java程序不需修改就可以存取、修改这些
    不同的数据库中的数据。JDBC的这种功能,再加上Java程序本
    身具有的平台无关性,大大拓宽了Java程序的应用范围,尤其
    是商业应用的适用领域。
    第4章 类 与 对 象
    11.java.security
    ijtscerayuva.
    包、java.security.acl
    iljtscerayu.包和java.security.interfaces
    ifjtsceraynu.包
    这三个包提供了更完善的Java程序安全性控制和管理,利
    用它们可以对Java程序加密,也可以把特定的Java Applet标记
    为“可信赖的”,使它能够具有与Java Application相近的安全权
    限。
    12
    .java.awt.peer

    java.awt.peer包是实现Java语言跨平台特性的手段之一。这
    个包虽然在程序中很少直接用到,但它的作用是将不同的平台
    包裹、隐藏起来,使这些平台在用户程序面前呈现基本相同的
    面貌。
    第4章 类 与 对 象
    14
    .java.awt.datatransfer

    java.awt.datatransfer包提供了处理数据传输的工具类,包括
    剪贴板、字符串发送器等。
    15
    .java.lang.reflect

    java.lang.reflect包提供了用于反射对象的工具,反射允许
    程序监视一个正在运行的对象并获得它的构造函数、方法和属
    性。
    第4章 类 与 对 象
    16
    .java.corba
    包和java.corba.orb

    这两个包将CORBA(Common Object Request Broker
    Architecture,是一种标准化接口体系)嵌入到Java环境中,使得
    Java程序可以存取、调用CORBA对象,并与CORBA对象共同
    工作。这样,Java程序就可以方便、动态地使用已经存在的由
    Java或其他面向对象语言开发的部件,简化软件的开发。
    第4章 类 与 对 象
    4.1.7
    创建对象
    创建对象通常包括声明对象、建立对象和初始化对象三步。
    1
    .声明对象
    声明对象就是确定对象的名称,并指明该对象所属的类。声
    明对象的格式如下:
    类名
    对象名表;
    第4章 类 与 对 象
    其中:类名是指对象所属类的名字,它是在声明类时定义
    的;对象名表是指一个或多个对象名,若为多个对象名时,用
    逗号进行分隔。声明对象的作用是为将来的编译过程提供必要
    的信息。例如:
    class_name object_one,object_two;
    这个语句声明了两个对象object_one,object_two,它们都
    是class_name类的对象。
    第4章 类 与 对 象
    2
    .建立对象
    所谓建立对象,实际上就是用Java提供的new
    关键字为对象
    分配存储空间。在声明对象时,只确定了对象的名称和它所属
    的类,并没有为对象分配存储空间,此时对象还不是类的实例。
    只有通过建立对象这一步,才为对象分配内存,使该对象成为
    类的实例。建立对象的格式如下:
    对象名=new
    构造方法( )
    例如:object_one=new class_name( );
    object_two=new class_name( );
    第4章 类 与 对 象
    也可以在声明对象的同时建立对象,这称为创建一个对象。
    创建对象的格式如下:
    类名
    对象名=new
    构造方法( )
    例如:class_name object_one=new class_name( );
    class_name object_two=new class_name( );
    其中:new是Java的关键字,也可将其称为运算符,因为
    new的作用是建立对象,为对象分配存储空间。执行new
    class_name( )将产生一个class_name( )类的实例(对象)。
    第4章 类 与 对 象
    3.
    初始化对象
    初始化对象是指由一个类生成一个对象时,为这个对象确定
    初始状态,即为它的数据成员赋初始值的过程,当然,它主要由
    一些赋值语句组成。由于初始化操作是最常用的操作之一,为简
    化这一过程,Java还提供了专用的方法来完成它,这个方法被称
    为构造方法。关于构造方法的详细内容请参阅4.1.9节。
    第4章 类 与 对 象
    4.1.8
    使用对象
    一个对象可以有许多属性和多个方法。在面向对象的系统
    中,一个对象的属性和方法被紧密地结合成一个整体,二者是
    不可分割的,并且限定一个对象的属性值只能由这个对象或它
    的方法来读取和修改。这便是封装和信息隐藏的一个方面。
    当一个对象被创建后,这个对象就拥有了自己的数据成员
    和成员方法,我们可以通过引用对象的成员来使用对象,对象
    的数据成员的引用方式如下:
    对象名.
    数据成员名
    对象的成员方法的引用方式如下:
    对象名.
    成员方法名(
    参数表)
    第4章 类 与 对 象
    【示例程序c4_2.java】 定义一个dogs类,使其包括Name、
    Weight和Height三个数据成员和一个名为ShowDog的成员方法。
    为dogs类创建Dane和Setter两个对象,确定两个对象的属性后
    引用ShowDog方法显示这两个对象。
    import java.awt.*;
    import java.applet. *;
    class dogs //定义dogs类
    {
    //以下三行定义dogs类的数据成员
    public String Name;
    public int Weight;
    public int Height;
    第4章 类 与 对 象
    //以下六行是dogs类的成员方法ShowDog( )的定义
    public void ShowDog(Graphics g,int x,int y)
    {
    g.drawString("Name:"+Name,x,y);
    g.drawString("Weight:"+Weight,x,y+20);
    g.drawString("Height:"+Height,x,y+40);
    } //成员方法ShowDog( )定义完成
    }// dogs类定义毕
    第4章 类 与 对 象
    public class c4_2 extends Applet
    {
    public void paint(Graphics g)
    {
    //以下为创建对象
    dogs Dane; //声明了一个名为Dane的对象,它属于dogs类
    Dane=new dogs( ); //建立Dane对象,为它分配存储空间
    dogs Setter=new dogs( );//声明Setter对象的同时建立该对象
    //以下六行引用对象的数据成员,将一组值赋给对象的数据成员
    Dane.Name="Gread Dane";
    Dane.Weight=100;
    第4章 类 与 对 象
    Dane.Height=23;
    Setter.Name="Irish Setter";
    Setter.Weight=20;
    Setter.Height=30;
    //以下两行引用对象的成员方法
    Dane.ShowDog(g,25,25);
    Setter.ShowDog(g,25,120);
    }
    }
    第4章 类 与 对 象
    图4.4 c4_2的运行结果
    第4章 类 与 对 象
    4.1.9
    对象的初始化与构造方法
    创建对象时,通常首先要为对象的数据成员赋初始值(如上
    例中的Dane.Name="Gread Dane";等6条语句),这被称为对象的初
    始化。初始化是最常用的操作之一,为简化这一操作,Java系统
    提供了专用的方法——构造方法来完成这一操作。
    构造方法是一个类的方法中方法名与类名相同的类方法。每
    当使用new关键字创建一个对象,为新建对象开辟了内存空间之
    后,Java系统将自动调用构造方法初始化这个新建对象。构造方
    法是类的一种特殊方法,它的特殊性主要体现在以下几个方面:
    第4章 类 与 对 象
    (1) 构造方法的方法名与类名相同。
    (2) 构造方法是类的方法,它能够简化对象数据成员的初
    始化操作。
    (3) 不能对构造方法指定类型,它有隐含的返回值,该值
    由系统内部使用。
    (4) 构造方法一般不能由编程人员显式地直接调用,在创
    建一个类的对象的同时,系统会自动调用该类的构造方法将新
    对象初始化。
    (5) 构造方法可以重载,即可定义多个具有不同参数的构
    造方法。
    第4章 类 与 对 象
    (6) 构造方法可以继承,即子类可以继承父类的构造方法。
    (7) 如果用户在一个自定义类中未定义该类的构造方法,
    系统将为这个类定义一个缺省的空构造方法。这个空构造方法
    没有形式参数,也没有任何具体语句,不能完成任何操作。但
    在创建一个类的新对象时,系统要调用该类的构造方法将新对
    象初始化。
    第4章 类 与 对 象
    【示例程序c4_3.java】 将示例程序c4_2改写为定义了构造方法的程序。
    import java.awt.*;
    import java.applet.*;
    class dogs //定义 dogs类
    {
    public String Name;
    public int Weight;
    public int Height;
    public dogs(String CName, int CWeight, int CHeight) //构造方法
    第4章 类 与 对 象
    { Name=CName;
    Weight=CWeight;
    Height=CHeight;
    }//构造方法定义毕
    public void ShowDog(Graphics g,int x,int y)
    { g.drawString("Name:"+Name,x,y);
    g.drawString("Weight:"+Weight,x,y+20);
    g.drawString("Height:"+Height,x,y+40);
    }
    } // dogs类定义毕
    第4章 类 与 对 象
    public class c4_3 extends Applet
    {
    public void paint(Graphics g)
    { dogs Dane=new dogs("Gread Dane",100,23);
    dogs Setter=new dogs("Irish Setter",20,30);
    Dane.ShowDog(g,25,25);
    Setter.ShowDog(g,25,120);
    }
    }
    第4章 类 与 对 象
    该程序的执行结果与示例程序c4_2.java相同。
    特殊情况下,构造方法中的参数名可能与数据成员名相
    同,此时,在构造方法中可用下面两种形式之一来区分数据成
    员名与参数名。
    (1)默认法。当构造方法的参数名与数据成员名相同时,
    将赋值号左边的标识符默认为对象的数据成员名,则赋值号右
    边的标识符为参数。
    public dogs(String Name, int Weight, int Height)
    { Name=Name;// 左边的标识符为数据成员名,右边的标识符为参数。下同
    Weight=Weight;
    Height=Height;
    }
    第4章 类 与 对 象
    (2) 使用代表本类对象的关键字this
    指出数据成员名之所在。
    关于this,将在5.4.4节讲述。
    public dogs(String Name, int Weight, int Height)
    {
    this.Name=Name; //用this指出数据成员名。下同
    this.Weight=Weight;
    this.Height=Height;
    }
    展开全文
  • 面向对象程序设计的基本概念

    千次阅读 多人点赞 2021-01-31 17:03:44
    (1) 对象对象类   对象是代码和数据的组合,可以作为一个单位来处理。对象可以是应用程序的一部分,比如可以是控件或窗体。整个应用程序也是一个对象。   VB中的每个对象都是用类定义的。用饼干模子和饼干之间...
  • 第四讲:面向对象程序设计方法及类、对象概念  掌握:面向对象程序设计的方法及特点;类的声明的对象的定义理解:对象的封装、抽象、继承与多态性四个特快性的概念;类和对象的作用;面向对象和面向过程的程序...
  • 1、对象和类概念对象:任何一个对象都应该具备两个要素:属性、行为。在C++中每个对象都有数据(体现了‘属性’)和函数(用来数据进行操作,以实现某些功能)两部分组成。类:具有共性的实体的抽象。类是对象的...
  • php面向对象基础概念(封装)

    千次阅读 2015-06-22 23:30:18
    封装性是面象对象编程中的三大特性之一,封装性就是把对象的属性和服务结合成一个独立的相同单位,并尽可能隐蔽对象的内部细节,包含两个含义: 1. 把对象的全部属性和全部服务结合在一起,形成一个不可分割的独立...
  • Java异常封装(自己定义错误码和描述,附源码)

    万次阅读 多人点赞 2016-01-29 22:30:54
    当然真正工作里面主动抛出的异常都是经过分装过的,自己可以定义错误码和异常描述。下面小宝鸽就为大家介绍一个Java异常简单封装的例子。在给出异常分装例子之前,需要给大家普及Java里面的checked异常和unchecked...
  • VB 面向对象程序设计的基本概念

    千次阅读 2007-04-10 10:51:00
    1.3 面向对象程序设计的基本概念1.基本术语(1) 对象对象类 对象是代码和数据的组合,可以作为一个单位来处理。对象可以是应用程序的一部分,比如可以是控件或窗体。整个应用程序也是一个对象。在 VB中可能...
  • 第一章 对象概念 “我们没有意识到惯用语言的结构有多大的力量。可以毫不夸张地说,它通过语义反应机制奴役我们。语言表现出来并在无意识中给我们留下深刻印象的结构会自动投射到我们周围的世界。” – Alfred ...
  • VC++中的面向对象程序设计概念

    千次阅读 2006-07-02 15:46:00
    面向对象程序设计概念VC++应用程序是采用C++语言编写的。C++是在C语言的基础上进行改进与扩充,是既面向对象又面向过程的一种混合程序设计语言。传统的程序设计思维方式是基于“算法+数据结构=程序”的模式,在...
  • 这里有面向对象开发的几个核心的思想和概念 1、问题领域、对象、属性、状态、行为、方法、实现 ...对象问题领域中的事物的一种抽象。 1)所有的东西都是对象,万物皆对象,问题领域中的实体和概念都可
  • 一、 名词解释抽象 封装 消息【问题解答】面向对象方法中的 抽象是指 具体问题(对象)进 行概括,抽出一类对象的公共性质并加以描述的过 程。面向对象方法中的 封装就是 把抽象出来的对象的 属性和行为结合成一个...
  • 面向对象方法,OO方法所具有的模块化、信息封装与隐蔽、抽象性、继承性、多样性等独特之处,这些优异特性为研制大型软件、提高软件可靠性、可重用性、可扩充性和可维护性提供了有效的手段和途径。Java主要特征:封装性...
  • 本文通过对象的创建步骤中的检查加载->分配内存->内存空间初始化->设置->对象初始化,对象的内存布局,什么是垃圾的两种算法以及四种引用,讲述JVM中对象及引用。
  • java面向对象

    万次阅读 多人点赞 2018-08-21 16:51:59
    包括面向对象概念、类与对象的关系、封装、构造函数、this关键字、static关键字、单例设计模式、继承、多态、内部类、异常、包等java基础知识。 1、面向对象 面向对象是相对面向过程而言 面向对象和面向过程都是...
  • 这是面试的问题,不知道该如何谈起,看来面向对象思想理解不够。 网友回答:网友:daizh面向对象程序设计语言c++中的多态性 蓝雯飞 c++是以c语言为基础,支持数据抽象和面向对象的程序设计语言。c++c语言的扩充...
  • 深入理解Python中的面向对象

    万次阅读 多人点赞 2017-06-12 06:42:41
    类和对象概念 初始化构造函数__init__的作用 self关键字的使用 继承的概念 组合的概念 接口的概念 抽象类的概念 1、面向过程与面向对象的对比面向过程的程序设计的核心是过程(流水线式思维),过程即解决问题的...
  • 深入理解Java类型信息(Class对象)与反射机制

    万次阅读 多人点赞 2017-05-01 23:19:19
    【版权申明】未经博主同意,谢绝转载!(请尊重原创,博主保留追究权) ...深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深入理解
  • 真正工作了才发现,Java里面的异常在真正工作中使用还是十分...当然真正工作里面主动抛出的异常都是经过分装过的,自己可以定义错误码和异常描述。 在给出异常分装例子之前,需要给大家普及Java里面的checked异常和un
  • 【思考】再谈面向过程与面向对象

    千次阅读 多人点赞 2019-08-31 14:10:53
    这篇文章试图对比描述了关于 面向过程与面向对象 的内容。为什么还要再谈呢? 一方面原因是深度不够,另一方面原因要从各种编程语言的感知说起 (涵盖面向对象、面向过程): 编译执行的C语言是静态语言、弱类型...
  • JSP九大内置对象和四种属性范围解读

    万次阅读 多人点赞 2015-07-14 18:27:52
    本文首先主要讲解了JSP中四种属性范围的概念、用法与实例。然后在这个基础之上又引入了九大内置对象,并这几大内置对象一个一个的进行分析的解读。内容很详细,例子都附有代码和运行的结果截图。
  • 面向对象六大原则

    万次阅读 多人点赞 2015-11-30 00:10:44
    小民的主管是个工作经验丰富的技术专家,对于小民的工作并不是很满意,尤其小民最薄弱的面向对象设计,而Android开发又是使用Java语言,什么抽象、接口、六大原则、23种设计模式等名词把小民弄得晕头转向。...
  • 对象存储OSS如何把对象放入文件夹

    千次阅读 2018-10-15 23:17:16
    首先先讲些OSS 对象存储的基本概念: (1):对象(object) 对象是存储在COS中基本数据单位,也就是最小单位,用户的每个文件都是一个...MetaData是该Object的描述信息。 (2)桶(Bucket)是对象的容器,桶名全局唯...
  • 光棍节就要到了,要不要给你介绍个 python 对象

    万次阅读 多人点赞 2019-11-07 08:41:22
    光棍节就要到了,一说介绍对象,我猜你一定想到了派森大叔家的克蕾丝(class)小姐姐和黛夫(def)小哥哥。别想入非非了,严肃点儿!我们今天的的话题,不是介绍男女朋友,而是讲解如何面向对象编程,也就是程序员常...
  • 实体引言在领域驱动设计里,实体的设计可以说是通用语言的核心... 实体是具有可变性的,这是一个和值对象比较明显的区分,也即实体是可以持续得变化,持续得修改,并且具有唯一的标识。在设计实体的时候需要跳出CRUD的
  • Spring AOP(一)——基础概念

    万次阅读 2016-10-12 23:39:12
    前文的一些内容更多是针对Spring容器内部的一些特性的描述,接下来一个专题将描述Spring AOP的一些信息,配置细节等等。介绍面向切面编程(AOP)是一种新的针对程序结构的思路,它补足了面向对象编程(OOP)的一些...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 232,905
精华内容 93,162
关键字:

对对象概念描述错误的是