精华内容
下载资源
问答
  • Scala:对象特征(接口)

    千次阅读 2016-10-23 16:32:03
    http://blog.csdn.net/pipisorry/article/details/52902609Scala对象类对象的抽象,而对象的具体实例。是抽象的,不占用内存,而对象是具体的,占用存储空间。是用于创建对象的蓝图,它是一个定义包括...

    http://blog.csdn.net/pipisorry/article/details/52902609

    Scala类和对象

    类是对象的抽象,而对象是类的具体实例。类是抽象的,不占用内存,而对象是具体的,占用存储空间。类是用于创建对象的蓝图,它是一个定义包括在特定类型的对象中的方法和变量的软件模板。

    类的创建和实例化

    class Point(xc: Int, yc: Int) {
       var x: Int = xc
       var y: Int = yc
    
       def move(dx: Int, dy: Int) {
          x = x + dx
          y = y + dy
          println ("x 的坐标点: " + x);
          println ("y 的坐标点: " + y);
       }
    }

    Scala中的类不声明为public,一个Scala源文件中可以有多个类。

    以上实例的类定义了两个变量 xy ,一个方法:move,方法没有返回值。

    Scala 的类定义可以有参数,称为类参数,如上面的 xc, yc,类参数在整个类中都可以访问。

    接着我们可以使用 new 来实例化类,并访问类中的方法和变量:

    import java.io._
    
    class Point(xc: Int, yc: Int) {
       var x: Int = xc
       var y: Int = yc
    
       def move(dx: Int, dy: Int) {
          x = x + dx
          y = y + dy
          println ("x 的坐标点: " + x);
          println ("y 的坐标点: " + y);
       }
    }
    
    object Test {
       def main(args: Array[String]) {
          val pt = new Point(10, 20);
    
          // 移到一个新的位置
          pt.move(10, 10);
       }
    }

    实例的默认参数

    def this() = this(x = 1, y = 2)

    Scala 继承

    Scala继承一个基类跟Java很相似, 但我们需要注意一下几点:

    • 1、重写一个非抽象方法必须使用override修饰符。
    • 2、只有主构造函数才可以往基类的构造函数里写参数。
    • 3、在子类中重写超类的抽象方法时,你不需要使用override关键字。

    继承会继承父类的所有属性和方法,Scala 只允许继承一个父类。

    Scala重写一个非抽象方法,必须用override修饰符。

    实例:

    class Point(xc: Int, yc: Int) {
       var x: Int = xc
       var y: Int = yc
    
       def move(dx: Int, dy: Int) {
          x = x + dx
          y = y + dy
          println ("x 的坐标点: " + x);
          println ("y 的坐标点: " + y);
       }
    }
    
    class Location(override val xc: Int, override val yc: Int,
       val zc :Int) extends Point(xc, yc){
       var z: Int = zc
    
       def move(dx: Int, dy: Int, dz: Int) {
          x = x + dx
          y = y + dy
          z = z + dz
          println ("x 的坐标点 : " + x);
          println ("y 的坐标点 : " + y);
          println ("z 的坐标点 : " + z);
       }
    }

    Scala 使用 extends 关键字来继承一个类。实例中 Location 类继承了 Point 类。Point 称为父类(基类),Location 称为子类。

    override val xc 为重写了父类的字段。

    皮皮blog


    Scala单例对象与伴生对象

    Scala的单例对象

    Scala没有 static 这个东西,不能定义静态成员,而是代之定义单例对象(singleton object)。以object关键字定义。
    对象定义了某个类的单个实例,包含了你想要的特性:

    object Accounts{
        private var lastNumber = 0
        def newUniqueNumber() = { lastNumber += 1; lastNumber}
    }
    

    当你在应用程序中需要一个新的唯一账号时,调用Account.newUniqueNumber()即可。
    对象的构造器在该对象第一次被使用时调用。

    在下面几个场景下可以使用Scala单例对象:

    - 作为存放工具函数或常量的地方
    - 高效地共享单个不可变实例
    - 需要使用单个实例来协调某个服务时
    

    类和单例对象间的差别是,单例对象不带参数,而类可以。因为单例对象不是用new关键字实例化的,所以没机会传递给它实例化参数。每个单例对象都被实现为虚拟类(synthetic class)的实例,并指向静态的变量,因为它们与Java静态类有相同的初始化语义。

    独立对象(standalone object)

    不与伴生类共享名称的单例对象称为独立对象。它可以用在很多地方,例如作为相关功能方法的工具类,或者定义Scala应用的入口点。

    伴生对象(companion object)

    当单例对象与某个类共享同一个名称时,它就被称为是这个类的伴生对象(companion object)。类和它的伴生对象必须定义在同一个源文件中。类被称为是这个单例对象的伴生类(companion class)。类和它的伴生对象可以互相访问其私有成员

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    class Account {
    val id = Account.newUniqueNumber()
    private var balance = 0.0
    def deposit(amount: Double){ balance += amount }
    ...
    }
    object Account { //伴生对象
    private var lastNumber = 0
    def newUniqueNumber() = { lastNumber += 1; lastNumber}
    }

    注意

    • 类的伴生对象可以被访问,但并不在作用域当中。Account类必须通过Account.newUniqueNumber()来调用伴生对象的方法。
    • 在REPL中,要同时定义类和对象,必须用粘贴模式。键入:paste,然后键入或粘贴类和对象的定义,最后一Ctrl+D退出粘贴模式。

    将伴生对象作为工厂使用

    我们通常将伴生对象作为工厂使用。
    下面是一个简单的例子,可以不需要使用’new’来创建一个实例了。

    1
    2
    3
    4
    5
    class Bar(foo: String)
    object Bar {
    def apply(foo: String) = new Bar(foo)
    }

    单例对象实例

    import java.io._
    
    class Point(val xc: Int, val yc: Int) {
       var x: Int = xc
       var y: Int = yc
       def move(dx: Int, dy: Int) {
          x = x + dx
          y = y + dy
       }
    }
    
    object Test {
       def main(args: Array[String]) {
          val point = new Point(10, 20)
          printPoint
    
          def printPoint{
             println ("x 的坐标点 : " + point.x);
             println ("y 的坐标点 : " + point.y);
          }
       }
    }

    伴生对象实例

    /* 文件名:Marker.scala */
    
    // 私有构造方法
    class Marker private(val color:String) {
      println("创建" + this)
      override def toString(): String = "颜色标记:"+ color
    }
    
    // 伴生对象,与类共享名字,可以访问类的私有属性和方法
    object Marker{
        private val markers: Map[String, Marker] = Map(  //一调用这个函数,就会创建3个class Marker
          "red" -> new Marker("red"),
          "blue" -> new Marker("blue"),
          "green" -> new Marker("green")
        )
        def apply(color:String) = {
          if(markers.contains(color)) markers(color) else null
        }
        def getMarker(color:String) = { 
          if(markers.contains(color)) markers(color) else null
        }
    
        def main(args: Array[String]) { 
            println(Marker("red"))       //println会调用object Marker的toString函数,伴生对象就直接调用class Marker的toString函数了。
            // 单例函数调用,省略了.(点)符号  
    	println(Marker getMarker "blue")  
        }
    }
    
    
    $ scalac Marker.scala 
    $ scala Marker
    创建颜色标记:red
    创建颜色标记:blue
    创建颜色标记:green
    颜色标记:red
    颜色标记:blue

    [【Scala】单例对象与伴生对象]

    皮皮blog



    Scala Trait(特征)

    Scala Trait(特征) 相当于 Java 的接口,实际上它比接口还功能强大。

    与接口不同的是,它还可以定义属性和方法的实现。

    一般情况下Scala的类只能够继承单一父类,但是如果是 Trait(特征) 的话就可以继承多个,从结果来看就是实现了多重继承。

    Trait(特征) 定义的方式与类类似,但它使用的关键字是 trait,如下所示:

    trait Equal {
      def isEqual(x: Any): Boolean
      def isNotEqual(x: Any): Boolean = !isEqual(x)
    }

    以上Trait(特征)由两个方法组成:isEqualisNotEqual。isEqual 方法没有定义方法的实现,isNotEqual定义了方法的实现。子类继承特征可以实现未被实现的方法。所以其实 Scala Trait(特征)更像 Java 的抽象类。

    特征构造顺序

    特征也可以有构造器,由字段的初始化和其他特征体中的语句构成。这些语句在任何混入该特征的对象在构造是都会被执行。

    构造器的执行顺序:

    • 调用超类的构造器;
    • 特征构造器在超类构造器之后、类构造器之前执行;
    • 特质由左到右被构造;
    • 每个特征当中,父特质先被构造;
    • 如果多个特征共有一个父特质,父特质不会被重复构造
    • 所有特征被构造完毕,子类被构造。

    构造器的顺序是类的线性化的反向。线性化是描述某个类型的所有超类型的一种技术规格。

    from: http://blog.csdn.net/pipisorry/article/details/52902609

    ref:


    展开全文
  • 对象特征

    千次阅读 2019-04-28 20:44:45
    面向对象的程序设计的4个特点:封装性,继承性,多态性,抽象性。 **基于对象程序设计的两个特点:**抽象性和封装性,其中面向对象程序设计是在基于对象程序设计的两个特点...对象的抽象:对象的一个具体实...
    1. 面向对象的程序设计的4个特点:封装性,继承性,多态性,抽象性。
    2. **基于对象程序设计的两个特点:**抽象性和封装性,其中面向对象程序设计是在基于对象程序设计的两个特点的基础上,再加两个特点即多态性和继承性发展而来的。
    3. 对象的两个因素(要素):数据和操作(函数)。
    4. 面向对象程序设计的封装性:将对象的数据和功能对外隔绝,以防止外部修改。
    5. 对象的对外接口是函数名
    6. 类是对象的抽象:对象是类的一个具体实例,即类的具体表现形式。
    7. 继承:在原有类的基础上,再新增一个类,其中原有类称为父类或者基类,新增加的类可称为子类或派生类,子类和派生类又可以称为一个父类和基类。
    8. 软件重用:在原有类的基础上,又新增新的类,这样可以重用原有类的一部分,这就是软件重用,可以大大减小编程量。
    9. 多态性:由继承而产生的不同的派生类,其对象对同一消息会做出不同的响应。
    10. 面向对象软件开发:面向对象分析(OOA),面向对象设计(OOD),面向对象编程(OOP),面向对象测试(OOT),面向对象维护(OOSM)。
    11. 成员访问限定符:private(私有的),public(共有的),protected(受保护的),用来声明成员的访问属性。
    展开全文
  • JAVA面向对象对象

    千次阅读 多人点赞 2015-12-20 09:30:41
    Java是一种面向对象的编程语言,面向对象在整个Java的学习中属于重中之重,从这一篇博客开始,将逐步为大家介绍Java面向对象的相关知识,这一偏将为大家介绍对象的概念以及如何定义和创建对象。 一、对象...

    Java是一种面向对象的编程语言,面向对象在整个Java的学习中属于重中之重,从这一篇博客开始,将逐步为大家介绍Java面向对象的相关知识,这一偏将为大家介绍对象和类的概念以及如何定义类和创建对象。

    一、对象和类的概念

    1、对象

    以一个人为例,对于人,我们可以从他所具有的特征和所具有的行为来进行分析。

    特征:体重、身高、性别、年龄......

    行为:吃饭、睡觉、说话......

    上面的例子就是对现实世界中的具体事物进行的描述,这些具体的事务就是对像,比如一个人、一辆车。从以上的分析还可以看出,人类在对事物进行描述的时候大多从两个方面,即从静(特性、特征)和动(用途、行为)来展开。所以我们可以总结为:对象指具体的事物,具有静态的特征和动态的行为或用途。

    在Java语言中,在对对象进行描述时,其静态的特征称为属性,动态的行为或用途称为方法。

    2、类

    上面提到对象是具体的事物,那么,类就是对具体事物的一般特征进行描述。换句话说,类是具有相同属性和行为的一组对象的集合,类也有属性和行为。

    对象是具体的一个实实在在的事物,类是从这些具体事物(对象)的原型。是这些事物一般特征的描述,是抽象出来的。

    二、定义类和创建对象

    1、类的声明

    Java中类声明的格式如下:

    [类修饰符] class 类名 [extends 父类名称] [implements 接口名称列表] 

    {

       变量定义及初始化;

       方法定义及方法体;

    }

    类修饰符:[public|abstract|final] 缺省方式为frindly

    public:类的访问控制符。Java类具有两种访问访问修饰符:public和default。public允许类具有完全开放的可见性,所有其他类都可以访问它,省略public,则为default,即只有位于同一个包(本质上就是文件夹)中的类可以访问该类。

    abstract指明该类为一个抽象类,说明该类是一个定义不完全的类,需要被继承,才能实例化创建对象。

    final:表明该类为最终类,不能被继承。

    extends:表示继承,如果没有指定继承关系,则自动从Object类派生该类。

    implements:表示实现接口。

    2、类的成员

    类的成员包括属性(变量)和方法两个部分,定义格式如下:

    成员变量:

    [变量修饰符] 变量数据类型 变量名;

    变量修饰符可以为public、protected、private、static、final、transient、volatile。

    成员变量可以是Java的任意一种数据类型

    成员方法:

    [方法修饰符] 返回类型 方法名称(参数列表) [throws exception]

    {

       ......

    }

    方法修饰符可以是public、protected、private、static、final、abstract、native、synchronized。

    返回类型可以是Java任意数据类型,当一个方法不需要返回值时,返回类型为void。

    参数的类型可以是Java任意数据类型,根据数据类型的不同采用值传递或引用传递。

    3、创建对象

    想要创建对象,我们首先要抽象出类,比如我们要创建一个箱子对象,我们应该首先抽象出箱子类,箱子具有长度、宽度、高度等属性,并且可以计算体积,所以我们可以这样定义这个类:

    public class Box 
    {
       private double length;
       private double width;
       private double height;
       
       public void setLength(double length)
       {
          this.length = length;
       }
       
       public void setWidth(double width)
       {
          this.width = width;
       }
       
       public void setHeight(double height)
       {
          this.height = height;
       }
       
       public double getLength()
       {
    	   return length;
       }
       
       public double getWidth()
       {
    	   return width;
       }
       
       public double getHeight()
       {
    	   return height;
       }
       
       public double getV()
       {
          return length * width * height;
       }
    }
    在这个类中,类名为Box,我们定义了三个属性,分别为长、宽、高,且属性的访问修饰为private,我们需要通过getter/setter方法对其进行读取/赋值,另外还有一个计算体积的方法。

    要想创建新的对象,我们需要使用new关键字和想要创建对象的类名,如:

    Box box = new Box();

    等号左边以类名Box作为变量类型定义了一个变量box,来指向等号右边通过new关键字创建的一个Box类的实例对象,变量box就是对象的引用。注意:在new语句的类名后一定要加上(),Box()被称为构造方法,后面会进行讲解。

    如果要访问对象中的属性或方法,可以使用.操作符,如:box.getV();

    展开全文
  • Java对象与Java

    千次阅读 多人点赞 2021-07-28 22:23:35
    文章目录1.面向对象是什么?2.Java1.什么是2.Java类类的结构Java的格式3.java对象4.对象5....面向对象语言的三大特征1.封装2.多态3.继承12.之间的关系1.关联关系(has-a)2.依赖关系(uses-a

    大家好,我是KookNut39也是Tommy,在CSDN写文,写Java时候我是Tommy,分享一些自己认为在学习过程中比较重要的东西,致力于帮助初学者入门,希望可以帮助你进步。感兴趣的欢迎关注博主,和博主一起学习Java知识。大家还可以去专栏查看之前的文章,希望未来能和大家共同探讨技术。

    面向对象程序设计是当今主流的程序设计范型,它取代了20世纪70年代的“结构化”或过程式编程技术。

    ——Java核心技术 卷1(11版)

    由于Java是面向对象的,所以我们必须熟悉面向对象程序设计才能更好的使用Java

    1.面向对象是什么?

    面向对象:object oriented programming 缩写 OOP面向对象的编程语言

    1. 以分类的方式进行思考和解决问题。
    2. 面向对象先对整体关系作出分类,然后根据不同的类深入细节的处理。
    3. 面向对象的思想符合人类的认知习惯。

    我见过举的最多的例子就是把大象放进冰箱:

    ​ 面向对象的思想就是把这件事的三个步骤:打开冰箱,放入大象,关闭冰箱。这三个动作俩个是关于冰箱的,一个是关于操作人的。所以就把打开冰箱,关闭冰箱这俩个操作定义在冰箱这个对象中,把放入大象定义在人这个对象中。于面向过程不同的就是在,面向过程关注的是正在发生什么事,面向对象关注的是发生这件事和谁有关系。

    面向对象的程序是由对象组成的,每个对象包含对用户公开的特定功能部分和隐藏的实现部分。

    ——Java核心技术 卷1(11版)

    注意

    面向对象无法取代面向过程,他们是相辅相成的。面向对象关注于从宏观上把握事物之间的关系,在具体到如何实现某个细节时(在类中定义一个方法),仍然采用面向过程的思维方式。

    对于一些规模较小的问题,将它分解为过程的开发方式比较理想,面向对象的设计思想适用于规模较大的项目,把很多个过程转换为较少的类,这更便于程序员管理,寻找错误时与比较方便(假设一个数据出现了错误,你只需要找访问这个数据的方法)。

    2.Java类

    1.什么是类

    类是构造对象的模板或蓝图,我们可以将类想象成制作小甜饼的模具,将对象想象为小甜饼。

    ——Java核心技术 卷1(11版)

    也就是说:

    1. 类就是将一类事物的相同的属性,行为放在一起
    2. 类是表示一个客观世界某类群体的一些基本特征抽象.

    2.Java类

    类的结构

    ​ 变量:事物属性的描述;

    ​ 方法:事物的行为;(可以做的事情)

    ​ 构造方法:用于创建对象;(创建类的时候有一个默认的无参的构造方法)

    ​ 内部类: 即在类体中声明的类。

    ​ 块:一段没有名称的代码块

    Java类的格式

    [访问权限修饰符]  [修饰符] class Person{
    //第一步声明一个类
      /*访问修饰符有两种public,无(默认)
    
      修饰符:final,abstract
    
      关键字class用来定义一个类
        
      Java类名的命名规范:
    
      类名首字母大写,见名知意,驼峰表示*/
    //第二步给类添加属性
        //成员变量定义
        /*
        [访问权限修饰符] [修饰符] 属性类型 属性名;
        */
        public String name; //名字
        public Integer age; //年龄
    //第二步给类添加方法
        /*方法声明格式为:
        [访问权限修饰符] [修饰符] 返回值类型  方法名(){
    	
         }*/
         public void eat(){
             System.out.println("吃饭");
         }
    
    }
    

    3.java对象

    对象是类的一个实例,是以类为模板在内存中创建的实际存在的实例

    上面举得例子人就是一个类,我们每个人都是一个对象,拥有类中的属性,行为,可以使用。

    对象的创建和使用

    Person person = new Person();
    

    Person person:使用Person类作为类型声明一个变量person(对象变量)。

    new Person():使用new + Person 类构造方法创建对象.

    =:将右边创建的对象地址 赋给 左边的person变量

    使用person变量可以访问对象中的成员变量和成员方法.

    注意

    1. 同一类的每个对象有不同的成员变量存储空间。

    2. 同一类的每个对象共享该类的方法。

    要想使用对象,必须清楚对象的三个主要特征:

    1. 对象的行为:可以对对象完成哪些操作,或者可以对对象应用哪些方法。
    2. 对象的状态:当调用那些方法时,对象会怎么样。
    3. 对象的标识:如何区分具有相同行为与状态的不同对象。

    4.类和对象

    类是一类事物的抽象概念,是一个模型

    对象是由这个模型所创造的一个个具体存在的,实实在在存在的实例。

    所以创建对象的过程也叫实例化对象。

    编程中现有类后有对象。

    现实生活中先有对象后有类(相当于根据对象,总结出来的类)。

    5.类中的变量,方法

    1.变量分类

    按照位置分

    成员变量:

    ​ 成员变量是定义在类中,方法体之外的变量。

    ​ 成员变量可以使用Java语言中任何一种数据类型(包括基本类型和引用类型)。

    ​ 在定义成员变量时可以对其初始化,如果不对其初始化,Java使用默认的值对其初始化。

    ​ 成员变量在创建对象的时候会从类中复制一份到对象中。

    ​ 成员变量可以被类中方法、构造方法和特定类的语句块访问。

    ​ 成员变量的作用范围为整个类体。

    局部变量:

    ​ 在方法、构造方法或者语句块中定义的变量被称为局部变量。

    ​ 局部变量可以使用Java语言中任何一种数据类型(包括基本类型和引用类型)。

    ​ 局部变量在使用前必须初始化赋值。

    ​ 变量声明和初始化都是在方法中,方法结束后,变量就会自动销毁。

    2.方法分类

    成员方法:成员方法是定义在类中。这种方法在创建对象的时候创建。

    语法格式:

    修饰符 返回值类型 方法名(参数列表) {
    
        方法体语句;
    
        [return 返回值]
    } 
    

    构造方法:用来创建对象的方法

    构造方法名与类名相同,且没有返回值,且不需要使用void修饰

    构造方法是定义在 Java 类中的一个用来创建对象的方法。

    使用 new + 构造方法 创建一个新的对象。在创建一个对象的时候,至少要调用一个构造方法。

    每个类都有构造方法。如果没有显式地为类定义构造方法,Java将会为该类提供一个默认构造方法,但是只要在一个Java类中定义了一个显示的构造方法后,默认的无参构造方法即失效。

    一个类可以有多个构造方法。

    public class Person{ 
    
      public Person(){ 
      } 
    
      public Person(String name){ 
          // 这个构造方法有一个参数:name 
      } 
    
    }
    

    例:创建Person类的对象

    Person person= new Person();
    
    Person person = new Person("张三")

    6.方法重载

    方法的重载是指同一个类中具有相同的名字,但参数不同的几个方法。

    参数不同(可以有三方面的不同)

    1. 数量不同
    2. 类型不同
    3. 顺序不同

    调用时,会根据不同的参数表选择对应的方法。

    注意:方法重载跟方法的返回值类型没有任何关系

    7.对象与引用

    Java 语言中除基本类型之外的变量类型都称之为引用类型。

    Java中的对象是通过引用对其操作的。

     class Person{    
        String name;
        String age;
    }
    
    Person person= new Person();
    

    创建一个对象包含三个动作:

    1. 右边的“new Person()”,是以Person类为模板,调用Person类的构造方法,在堆空间里创建一个Person类对象。
    2. 左边的“Person person”创建了一个Person类型引用变量。所谓Person类的引用,就是以后可以用来指向Person对象的对象引用。
    3. ”=”操作符使对象引用指向刚创建的那个Person对象。
    Person person;//对象引用变量
                
    person= new Person();//对象本身
    

    new Person(); 这个语句在堆空间里创建了实体,尽管它们也是确确实实存在的实体,但是,我们看不见,也摸不着。

    对象没有名字,也就没法直接访问它。我们需要通过对象引用来间接访问对象。

    对象好比是一只很大的气球,但是我们抓不住它。引用变量是一根绳,可以用来系汽球。

    Person  person1; //创建一根绳子,一根还没有系上任何一个气球的绳;
    
    Person  person2;//又做了一根绳,还没系上气球,
    
    person1 = new Person();//给person1系上气球;
    
    person2 = person1;//这里,发生了复制行为。要说明的是,对象本身并没有被复制,被复制的只是对象引用。
    

    结果是,person2也指向了person1所指向的对象。两根绳系的是同一只气球。

    基本类型和引用类型的区别:

    基本类型

    ​ byte,short,int,long,float,double,char,boolean

    ​ 它的值就是一个数字,一个字符或一个布尔值.

    引用数据类型

    ​ 类,接口,数组

    ​ 它的值是对象在内存空间中的地址,

    值传递与引用传递

    Java中进行方法调用中传递参数时,参数传递有两种

    1. 值传递:(形式参数类型是基本数据类型):方法调用时,实际参数把它的值传递给对应的形式参数,形式参数只是用实际参数的值初始化自己的存储单元内容,是两个不同的存储单元,所以方法执行中形式参数值的改变不影响实际参数的值。
    2. 引用传递:(形参数类型是引用数据类型参数):也称为传地址。方法调用时,实际参数是对象,这时实际参数与形式参数指向同一个地址,在方法执行中,对形式参数的操作实际上就是对实际参数的操作,这个结果在方法结束后被保留了下来,所以方法执行中形式参数的改变将会影响实际参数。

    基本类型传递的是该数据值本身。引用类型传递的是对对象的引用,而不是对象本身 。

    8.static关键字

    概念

    1. static被称为静态,可以用来修饰类的属性,方法,代码块,内部类。
    2. 随着类的加载而加载
    3. 优先于对象存在
    4. 修饰的成员,被所有对象所共享
    5. 可不创建对象,直接被类调用

    static属性

    静态属性是类的所有对象共享的,不管创建了多少个对象,静态属性在内存中只有一个。

    static方法

    可以使用对象调用,也可以直接用类名调用,建议用类名直接调用

    在static方法内部只能访问类的static属性,不能访问类的非static属性,因为static属性先加载。

    因为在类加载的时候加载方法,非static属性还没有加载,如果在静态方法中访问非static属性,该属性找不到。

    代码块

    代码块在类中声明,类似一个没有名称的方法体(代码块),代码分实例块和静态块

    //实例块:每次创建对象时自动调用
    {
    
       //任何符合语法的Java代码
    
    }
    
    //静态块:类加载时自动调用,仅一次,与是否创建对象无关。  
    static {
    
        //任何符合语法的Java代码
    
    }
    

    9.类的加载执行

    在这里插入图片描述

    创建对象时,先执行静态代码块,在执行实例代码块,然后执行构造方法。

    10.包

    包的概念:

    ​ 包就相当于一个文件夹

    包的作用:

    ​ 避免类重名

    ​ 按照不同功能管理类

    ​ 控制访问权限

    包(package)的命名规范:

    在包名中,可以使用 . 号来区分包的级别;包名一般情况下是小写

    1. 第一级 指该项目的类型,如com等,
    2. 第二级 指项目所开发或者运行的公司名称,如:oracle,sun,huawei等
    3. 第三级 指项目的名称。
    4. 第四级 指项目模块的名称。如:filter等表明这个包下类的功能

    包可以更好得管理逻辑相关的类,可以控制不同包之间的访问权限

    导入外部包的类,关键字import

    访问权限修饰符

    Java语言有个权限访问修饰符,权限从大到小依次为:

    1. public :公共权限 修饰类、属性、方法。可以被任意类访问
    2. protected:受保护的权限 修饰属性、方法。可以被同包类访问,如果不是同包类,必须是该类的子类才可以访问。
    3. default:同包权限 修饰类、属性、方法。只能被同包的类访问
    4. private:私有权限 修饰属性、方法。 只能在本类中访问

    11.面向对象语言的三大特征

    1.封装

    封装:有时称之为数据隐藏,将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问

    好处:隐藏类的实现细节,方便加入控制语句,方便修改实现

    具体表现是

    1. 属性使用private权限 (私有的)

    2. 方法使用public权限

      例子:

      public class Person {    
          private String name;    
          private String age;    
          public String getName() {        
              return name;    
          }    
          public void setName(String name) {        
              this.name = name;   
          }   
          public String getAge() {        
              return age;    
          }    
          public void setAge(String age) {        
              this.age = age;    
          }
      }
      
      

    我们可以发现上述代码用到了this关键字,那么什么是this关键字呢?

    this关键字代表自身类的对象

    功能:

    1. 使用this关键字引用成员变量
    2. 使用this关键字引用成员方法

    注意:this关键字必须放在非静态方法里面

    在一个类的方法或构造方法内部,可以使用“this.成员变量名”这样的格式来引用成员变量名,常常用来区分同名的成员变量和局部变量。

    例如上面的:

     this.name = name;   //把局部变量赋值给自己类的成员变量
    

    2.多态

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

    多态的优点

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

    多态存在的三个必要条件

    1. 继承
    2. 重写
    3. 父类引用指向子类对象:Parent p = new Child();(Child类继承了Parent 类)

    当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;如果有,再去调用子类的同名方法。

    多态的好处:可以使程序有良好的扩展,并可以对所有类的对象进行通用处理。

    public class Test {
        public static void main(String[] args) {
            show(new Cat());  
            show(new Dog());  
        }  
        public static void show(Animal a)  {
            a.eat();  
            // 类型判断
            if (a instanceof Cat)  {  
                Cat c = (Cat)a;  //向下转型
                c.work();  
            } else if (a instanceof Dog) { 
                Dog c = (Dog)a;  
                c.work();  
            }  
    	}  
    }
    
    public abstract class Animal {  
        abstract void eat();  
    }  
    
    public class Cat extends Animal {  
        public void eat() {  
            System.out.println("吃鱼");  
        }  
        public void work() {  
            System.out.println("抓老鼠");  
        }  
    }
    
    public class Dog extends Animal {  
        public void eat() {  
            System.out.println("吃骨头");  
        }  
        public void work() {  
            System.out.println("看家");  
        }  
    }
    

    Test中的main方法输出:

    在这里插入图片描述

    同一个方法在不同情况下的表现不同,就是多态的体现。

    3.继承

    继承:继承是面向对象程序设计不可缺少的设计思想,是实现代码可重用的根基,是提高代码可扩展性的主要途径。

    继承是从已有的类中派生出新的类,新的类能吸收已有类的属性和行为,并能扩展新的能力。

    1. 在JAVA中使用extends关键字来表示继承关系。
    2. JAVA不支持多继承,单继承使JAVA的继承关系很简单,一个类只能有一个直接父类。
    3. 继承之后子类可以调用父类的所有非私有属性和非私有方法。

    什么时候使用继承呢?

    当你想用一些非本类的方法或属性时,可以使用继承,继承想使用的那个类,就可以将那个类中的属性方法拿过来用,可以让你少写一些代码。所以继承是代码重用的一种方式

    public class Animal{
    
      public static void eat(){
                System.out.println("动物吃");
            }
    
    }
    public class Dog  extends Animal{
    
     public static   void main(String[] args) {
            Dog dog = new Dog();
            dog.eat();
        }
    
    }
    

    在这里插入图片描述

    专业术语:

    Dog类是 Animal类的子类, Animal类是Dog类的父类(或者是) Dog类是 Animal类的派生类, Animal类是Dog类的基类。

    继承传递性

    C类从B类继承,B类又从A类继承

    那么C类就具有B类和A类的所有非私有的属性和方法

    当一个没有继承任何一个类时,jvm(java虚拟机)会默认让类继承Object类

    Object是 java为所有类提供的基类

    继承中的构造方法

    子类构造方法总是先调用父类构造方法,默认情况下,调用父类无参构造方法

    可以在子类构造方法的第一行,使用super关键字调用父类任意一个构造方法

    如果用super,必须写在方法的第一行

    如果子类的构造方法中没有显式地(使用super)调用基类构造方法,则系统默认调用基类无参数的构造方法。

    为什么要先创建父类:子类创建后需要调用父类的方法,所以在创建子类对象是父类也需要同时被创建.

    我们又提到了一个新的关键字——super

    super关键字用途

    1. super关键字代表父类的引用,在程序中主要的用途

    2. 在子类构造方法中要调用父类的构造方法,需要注意:super语句只能出现在子类构造方法体的第一行

    3. 用“super.成员变量名”来引用父类成员变量

    4. 用“super.方法名(参数列表)”的方式访问父类的方法

    5. 与this的区别,this通常指代当前对象,super通常指代父类

    方法的重写(OverRide)

    在子类中可以根据需要对从基类中继承来的方法进行重写。

    方法重写规则

    1. 方法名相同、参数列表相同;
    2. 返回值类型相同;
    3. 访问权限等于大于父类中方法权限;

    只有方法体不同(大括弧内的代码不同)

    注意构造方法不能重写

    应用场景:

    ​ 当父类的方法实现不能满足子类需求时,可以对方法进行重写( override)

    12.类于类之间的关系

    1.关联关系(has-a)

    对象和对象之间的连接。在Java中,关联关系的代码表现形式为一个类做为另一个类的属性类型存在。

    就是相当于我们在我们的类中定义了一个String类型的属性,那么,我们这个类和String类就是关联关系。

    即“有”的关系:”has-a”。

    关联关系分为单向关联和双向关联

    1. 单向关联: A类关联B类。
    2. 双向关联:A类关联B类,B类关联A类;
    public class Phone {
    
         private  Person per;//手机有主人
    
    }
    
    public  class Person {
    
         private Phone phone;//人拥有手机
    
    }
    

    关联关系的多重性

    一对一关联:一个手机只能有一个主人

    一对多关联:一个人,可以拥有多个手机。

    解决一对多的关联的方案:集合或者数组

    public List<Phone> phoneList;//集合
    public Phone[] phones;//数组
    

    2.依赖关系(uses-a)

    依赖关系是指一个类A使用到了另一个类B,也就是说一个类的方法使用或者操作另一个类的对象

    依赖关系的特性:

    这种关系是具有偶然性的、临时性的、非常弱的,但是类B的变化会影响到类A。

    依赖具体表现

    1. 在代码层面,依赖关系表现为类B作为参数被类A在某个方法中使用

    例:

    public  class Person {
    
          public void travel(Bus bus){}
    
    }
    

    注意

    应该尽量减少类与类之间有这种关系

    3.继承关系(is-a)

    这种关系在上文中有过解释,在这就不赘述了,写在这只是表明类与类还有这种关系。

    本次的分享到这里就结束了,码字不易,如果喜欢,赏个点赞+评论+收藏🤞🤞🤞,感谢您的支持

    文中举例,用词等可能有不当的地方,望谅解,欢迎在评论区批评指正!
    参考书籍:Java核心技术 卷1(11版)
    在这里插入图片描述

    展开全文
  • 面向对象的三个基本特征

    千次阅读 2013-03-29 09:00:41
    封装是面向对象特征之一,是对象概念的主要特性。 封装,也就是把客观事物封装成抽象的,并且可以把自己的数据和方法只让可信的或者对象操作,对不可信的进行信息隐藏。 继承 面向对象编程 (OOP) ...
  • 面向对象特征-多态

    千次阅读 2017-08-01 18:13:20
    1、多态的相关概念 ...动态的多态性是在程序运行过程中才动态的确定操作所针对的对象,因此又称为运行时的多态。动态的多态性是通过虚函数实现的。 2、构成多态的条件: (1)必须要使用关键字v
  • 的作用、对象的关系?

    千次阅读 2020-06-01 09:22:04
    类是封装对象是属性和行为的载体,反过来说,具有相同属性的行为和方法的一类实体被称为类。 二、类的作用 类是对事物的一种抽象定义,将抽象之后的特征和行为有机结合便构成了类,类是具有共同特征和行为的一类事物...
  • JAVA 面向对象 对象

    千次阅读 2016-07-17 15:57:34
    本页面更新日期: 2016年07月17日前言 Java 是面向对象的程序设计语言, Java 语言提供了 定义, 成员变量, 方法 等基本功能.... 用于描述客观世界里 某一类对象的共同特征. 而对象则是 的具体存在. Java
  • Java - 面向对象特征有哪些?

    万次阅读 2019-03-06 20:08:29
    抽象:抽象是将一类对象的共同特征总结出来构造的过程,包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为,并不关注这些行为的细节是什么。 封装:通常认为封装是把数据和操作数据的方法绑定起来,...
  • Java面向对象编程三大特征 - 封装

    千次阅读 多人点赞 2020-03-25 20:45:49
    本文关键字:Java、面向对象、三大特征、封装。封装是面向对象编程中的三大特征之一,在对封装性进行解释时我们有必要先了解一些面向对象的思想,以及相关的概念。
  • java 面向对象特征(详解):

    千次阅读 2019-09-21 15:27:18
    首先阐述面向对象思想概述 概述 ...向对象思想就是在计算机程序设计过程中,参照现实中事物,将事物的属性特征、行为特征抽象出来,描述成计算 机事件的设计思想。 它区别于面向过程思想,强调的...
  • 面向对象特征

    千次阅读 2015-06-30 15:29:01
    1.抽象:抽象就是忽略一个主题中与当前目标无关的那些方面,以便更充分地注意与当前目标有关的方面。...对象的一个新类可以从现有的类中派生,这个过程称为类继承。新类继承了原始类的特性,新类称为原
  • Python定义与创建对象

    千次阅读 2019-08-06 18:12:40
    2. 创建与使用对象对象称为实例) 1)增加或删除实例变量 2)增加实例方法 面向对象编程的三大特征:封装、继承、多态; 1. 定义 语法格式: # 语法格式: class 类名: 执行语句... 变量... 方法....
  • 详细说明面向对象的三大特征。 面向对象 把数据及对数据的操作方法放在一起,作为一个相互依存的整体–对象。对同类对象抽象其共性,形成中的大多数数据,只能在本的方法进行处理。通过一个简单的外部...
  • Java对象

    千次阅读 2019-04-30 11:48:25
    定义:表示一个客观世界中对一具有共同特征的事物的抽象。 =属性+方法。 在中的属性实际上就是相当于一个变量,有时还称为变量或成员。 方法是一些操作的行为。 格式 class 名称(首字母大写) [访问权限...
  • Java面向对象编程三大特征 - 多态

    千次阅读 多人点赞 2020-04-06 11:43:48
    本文关键字:Java、面向对象、三大特征、多态。多态是面向对象编程的三大特征之一,是面向对象思想的终极体现之一。在理解多态之前需要先掌握继承、重写、父类引用指向子类对象的相关概念。
  • C++面向对象的三个基本特征

    千次阅读 2019-09-19 20:00:38
    封装是面向对象特征之一,是对象概念的主要特性. 简单的说,一个就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部,某些代码或某些数据可以是私有的,不能被外界访问。通过这种方式,...
  • 面向对象概念和基本特征

    千次阅读 2018-07-23 16:24:51
    所谓的面向对象就是基于对象概念,以对象为中心,以和继承为构造机制,来认识、理解刻画客观世界和设计、构建相应的软件系统。 OO (Object Oriented, 面向对象)是当前计算机界关心的重点,它是90年代软件开发的...
  • 面向对象特征有哪些?

    千次阅读 2018-12-17 09:41:56
    封装是把对象的状态数据隐藏起来,再通过暴露合适的方法来允许外部程序修改对象的状态数据。Java 的封装主要通过private、protected、public 等访问控制符来实现。 Java中通过将数据声明为私有的(private),再...
  • 对象是实际存在的该事物的每个个体,因此也称为实例; 对象的抽象是的具体化就是对象,也可以说的实例就是对象用来描述一系列对象,概述了每个对象应包括的数据,并概述了每个对象的行为特征。 ...
  • 什么是面向对象,以及什么是对象

    千次阅读 多人点赞 2019-08-11 19:04:04
    什么是面向对象,以及什么是对象 ​ 1.1面向过程与面向对象的区别 ​ 面向对象是一种现在最为流行的程序设计方法 。将面向过程与面向对象进行比较。 ​ 首先这两个种都是一种编程思维, 在一些简单的动作...
  • 面向对象编程的三大特征简述

    千次阅读 2018-01-04 20:38:15
    对象的一个新类可以从现有的类中派生,这个过程称为类继承。新类继 承了原始类的特性,新类称为原始类的派生类(子类),而原始类称为新类的基类(父类)。派生类可以从它的基类那里继承方法和实例变量,并且类可以...
  • Java常考面试题1--面向对象特征

    千次阅读 2017-02-08 16:13:36
    面向对象特征
  • C++中的对象

    千次阅读 多人点赞 2019-06-08 11:38:28
    文章目录C++中的对象抽象和类型C++中的实现成员函数内联方法使用类类的构造函数和析构函数`const`成员函数构造函数和析构函数小结`this`指针对象数组的作用域抽象数据类型 C++中的对象 抽象和 ...
  • java对象的联系,区别

    千次阅读 2017-10-11 17:29:24
    将具有相同属性及相同行为的一组对象称为类。广义地讲,具有共同性质的事物的集合就称为类。 在面向对象程序设计中,类是一个独立的单位,它有一个类名,其内部包括成员变量,用于描述对象的属性;还包括类的成员...
  • 面向对象特征有哪些方面?

    千次阅读 2018-04-12 15:44:54
    答:面向对象特征主要有以下几个方面:- 抽象:抽象是将一类对象的共同特征总结出来构造的过程,包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为,并不关注这些行为的细节是什么。- 继承:继承是...
  • Python 面向对象三大特征

    千次阅读 2018-05-18 20:51:51
    一、 面向对象三大特征--封装面向对象的程序设计中,某个类把所需要的数据(也可以说是类的属性)和对数据的操作(也可以说是类的行为)全部都封装在类中,分别称为类的成员变量和方法(或成员函数)。这种把成员...
  • 面向对象——三大基本特征

    万次阅读 多人点赞 2018-06-15 13:24:57
    面向对象的三大基本特征:封装、继承和多态 一、封装 利用抽象数据类型将数据和基于数据的操作封装在一起,使其构成一个不可分割的独立实体。数据被保护在抽象数据类型的内部,尽可能地隐藏内部的细节,只保留一些...
  • [C/C++]详解C++的对象

    万次阅读 多人点赞 2021-05-24 13:09:01
    对象是具有类型的变量。对象是面向对象编程技术中的最基本的概念。 1.面向对象 首先来理解什么是面向对象编程。 C语言是面向过程的,关注的是过程,分析出求解问题的步骤,通过函数调用逐步解决问题。 C++是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 167,973
精华内容 67,189
关键字:

对象的特征称为类的