精华内容
下载资源
问答
  • 1.wait和notify不仅仅是普通方法或同步工具,更重要是它们是Java中两个线程之间通信机制 。对语言设计者而言,如果不能通过Java关键字(例如synchronized)实现此通信机制,同时又要确保这个机...

    分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!请点击http://www.captainbed.net

    以下是我认为有意义的一些想法:

    1.wait和notify不仅仅是普通方法或同步工具,更重要的是它们是Java中两个线程之间的通信机制 。对语言设计者而言,如果不能通过Java关键字(例如synchronized)实现此通信机制,同时又要确保这个机制对每个对象可用,那么Object类则是正确的声明位置。记住同步和等待、通知是两个不同的领域,不要把它们看成是相同的或相关的。同步是提供互斥并确保Java类的线程安全,而wait和notify是两个线程之间的通信机制。

    2.每个对象都可上锁,这是在Object类而不是Thread类中声明wait和notify的另一个原因。

    3.在Java中为了进入代码的临界区,线程需要锁定并等待锁定,他们不知道哪些线程持有锁,而只是知道锁被某个线程持有,并且他们应该等待取得锁,而不是去了解哪个线程在同步块内,并请求它们释放锁定。

    4.Java是基于监视器的思想,在Java中,所有对象都有一个监视器。

    线程在监视器上等待,为执行等待,我们需要2个参数:

    • 一个线程
    • 一个监视器(任何对象)

    在Java设计中,线程不能被指定,它总是运行当前代码的线程。但是,我们可以指定监视器(这是我们称之为等待的对象)。这是一个很好的设计,因为如果我们可以让任何其他线程在所需的监视器上等待,这将导致“入侵”,导致在设计并发程序时会遇到困难。请记住,在Java中,所有在另一个线程的执行中侵入的操作都被弃用了(例如stop方法)。

    展开全文
  • 1.类的每个实例本质上都是唯一的,对于代表活动实体而不是值的类确实如此,例如Thread.2.不关心类是否提供了“逻辑相等”的测试功能3.超类已经覆盖了equals,从超类继承过来的行为对子类也是合适的4.类是私有的或者包...

    第八条 在改写equals的时候请遵守通用约定

    一般以下几种情况,不适宜覆盖equals方法
    1.类的每个实例本质上都是唯一的,对于代表活动实体而不是值的类确实如此,例如Thread.

    2.不关心类是否提供了“逻辑相等”的测试功能

    3.超类已经覆盖了equals,从超类继承过来的行为对子类也是合适的

    4.类是私有的或者包级私有的,可以确定它的equals方法永远不会被调用。

    那什么情况应该覆盖Object.equals呢?如果类具有自己特有的“逻辑相等”的概念(不同于对象等同的概念),而且超类没有覆盖equals以实现期望的行为,就需要进行覆盖,这通常属于“值类”的情形,例如Integer和Date。当使用equals来比较对象, 是希望他们在逻辑上是否相等, 而不是指向同一对象, 或者用来作为Map的key以及集合Set中的元素时, 就必须复写equals方法.

    实例受控,确保“每个值最多只存在一个对象”的类,枚举通常属于这种类型。对于枚举类型来说, 逻辑相等与对象相等是同一回事, 因此不需要覆盖equals方法。

    equals的改写规范:
    1)自反性:对于任何非null的引用值x,x.equals(x)一定为true
    2)对称性:对于任何非null的引用值x和y,当且仅当x.dquals(y)为true;那么y.equals(x)也必须为true
    3)传递性:对于任何非null的引用值x和y和z,如果x.equals(y)为true,y.equals(z);那么x.equals(x)也必须为true
    4)一致性:对于任何非null的引用值x和y,如果用于equals比较的对象信息没有被修改的话,那么多次调用x.dquals(y)返回的值是一致的
    5)对于非null引用值x,x.equals(null)一定返回false

    接下来是逐一解析上面几个原则:
    2)对称性

    public final class CaseInsensitiveString {
        private final String s;
    
        public CaseInsensitiveString(String s) {
            if (s == null)
                throw new NullPointerException();
            this.s = s;
        }
    
        // Broken - violates symmetry!
        @Override
        public boolean equals(Object o) {
            if (o instanceof CaseInsensitiveString)
                return s.equalsIgnoreCase(((CaseInsensitiveString) o).s);
            if (o instanceof String) // One-way interoperability!
                return s.equalsIgnoreCase((String) o);
            return false;
        }
    
        // This version is correct.
        // @Override public boolean equals(Object o) {
        // return o instanceof CaseInsensitiveString &&
        // ((CaseInsensitiveString) o).s.equalsIgnoreCase(s);
        // }
    
        public static void main(String[] args) {
            CaseInsensitiveString cis = new CaseInsensitiveString("Polish");
            String s = "polish";
            System.out.println(cis.equals(s) + "  " + s.equals(cis));
        }
    }
    

    上面代码中的equals企图和String进行比较操作,假设我们有一个不区分大小的字符串和一个普通的字符串:

      CaseInsensitiveString cis = new CaseInsensitiveString("Test");
            String s = "test";

    此时cis.equals(s)会返回true,CaseInsensitiveString 类中做了兼容大小写的处理,但是String 的equals方法是不知道要不区分大小写1的,所以s.equals(cis)会返回false,违反了自反性

    假如你把CaseInsensitiveString 放到一个集合中

    List<CaseInsensitiveString> list = new ArrayList<>();
            list.add(cis);
            list.contains(s);

    list.contains(s)有可能返回true,也可能是false,甚至会抛出RumtimeException

    为了解决这个问题,只要企图与String互操作的这段代码从equals去掉即可

    @Override
        public boolean equals(Object o) {
            return o instanceof CaseInsensitiveString&&s.equalsIgnoreCase(((CaseInsensitiveString) o).s);
    
        }

    3)传递性:
    首先以一个简单不可变的二维整形Point类作为开始

    展开全文
  • JavaScript 在 1997 年被标准化时,就有 6 种数据类型,直到 ES6 出现之前,程序中变量一定是以下 6 种数据类型之一:  Undefined  Null  Boolean  Number  String  Object 每种数据类型都是一系列值组合...
  • 我有以下两个:class A(object):def __init__(self, i):self.i = iclass B(object):def __init__(self, j):self.j = jclass C(A, B):def __init__(self):super(C, self).__init__(self, 4)c = C()c只会设置i属性,...

    比方说,我有以下两个类:

    class A(object):

    def __init__(self, i):

    self.i = i

    class B(object):

    def __init__(self, j):

    self.j = j

    class C(A, B):

    def __init__(self):

    super(C, self).__init__(self, 4)

    c = C()

    c只会设置i属性,而不是j.

    我应该写什么来设置两个属性/只有j属性?

    解决方法:

    如果只想设置j属性,则只调用B .__ init__:

    class C(A, B):

    def __init__(self):

    B.__init__(self,4)

    如果你想手动调用A和B的__init__方法,那么

    当然你可以这样做:

    class C(A, B):

    def __init__(self):

    A.__init__(self,4)

    B.__init__(self,4)

    使用super是a bit tricky(特别是,参见标题为“Argument passing,argh!”的部分).如果你仍然想使用super,这是你可以做到的一种方法:

    class D(object):

    def __init__(self, i):

    pass

    class A(D):

    def __init__(self, i):

    super(A,self).__init__(i)

    self.i = i

    class B(D):

    def __init__(self, j):

    super(B,self).__init__(j)

    self.j = j

    class C(A, B):

    def __init__(self):

    super(C, self).__init__(4)

    c = C()

    print(c.i,c.j)

    # (4, 4)

    标签:python

    来源: https://codeday.me/bug/20190526/1158134.html

    展开全文
  • 抽象工厂还有另外一个关键要点,是因为 SimpleFactory内,生产Sample和生产Sample2的方法之间有一定联系,所以才要将这两个方法捆绑在一个中,这个工厂有其本身特征,也许制造过程是统一的,比如:制造工艺比较...
  • Java 对象和

    2020-06-14 21:28:03
    Java作为一种面向对象语言。...下图中男孩(boy)、女孩(girl)为类(class),而具体的每个人为该类的对象(object): Java中的对象 现在让我们深入了解什么是对象。看看周围真实的世界,会发现身边有

    Java作为一种面向对象语言。支持以下基本概念:
    多态
    继承
    封装
    抽象

    对象
    实例
    方法
    重载
    本节我们重点研究对象和类的概念。
    对象:对象是类的一个实例(对象不是找个女朋友),有状态和行为。例如,一条狗是一个对象,它的状态有:颜色、名字、品种;行为有:摇尾巴、叫、吃等。
    :类是一个模板,它描述一类对象的行为和状态。下图中男孩(boy)、女孩(girl)为类(class),而具体的每个人为该类的对象(object):
    在这里插入图片描述

    Java中的对象

    现在让我们深入了解什么是对象。看看周围真实的世界,会发现身边有很多对象,车,狗,人等等。所有这些对象都有自己的状态和行为。
    拿一条狗来举例,它的状态有:名字、品种、颜色,行为有:叫、摇尾巴和跑。
    对比现实对象软件对象,它们之间十分相似。
    软件对象也有状态和行为。软件对象的状态就是属性,行为通过方法体现。
    在软件开发中,方法操作对象内部状态的改变,对象的相互调用也是通过方法来完成。

    Java中的类

    类可以看成是创建Java对象的模板。
    通过下面一个简单的类来理解下Java中类的定义:

    public class Dog{
      String breed;
      int age;
      String color;
      void barking(){
      }
     
      void hungry(){
      }
     
      void sleeping(){
      }
    }
    

    一个类可以包含以下类型变量:

    局部变量:在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中,方法结束后,变量就会自动销毁。
    成员变量:成员变量是定义在类中,方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
    类变量:类变量也声明在类中,方法体之外,但必须声明为static类型。
    一个类可以拥有多个方法,在上面的例子中:barking()、hungry()和sleeping()都是Dog类的方法。

    创建对象

    对象是根据类创建的。在Java中,使用关键字new来创建一个新的对象。创建对象需要以下三步:
    声明:声明一个对象,包括对象名称对象类型
    实例化:使用关键字new来创建一个对象。
    初始化:使用new创建对象时,会调用构造方法初始化对象。
    下面是一个创建对象的例子:

    public class Puppy{
       public Puppy(String name){
          //这个构造器仅有一个参数:name
          System.out.println("小狗的名字是 : " + name ); 
       }
       public static void main(String[] args){
          // 下面的语句将创建一个Puppy对象
          Puppy myPuppy = new Puppy( "tommy" );
       }
    }
    

    访问实例变量和方法

    通过已创建的对象来访问成员变量和成员方法,如下所示:

    /* 实例化对象 */
    Object referenceVariable = new Constructor();
    /* 访问类中的变量 */
    referenceVariable.variableName;
    /* 访问类中的方法 */
    referenceVariable.methodName();
    

    实例

    下面的例子展示如何访问实例变量和调用成员方法:

    public class Puppy{
       int puppyAge;
       public Puppy(String name){
          // 这个构造器仅有一个参数:name
          System.out.println("小狗的名字是 : " + name ); 
       }
     
       public void setAge( int age ){
           puppyAge = age;
       }
     
       public int getAge( ){
           System.out.println("小狗的年龄为 : " + puppyAge ); 
           return puppyAge;
       }
     
       public static void main(String[] args){
          /* 创建对象 */
          Puppy myPuppy = new Puppy( "tommy" );
          /* 通过方法来设定age */
          myPuppy.setAge( 2 );
          /* 调用另一个方法获取age */
          myPuppy.getAge( );
          /*你也可以像下面这样访问成员变量 */
          System.out.println("变量值 : " + myPuppy.puppyAge ); 
       }
    }
    

    源文件声明规则

    在本节的最后部分,我们将学习源文件的声明规则。当在一个源文件中定义多个类,并且还有import语句和package语句时,要特别注意这些规则。

    一个源文件中只能有一个public类
    一个源文件可以有多个非public类
    **源文件的名称应该和public类的类名保持一致。**例如:源文件中public类的类名是Employee,那么源文件应该命名为Employee.java。
    如果一个类定义在某个包中,那么package语句应该在源文件的首行。
    如果源文件包含import语句,那么应该放在package语句和类定义之间。如果没有package语句,那么import语句应该在源文件中最前面。
    import语句和package语句对源文件中定义的所有类都有效。在同一源文件中,不能给不同的类不同的包声明。
    **类有若干种访问级别,并且类也分不同的类型:抽象类和final类等。**这些将在访问控制章节介绍。

    除了上面提到的几种类型,Java还有一些特殊的类,如:内部类、匿名类。

    Java包

    包主要用来对类和接口进行分类。当开发Java程序时,可能编写成百上千的类,因此很有必要对类和接口进行分类。

    Import语句

    在Java中,如果给出一个完整的限定名,包括包名、类名,那么Java编译器就可以很容易地定位到源代码或者类。Import语句就是用来提供一个合理的路径,使得编译器可以找到某个类。

    例如,下面的命令行将会命令编译器载入java_installation/java/io路径下的所有类

    import java.io.*;
    

    一个简单的例子

    在该例子中,我们创建两个类:EmployeeEmployeeTest
    首先打开文本编辑器,把下面的代码粘贴进去。注意将文件保存为 Employee.java。
    Employee类有四个成员变量:nameagedesignationsalary。该类显式声明了一个构造方法,该方法只有一个参数。

    import java.io.*;
     
    public class Employee{
       String name;
       int age;
       String designation;
       double salary;
       // Employee 类的构造器
       public Employee(String name){
          this.name = name;
       }
       // 设置age的值
       public void empAge(int empAge){
          age =  empAge;
       }
       /* 设置designation的值*/
       public void empDesignation(String empDesig){
          designation = empDesig;
       }
       /* 设置salary的值*/
       public void empSalary(double empSalary){
          salary = empSalary;
       }
       /* 打印信息 */
       public void printEmployee(){
          System.out.println("名字:"+ name );
          System.out.println("年龄:" + age );
          System.out.println("职位:" + designation );
          System.out.println("薪水:" + salary);
       }
    }
    

    程序都是从main方法开始执行。为了能运行这个程序,必须包含main方法并且创建一个实例对象。
    下面给出EmployeeTest类,该类实例化2个 Employee 类的实例,并调用方法设置变量的值。
    将下面的代码保存在 EmployeeTest.java文件中。

    import java.io.*;
    public class EmployeeTest{
     
       public static void main(String[] args){
          /* 使用构造器创建两个对象 */
          Employee empOne = new Employee("RUNOOB1");
          Employee empTwo = new Employee("RUNOOB2");
     
          // 调用这两个对象的成员方法
          empOne.empAge(26);
          empOne.empDesignation("高级程序员");
          empOne.empSalary(1000);
          empOne.printEmployee();
     
          empTwo.empAge(21);
          empTwo.empDesignation("菜鸟程序员");
          empTwo.empSalary(500);
          empTwo.printEmployee();
       }
    }
    
    展开全文
  • 除这些重载以外,除 ExecuteXmlReader 之外的其他方法还提供了另一种重载:允许将连接信息作为连接字符串而不是连接对象来传递,如下面的方法签名所示: [Visual Basic] Execute* (ByVal connectionString As String...
  • 什么是类和对象? Java作为一种面向对象语言。支持以下基本概念: 多态 继承 ... 下图中男孩(boy)、女孩(girl)为类(class),而具体的每个人为该类的对象(object): 下图中汽车为类(cla.
  • Java 对象和类 Java作为一种面向对象语言。支持以下基本概念: ...下图中男孩(boy)、女孩(girl)为类(class),而具体的每个人为该类的对象(object): Java中的对象 现在让我们深入了解什么是对象。看看周
  • //建立自己新建的类的对象my1 if(my1.exec()==QDialog::Accepted) //利用Accepted 信号判 断enterBtn 是否被按下 { w.show(); //如果被按下,显示主窗口 return a.exec(); //程序一直执行,直到主窗口 关闭 } else ...
  • 什么是EAP异步编程模式 EAP基于事件的异步模式是.net 2.0提出来的,实现了基于事件的异步模式的将具有一个或者多个以Async为后缀的方法和对应的Completed事件,并且这些都支持异步方法的取消、进度报告和报告...
  • wait是Object类的方法,对此对象调用wait方法导致本线程放弃对象锁,进入等待此对象的等待锁定池,只有针对此对象发出notify方法(或notifyAll)后本线程才进入对象锁定池准备获得对象锁进入运行状态。 17、...
  • 一、为什么需要装箱和拆箱?...把一个基本类型包装成对应的包装器对象,有以下三点好处:一是包装器对象具有很多可以调用的方法;二是Java向面像对象语言的靠近。其实Java还不算是很纯的面向对象的语言。真正的...
  • 一、为什么需要装箱和拆箱?  基础数据类型是数据,不是对象,也不是Object的子类。Java为每种基本数据类型都提供了...一是包装器对象具有很多可以调用的方法; 二是Java向面像对象语言的靠近。其实Java还不...
  • 在Delphi中,对对象的调用实际上采用了两个步骤,首先是把对象地址放入eax寄存器中,然后call类方法,所以如果不使用继承类增加数据的话,用父类调用继承类的方法是没问题的,所以其实这样的方法在D7中也可以使用,...
  •  我要向大家介绍的最重要的经验是充分利用SQL的面向集合的方法来解决数据库处理需求,而不是使用Java等过程化的编程语言。  如果编程人员要在一个表中查找许多行,结果中的每个行都会查找其他表中的数据,最后,...
  • <div><p>程序员这行如果想一直做下去,那么持续学习是必不可少的。...这是因为无状态组件没有更新的方法。 因此搜索了下 react-hot-loader 的工作原理,发现官方同样给出了一份文档:...
  • Java语言中忽视细节

    2011-09-04 11:24:00
     ①为了获取对象的一份拷贝,我们可以利用Object类的clone()方法。  ②在派生类中覆盖基类的clone()方法,并声明为public。  ③在派生类的clone()方法中,调用super.clone()。  ④在派生类中实现Cloneable接口。...
  • 大多人已经习惯了基于类的面向对象编程(OOP),所以面对JavaScript面向对象时显得无从下手。 在网上对JavaScript还有另一种评价——“JavaScript是一种基于(object-based)对象的...
  • Node.js关于Stream理解

    2020-12-08 19:35:53
    本文不是翻译node.jsstreamAPI,而是对学习过程中遇到问题做一些梳理。 为什么要使用流? 想象一个场景,你在程序中,拷贝一个文件内容到另外一个文件中。我们可能会这么做 ...
  • 2020-07-31

    2020-07-31 08:39:32
    支持以下基本概念:多态继承封装抽象类对象实例方法重载本节我们重点研究对象和类的概念。对象:对象是类的一个实例(对象不是找个女朋友),有状态和行为。例如,一条狗是一个对象,它的状态有:颜色、名字、品种;...
  • java 面试题 总结

    2009-09-16 08:45:34
    wait是Object类的方法,对此对象调用wait方法导致本线程放弃对象锁,进入等待此对象的等待锁定池,只有针对此对象发出notify方法(或notifyAll)后本线程才进入对象锁定池准备获得对象锁进入运行状态。 14、Overload...
  • 一般情况下,如果对于一个类的两个对象,我们想要关注的是它的值是否相等,而不是是否指向同一个类,就可以这么做。但是如果使用了单例模式。在覆盖equals方法时,应注意以下的规范,这些规范不是必须的,但是如果...
  • java面试宝典

    2013-02-28 16:04:01
    95、以下哪些属于Session的方法?(A,B,C,D,F) 22 96、Hibernate工作原理及为什么要用? 22 97、Hibernate是如何延迟加载? 22 98、Hibernate中怎样实现之间的关系?(如:一对多、多对多的关系) 22 99、说下Hibernate...
  • 千方百计笔试题大全

    2011-11-30 21:58:33
    95、以下哪些属于Session的方法?(A,B,C,D,F) 22 96、Hibernate工作原理及为什么要用? 22 97、Hibernate是如何延迟加载? 22 98、Hibernate中怎样实现之间的关系?(如:一对多、多对多的关系) 22 99、说下Hibernate...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 129
精华内容 51
关键字:

以下什么不是object类的方法