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

    万次阅读 多人点赞 2019-02-06 21:56:15
    面向对象就是:把数据及对数据的操作方法放在一起,作为一个相互依存的整体——对象。对同类对象抽象出其共性,形成类。类中的大多数数据,只能用本类的方法进行处理。类通过一个简单的外部接口与外界发生关系,对象...

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

    面向对象编程(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

     

    展开全文
  • 面向对象概念精解

    2017-11-06 19:13:23
    面向对象概念精解
    1.抽象
    2.问题领域
    3.对象(属性,状态,方法,行为,实现)
    4.类(类型)
    5.封装(透明话)
    6.继承(扩展,重载,覆盖)
    7.多态(动态绑定,组合)
    8.接口
    9.消息,服务
    面向对象编程的三个原则:封装 ,继承 ,多态
    封装:将代码及其处理数据捆绑在一起的一种机制
    继承:一个对象获得另一个对象的属性和过程
    多态性: 一个接口,多种方法

    一、面向对象
    1.面向机器
     早期计算机中运行的程序大概都是为特定的硬件系统专门设计的,称为面向机器的程序。开发这类程序的语言称为机器语言,也叫做低级语言或二进制代码语言。
      这类程序运行速度和效率都非常高,但是可读性和可种植性极差,随着软件开发规模的扩大,这类面向机器和程序逐渐被以Fortran,C等为代表的面向过程的程序所取代。                                            
    2.面向过程
     其中心思想是用计算机能够理解的逻辑来描述和表达待解决的问题及其具体的解决过程。数据结构、算法是面向过程问题求解的核心组成。其中数据结构利用计算机的离散逻辑来量化表达需要求解的问题,二算法则研究如何快捷,高效的组织解决问题的具体过程。
     面向过程遵循面向过程的问题求解方法。可以精确,完备地描述具体求解过程(这里的过程通常是指操作),但却不足以把一个包含了多个相互关联的过程的复杂系统表述出来。
     
    三、问题领域
     问题领域,是指软件系统所模拟的真实世界中的系统。
     随着计算机的发展和普入,软件系统渗透到社会的各个方面,几乎用来模拟任意一种问题领域。
     如学校、医院、商场、电影摄制组和太阳系等。
     
    四、对象--面向对象的技术核心所在。
    对象是对问题领域中事物的抽象!
    对象具有如下特征:
    1、万物皆为对象;
     问题领域中的实体和概念都可以抽象为对象。
    2、每个对象那都是唯一的;
     对象的惟一性来自真实世界中食物的惟一性。
    3、对象具有属性和行为;
    对象的行为包括具有的功能及具体的实现。
    在建立对象模型时,只关注对象有什么样的功能,而不需要考虑如何实现这些功能。
    对象的属性用成员变量来表示,对象的行为用成员方法表示。
    4、对象具有状态;
    状态是指某个瞬间对象的各个属性的取值。
    对象的某些行为往往会改变对象自身的状态,及属性的取值。
    5、对象都属于某个类,每个对象都市某个类的实例。

    五、类--简单地说,类是同种对象的集合与抽象。
    类是一组具有相同属性和行为对象的抽象,或集合。
    类及类的关系构成了对象模式的主要内容。面向对象编程的主要任务就是定义对象模型中的各个类 
    六、封装
    封装是指隐藏对象的属性和实现细节,仅仅对外公开接口。这是面向对象的基本思想之一。
    使用封装的优点:
    1.便于使用者正确,方便地理解和使用系统,防止使用者错误修改系统的属性
    2.有助于建立各个系统之间的松耦合关系,提高系统的独立性
    3.提高软件的课重用性,每一个系统都是一个相对独立的整体,可以在多种环境中得到重用
    4.降低了构建大型系统的风险,即使整个系统不成功,个别的独立于系统有可能依旧是有价值
    一个设计良好的系统会封装所有的实现细节,把他的接口与实现清晰地隔离开来,系统之间只通过接口进行通信。
    面向对象的额编程语言,主要通过访问控制机制来进行封装,这种机制能控制对象的属性和方法的可访问性。
    在java语言中提供了以下4种访问控制级别:
    public:对外公开,访问级别最高
    protected:只对同一个包中的类或者子类公开
    默认default:只对同一个包中的类公开
    private:不对外公开,只能在对象内部访问,访问级别最低
    哪些属性和方法该公开,哪些该隐藏?
    封装的两个大致原则:
    1.把尽可能多的东西隐藏起来,对外提高简捷的接口。
      系统的额封装程度越高,那么它的相对独立型就越高,使用就更方便。
    2.把所有的属性藏起来
    透明:对象封装实现的细节,也意味着对象的实现细节对使用者是透明的

    八、多态
    1.多态的实质:
    当系统A访问系统B的服务时,系统B可以通过多种实现方式来提供服务,而这一切对系统A是透明的。
    抽象机制:是开发人员在开发过程中使用的机制
    动态绑定机制:是java虚拟机运行时提供的机制
    抽象机制和动态绑定机制能共同提高系统之间的松耦合性。
    2.组合是 一种用多个简单子系统来组装出复杂系统的有效手段
    3.动态绑定
    (补充)
    多态:对同一个消息产生不同的结果反映出多种状态

    九、接口
    在java语言中,接口有两种意思:一是指概念性的接口;二是指程序中的接口类型。
    1.概念性的接口:
    即指系统对外提供的所有服务,在对象中表现为public类型的方法的声明。
    既然每个对象都是服务提供者,如何对外提供服务呢?对象通过接口对外提供服务。
    在现实世界中,接口也是实体,比如电源插口,电灯开关等,而在面向对象范畴中,接口是一个抽象的概念,实质系统对外提供的所有服务。系统的接口描述描述系统能够提供哪些服务,但是不包含服务的实现细节。这里的系统既可以指整个软件系统,也可以指一个子系统,对象是最小的子系统,每一个对象都是服务提供者,因此每个对象都有接口。

    2.接口类型:
    指interface关键字定义的实实在在的接口,它用于明确地描述系统对外提供的所有服务,它能够更加清晰地把系统的实现细节与接口分离。

    十、消息,服务
    软件系统的复杂功能是由各种对象协同工作来完成的。
    每个对象都有特定的功能,相对于其他对象而言,它的功能就是为其他对象提供的服务。
    一个对象为了获得另一个对象的服务,需要向那对象提出获得特定服务的请求,提出请求的过程被称为发送消息。
    对象提供的服务是由对象的方法来实现的,因此发送消息实际上也是调用一个对象的方法。
     
    从使用角度出发,整个软件系统就是服务提供者。操作软件系统的用户是系统的边界。
    在UML语言中,系统边界被称为角色(Actor)。在系统内部,每个子系统(对象或对象的组合)也都是服务提供者,它们为其子系统提供服务,子系统之间通过发送消息来互相获得服务。一个孤立的不对外提供任何服务的系统是没有任何意义的。






    展开全文
  • 面向对象技术 -- 面向对象概念

    热门讨论 2018-06-17 19:55:30
    看了点软工视频,对面向对象概念有了些许的了解。 是面向对象开发模式中基本成分; 每个对象可以用他本身的一组属性和他可以执行的一组操作定义 属性一般只能通过执行对象的操作来改变; 操作成为方法或服务,...

    背景

    看了部分软工视频,对面向对象的概念有了些许的了解。

    什么是

    面向对象=对象+类+继承+通信

    若一个系统使用这样 4 个概念设计和实现的,则这个软件系统是面向对象的。

    对象

    是面向对象开发模式中基本成分;

    每个对象可以用他本身的一组属性和他可以执行的一组操作定义

    属性一般只能通过执行对象的操作来改变;

    操作成为方法或服务,描述了对象执行得到功能,若通过消息传递,还可以为其他对象使用。

    消息

    对象和另外一个对象的通信单元,是要求某个对象执行类中定义的某个操作的规格说明。

    一组具有相同数据结构和相同操作的对象的集合。

    定义包括一组数据属性和在数据上的一组合法操作。

    类的实现

    通过变量的声明、操作界面的实现及支持界面操作的函数的实现,可实现一个类的预期行为和状态;

    实现是与语言有关的,一个好的面向对象语言应当分离共有界面与其内部实现。

    类的测试

    如果类的定义提供的界面比较狭窄,那么穷举测试就有可能实现;

    类的测试在最抽象的层次开始,沿继承关系继续向下进行;

    已经测试过的部分不需要重新测试。

    继承

    使用已经存在的定义作为基础建立新定义的基础;

    新类的定义可以是既存类所声明的数据和新类所增加的声明的组合 。

    写在最后

    个人的学习笔记,有的内容或许有遗漏或者错误,还望斧正。

    展开全文
  • 面向对象概念-类与对象的关系 封装:指隐藏对象的属性和实现细节,仅对外提供公共访问方式,private-构造方法/构造器-this关键字-static关键字(javadoc制作工具类) -代码块 继承:方法重写-super-子类实例化过程-...

    面向对象概念-类与对象的关系

    封装:指隐藏对象的属性和实现细节,仅对外提供公共访问方式,private-构造方法/构造器-this关键字-static关键字(javadoc制作工具类) -代码块

    继承:方法重写-super-子类实例化过程-final-抽象类-接口

    多态:

     

    1.1 面向对象概念Object-Oriented

    1.1.1 理解面向对象

    面向对象是相对面向过程而言
    面向对象和面向过程都是一种思想
    面向对象是基于面向过程的

     

    1.1.2 面向对象的特点

    可以将复杂的事情简单化
    将程序员从执行者转换成了指挥者
    完成需求时:
    先要去找具有所需的功能的对象来用。如果该对象不存在,那么创建一个具有所需功能的对象,这样简化开发并提高复用

      1. 开发的过程:其实就是不断的创建对象,使用对象,指挥对象做事情
      2. 设计的过程:其实就是在管理和维护对象之间的关系。

    面向对象的特征:

      • 封装(encapsulation)
      • 继承(inheritance)
      • 多态(polymorphism)

    1.2类与对象的关系

    1.2.1类与对象的定义

    使用计算机语言就是不断的在描述现实生活中的事物。java中描述事物通过类的形式体现,类是具体事物的抽象,概念上的定义。对象(实例)即是该类事物实实在在的个体
    不同Dog对象抽象出Dog类。

    1.2.2类的定义

    生活中描述事物无非就是描述事物的属性和行为
    如:狗有颜色,年龄等属性,有跑,叫等行为
    Java中用类class来描述事物也是如此

      • 现实世界中事物的属性:对应类中的成员变量
      • 现实世界中事物的行为:对应类中的成员方法

    定义一个类,其实就是在定义类中的成员(也就是成员变量和成员方法)
    public class Dog{
    public String color; //成员变量
    public void eat(){...} //成员方法
    }

    类成员的写法:

      • 成员变量:

        和之前定义变量的规则一样
        写在类中,成员方法的外边

      • 成员方法:

        和之前定义方法的规则一样

    1.2.3成员变量和局部变量的区别

    成员变量(目前都是实例变量):
      成员变量定义在类中,作用范围是整个类
      实例变量随着对象的创建而存在,随着对象消失;存在于对象所在的堆内存中
      成员变量有默认初始化值(0/0.0/false/null)


    局部变量:
      局部变量定义在局部范围内:方法内,形参上,代码块内
      局部变量存在于栈内存中
      方法或者语句执行完,变量空间自动释放
      局部变量没有默认初始化值,除了形参,使用之前必须赋值

    1.2.4创建对象,使用对象

    类定义:

    //类定义
    class
    Car{ int year;String color; public void run(){ System.out.println(“车在跑...”); } public void turnTo(String direction){ System.out.println(“转向:”+direction); } }

     类使用:

    public class CarDemo{ //想要运行main方法,专门放入一个测试类中
        public static void main(String[] args){ 
            Car c = new Car();//建立对象
            c.color = "black";
            c.run();//调用对象的方法
        }
    }

    1.2.5对象的内存结构

    一个对象的内存结构
    重点:
    1.方法区的概念
    2.成员变量的初始化

    两个变量指向一个对象的内存结构
    重点:多个变量指向同一个对象(多对一关系)

    同类两个对象的内存结构
    重点:方法的共用

     1.2.6匿名对象

    匿名对象是对象的简化形式
    匿名对象两种使用情况:
      1.对象方法仅进行一次调用时,多次调用不适合
      2.匿名对象可以作为实际参数进行传递(可作参)
      3.作为返回值返回
    使用匿名对象的好处:
      1.简化写法,不必定义变量接住对象引用
      2.对象用完之后就变成垃圾内存,可以被垃圾回收器回收

     

    转载于:https://www.cnblogs.com/wqbin/p/11146247.html

    展开全文
  • C++面试题-面向对象-面向对象概念

    千次阅读 2019-01-11 00:16:27
    C++面试题-面向对象-面向对象概念 问:说说C++和C的主要区别? 答: C语言属于面向过程语言,通过函数来实现程序功能。而C++是面向对象语言,主要通过类的形式来实现程序功能。 使用C++编写的面向对象应用程序比...
  • 概念 1、什么是面向对象 一切看待问题的思维方式,着眼于找到一个特殊功能的具体的个体,然后委托这个个体去做某些事情...面向对象编程主要用语言描述将现实世界中存在的事物,或者规律。无限接近机器语言。 3...
  • 面向对象概念

    2009-01-11 12:17:49
    理解抽象与封装的概念,掌握JAVA中的类与对象的应用,能够运用面向对象思想进行类的设计,正确设计类中的成员方法和成员变量,是我们学习的目标。 面向对象是一种新型的程序设计方法,或者说是一种心的...
  • 面向对象是一种由对象、类、封装、继承和多态性等概念来构造系统的软件开发方法。 对象 对象是现实世界中客观存在的某种事物,它可以是有形的,也可以是无形的。对象是一种相对独立的实体,它具有静态特性和动态特性...
  • 具有相同或相似性质的一组对象的抽象就是类,类是对一类事物的描述,是抽象的、概念上的意义; 对象是实际存在的该类事物的每个个体,因此...面向对象的三个基本特征: 一、封装  对象要有一个明确的边界;边界
  • 面向对象概念0 目录8 UML-18.1 面向对象概念8.1.1课堂重点8.1.2测试与作业8 一章 0 目录 8 UML-1 8.1 面向对象概念 8.1.1课堂重点 8.1.2测试与作业 1填空(2分)在面向对象方法中,对于客观事物的...
  • 好程序员Java培训分享Java面向对象概念解析,Java作为构建编程语言的核心基础,已经得到了越来越多人的青睐。人们在对Java充满向往的同时,对于Java面对对象知识点的兴趣越来越浓厚。那面向对象到底指的是什么呢?...
  • 面向对象的基本概念

    2019-07-24 19:01:01
    类是对同一类对象的抽象描述,它包括对象的属性和行为,是面向对象的基础。 继承是在已有类的基础上生成新类的过程,通过继承可以实现代码重用,提高编程效率,还是实现多态性的前提。 多态指的是同一类对象表现出的...
  • 一、基本概念 1、类:具有相同或者相似性质的对象的抽象就是类。对象的抽象就是类,类的具体化就是对象。比如人类就是一个抽象类,具体到张三李四就是对象。 2、对象:将一组数据和这组数据有关的操作组装在一起,...
  • 面向对象程序设计的基本概念

    千次阅读 2016-07-04 15:31:41
    概述概念面向对象 = 对象 + 类 + 继承 + 消息对象对象(Object):具有责任的实体。用来描述客观事物的实体,是构成系统的一个基本单位,由一组属性以及作用在这组属性的操作构成。特性:标识符(区别其他对象)、属性...
  •  名称注解范型(paradigm)做事情的整体策略和观点,范型是一套特定的思想集....面向对象范型(object-oriented paradigm)一种基于以下概念的开发策略:即从被称为对象的可重用组件来构建系统的.OO(面向对象)ob
  • c++面向对象和c面向过程的一些概念

    千次阅读 2017-01-18 14:02:46
    1.面向对象和面向过程的概念 面向过程是分析解决问题的步骤,然后用函数把这些步骤一步一步的实现,然后在使用的时候一一调用则可。 面向对象是把构成问题的事务分解成各个对象,而建立对象的目的也不是为了完成一...
  • 我写博客是为了提升自己,还有分享些自己的心得给大家,希望能帮助大家学习JAVA。 我是自学的,如果写的有错误或者能更好的修改的请提出。...下面我为大家解释下面向对象概念。   面向对象的...
  • 面向对象分析和设计基本概念

    千次阅读 2014-10-12 11:54:31
     面向对象分析和设计基本概念  面向对象是基于一种哲学思想,它认为:客观实体和实体之间的联系构成了现实世界的所有问题,而每一个实体都可以抽象为对象。这种思想尽可能地按照人类认识世界的方法和思维方式来...
  • 面向对象基础概念

    千次阅读 2007-05-30 17:27:00
    面向对象概念和应用已超越了程序设计和软件开发,扩展到很宽的范围。如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。 谈到面向对象,这方面的文章非常多。...
  • 面向对象的一些基本核心概念

    千次阅读 2016-12-19 12:00:27
    封装是面向对象的特征之一,是对象和类概念的主要特性。 封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。 1.2继承 面向对象编程...
  •  * 而我个人认为面向对象,首先要把面向与对象分开,在我们明确了对象之后,才可以考虑如何去面对它,而面对他并不是指你的脸面对向他,而是指我们如何去挖掘这个对象的实际的内涵。比如我们把一个人确定为对象,...
  • 什么是对象? 《韦氏大词典》中对对象定义: (1)某种可为人所感知的物质。 (2)思维、感受或动作所作用的物质或精神体。 ...----说白了万物皆对象 ...在软件开发中,对象是建立面向对象程序所依赖的基本单元。 ...
  • Java面向对象程序设计的基本概念早期的程序设计经历了“面向问题”、“面向过程”的阶段,随着计算机技术的发展,以及所要解决问题的复杂性的提高,以往的程序设计方法已经不能适应这种发展的需求。于是,从 20 世纪...
  • 我现在正在学习C#,以前一直是用c,c++,其...学到面向对象概念这里也来个三步走,第一是初论,二是中论,三是末论。初论主要学到的是,何为抽象,什么是对象。中论主要学到的是,对象互操作,对象间关系,对象群集。
  • js 面向对象的基本概念和基本使用方法 -> js 是不是一个面向对象的语言? 不是:与传统面向对象的理论语言有矛盾。C#,Java。 是:js里面到处都是对象,数组,时间,正则… 和 DOM。也可以像传统面向对象的语言那样...
  • 类和对象的基本概念 “类”指的是一类事物,是一个抽象的概念对象”指的是属于某个类的一个实体,是一个具体存在的事物   Tip:   类是一种“模板”,可以通过这种模板创建出不同的对象“实例” 对象“实例...
  • 面向对象的一些概念

    千次阅读 2011-10-24 00:23:48
    1.面向对象的三个基本特征是:...封装是面向对象的特征之一,是对象和类概念的主要特性。 封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 142,466
精华内容 56,986
关键字:

下面对对象概念描述错误的是