2020-11-04 内部类、接口、拷贝、异常

hashcode()和equals();

https://blog.csdn.net/kangkanglou/article/details/78954894

• 如果两个对象相同，则他们的哈希值（hashcode）一定相同

• 如果两个对象的哈希值相同（hashcode）相同，并不意味着他们是相同的。

• 对于使用Hash散列方式存储对象的数据结构：*HashSet、HashMap、HashTable*等，仅仅重载equals方法可能会导致实际业务逻辑失败

• 在比较两个对象时，仅重载hashCode方法并不能强制Java忽略内存地址。

Integer

https://www.jianshu.com/p/9cb9c61b0986

 

一、内部类

内部类是一个定义在另一类中的类。

java为什么会有内部类，原因就是java摒弃了多继承，内部类在一定程度上解决了java多继承的问题。

• 内部类可以访问主类中的所有属性

• 内部类可以把统一类中的其他属性隐藏起来，增强封装的特性。

内部类不能有static方法。

二、局部内部类 定义在一个方法体或者内部块中

若有static修饰那就是类级，否则就是对象级

静态内部类中的方法可以用static修饰

非静态内部类不能使用static修饰对象

 

内部类是生命在其他类中的内嵌内省，包含内嵌类型的类或者接口称为外层接口。

public class Pixel
{
  public static interface ColorConstant
  public static class extends Object implements ColorConstant
}

1.内嵌类型不能与外层类型同名

2.内部类中可以声明成员变量和成员方法，内部类成员可以与外部类成员同名：内部接口中可以声明成员常量和抽象成员方法。

3.可以生命内部类为抽象类，但该内部类必须被其他内部类所继承。

内部类

1.普通内部类

常规内部类：常规内部类没有用static修饰且定义在在外部类类体中。

1. 常规内部类中的方法可以直接使用外部类的实例变量和实例方法。

2. 在常规内部类中可以直接用内部类创建对象

   public class MyOuter {
       private int x = 100;
     
       //内部类
       class MyInner{
           private String y="Hello!";
           public void innerMethod(){
               System.out.println("内部类中 String ="+y);
               System.out.println("外部类中的x ="+x);
               outerMethod();
               System.out.println("x is "+MyOuter.this.x);
           }
       }
       public void outerMethod(){
           x++;
       }
       public void makeInner(){
           //在外部类方法中创建内部类实例
           MyInner in = new MyInner();
       }
        
       public static void main(String[] args){
           MyOuter mo = new MyOuter();
           //使用外部类构造方法创建 mo 常规内部类需要通过外部类实例来new
           MyOuter.MyInner inner = mo.new MyInner();
           inner.innerMethod();
       }
   }

2.静态内部类

静态内部类：与类的其他成员相似，可以用static修饰内部类，这样的类称为静态内类。静态内部类与静态内部方法相似，只能访问外部类的static成员，不能直接访问外部类的实例变量，与实例方法，只有通过对象引用才能访问。

public class MyOuter2 {    
    public static int x=100;     
    //内部类
    public static class Myinner{
        private String y="Hello!";
        /**
         * 由于static内部类不具有任何对外部类实例的引用，
         * 因此static内部类中不能使用this关键字来访问外部类中的实例成员，
         * 但是可以访问外部类中的static成员。这与一般类的static方法相通
         */
        public void innerMethod(){
            System.out.println("x="+x);
            System.out.println("y="+y);
        }
    }
    public static void main(String[] args){
        MyOuter2.Myinner si = new MyOuter2.Myinner();
        si.innerMethod();
    }
}

3.局部内部类

局部内部类：在方法体或语句块（包括方法、构造方法、局部块或静态初始化块）内部定义的类成为局部内部类。 局部内部类不能加任何访问修饰符，因为它只对局部块有效。

1. 局部内部类只在方法体中有效，就想定义的局部变量一样，在定义的方法体外不能创建局部内部类的对象

2. 在方法内部定义类时，应注意以下问题： 2.1 方法定义局部内部类同方法定义局部变量一样，不能使用private、protected、public等访问修饰说明符修饰，也不能使用static修饰，但可以使用final和 abstract修饰 2.2方法中的内部类可以访问外部类成员。对于方法的参数和局部变量，必须有final修饰才可以访问。 2.3static方法中定义的内部类可以访问外部类定义的static成员

 public class Person {
    //人在出生的时候选择性别
    private static String[] sex = {"男性","女性"};
 
    public void print() {
        class People {
            private String name = "xiaoming";
            public void print() {
                System.out.println("hello world");
            }
        }
        People people = new People();
        people.print();
    }
}

局部内部类有以下特性：

1.不能使用public、private、protected、static等这些修饰符

2.局部内部类只能在当前方方法中使用，作用域范围仅限于当前方法中

3.局部内部类和成员内部类一样，不能拥有静态成员，但可以访问外部成员的所有变量

4.局部内部类访问的局部变量必须使用fianl修饰，在jdk8中自动隐士的加上了final,但是依然是常量，值不能被改变（不知道为什么）

为什么不推荐使用局部内部类？

如果当前方法不是main方法，那么当前方法调用完毕之后，当前方法的栈帧就会被销毁，方法内部的局部变量的空间也会被销

4.匿名内部类

定义类的最终目的是创建一个类的实例，但是如果某个类的实例只是用一次，则可以将类的定义与类的创建，放到与一起完成，或者说在定义类的同时就创建一个类以这种方法定义的没有名字的类成为匿名内部类。 声明和构造匿名内部类的一般格式如下：

 

http://blog.csdn.net/guyuealian/article/details/51981163

匿名内部类也就是没有名字的内部类正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写，但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口，但最多只能继承一个父类，或实现一个接口。 关于匿名内部类还有如下两条规则： 1）匿名内部类不能是抽象类，因为系统在创建匿名内部类的时候，会立即创建内部类的对象。因此不允许将匿名内部类定义成抽象类。 2）匿名内部类不等定义构造器（构造方法），因为匿名内部类没有类名，所以无法定义构造器，但匿名内部类可以定义实例初始化块，

怎样判断一个匿名类的存在啊？看不见名字，感觉只是父类new出一个对象而已，没有匿名类的名字。 先看段伪代码

接口

1.为什么java使用接口？

有时候必须从几个类当中派生出一个子类，继承他们所有的属性和方法，但是java不支持多重继承于是就有了接口

接口的特征

1.接口用interface实现

2.接口中所有的成员变量都是由public static final修饰的

3.接口中的所有方法默认都是public abstract修饰的

4.接口没有构造方法，构造方法用于创建对象（接口没办法new对象），但是可以使用多态

5.实现接口类中，必须实现接口中的所有方法

6.接口和接口之间可以互相继承

7.与继承关系类似，接口与实现类之间存在多态性

接口的好处：

1.降低耦合度

2.提高程序的可扩展性

比如项目需要做一个订单模块，首先后端leader创建了一个订单的接口（定义了规范），然后把该接口具体怎么实现交给了小a来做，小a开始进行实现类的编写（接口的第一个实现类），但是过了很久以后，后端leader觉得小a写的这个实现类不太满意，想找人重新写订单模块。那么此时，接口的可扩展性就体现了出来，领导找到了小b，而小b只需要根据该接口重新创建一个类（接口的第二个实现类），并将该订单接口定义的所有方法重新实现一遍，就达到了重写订单模块的目的。而项目其他部分对订单模块的引用并不受到影响，因为其他模块对订单模块引用的是“接口”，而不是具体的实现类。

 

接口和抽象类的异同

相同点

(1) 都可以被继承 (2) 都不能被实例化 (3) 都可以包含方法声明 (4) 都可以通过重写实现方法

不同点

1.接口比抽象类更加抽象,抽象类中可以定义构造方法(构造器),可以有抽象方法和具体方法,

而接口中的方法全部都是抽象方法(接口中也可以没有方法,这样的接口称为空接口)

2.抽象类中的方法可以是private,protected,public,接口全部都是由public static final修饰的

3.抽象类中可以定义成员变量,而接口中定义的成员变量实际上都是常量( static final)

4.接口支持多继承；抽象类不能实现多继承。

5.抽象类可以有构造方法，接口中不能有构造方法。

6.抽象类的子类必须实现抽象类的全部抽象方法，而实现接口的类必须实现接口的所有方法。

抽象类

• \1. 抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。

• \2. 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

• \3. 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。

• \4. 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。

• \5. 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

  1.如果一个函数没有方法体，那么该函数必须要使用abstract修饰，把该函数修饰成抽象的函数。

  2.如果一个类出现了抽象的函数，那么该类也必须使用abstract修饰。

  3.如果一个非抽象类继承了抽象类，那么必须要把抽象类的所有抽象方法全部实现。

  4.抽象类可以存在抽象方法，也可以存在非抽象方法，还可以不存在抽象方法，但是这样没任何意义，Java是不写废话的。

  5.抽象类是不能实例化对象的

  6.抽象类是存在构造函数的，其构造函数是提供给子类创建对象的时候初始化父类的属性的。

• 为什么抽象类不能实例化对象？

  因为抽象类是存在抽象方法的，如果能让抽象类创建对象的话，那么使用抽象类的对象调用抽象方法是没有任何意义的。

  为什么抽象类不能实例化对象？

  因为抽象类是存在抽象方法的，如果能让抽象类创建对象的话，那么使用抽象类的对象调用抽象方法是没有任何意义的。

深拷贝 浅拷贝

1.浅拷贝只拷贝了对象的地址

2.深拷贝中的被引用的类是无法被clone的。

1.Object中的baiclone执行的时候使用了RTTI（run-time type identification）的机制,动态得du找到目前正在调用clone方法的那zhi个reference，根据它的大小申请内存空间，然后进dao行bitwise的复制，将该对象的内存空间完全复制到新的空间中去，从而达到shallowcopy的目的。 所以你调用super.clone() 得到的是当前调用类的副本，而不是父类的副本。根本没有必用调用this.clone(); 2.要让实例调用clone方法就需要让此类实现Cloneable接口，API里面还有句话是：如果在没有实现 Cloneable 接口的实例上调用 Object 的 clone 方法，则会导致抛出 CloneNotSupportedException 异常，这便是“合法”的含义。 但请注意，Cloneable接口只是个标签接口，不含任何需要实现的方法，就像Serializable接口一样。 总之，一般如果你的子类没有特殊需要而重写clone()方法就直接用super.clone() 就行了。

异常类

 

受检异常 非受检异常