java内容整理（一）

最新推荐文章于 2021-02-15 13:37:38 发布

奔跑的蜗牛蒋

最新推荐文章于 2021-02-15 13:37:38 发布

阅读量889

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/xhjj520/article/details/79691097

版权

java 专栏收录该内容

64 篇文章 1 订阅

订阅专栏

1、类修饰符

和访问权限有关:

public：表示该类在项目中所有类中可以被导入；

默认类：表示该类只能在同一个package中使用；

final :不能被继承的类

abstract:抽象类

2、成员修饰符

public：该类在项目中所有类可被导入

private:该类只能在被自身访问，只修饰内部类

protected：类本身和子类，即使子类在不同的包中也可以访问

package：同一包，无任何修饰符

final:赋值后无法改变

static:静态字段，被所有类共享，只有一个。

3、方法修饰符

abstract：抽象方法的方法体没有在类中定义，是由参数列表后面的分号替代，其实现由子类负责；

static：可以用类直接调用，只能访问类中的静态标量，和其他静态函数。

final：final的子类不能被覆盖

synchronized：并发控制线程有关

native：非java语言编写的方法

严格浮点：strictfp

抽象方法不能是static、final、synchronized、native和严格浮点的。native不能是严格浮点的。

重载：在同一类中，两个方法只要具有不同的类型或数量的参数。具有相同的函数名。

在Java中，所有的继承都是公有继承。即父类中的所有属性和方法，不管是用什么访问修饰符修饰，都被子类继承了。这就是公有继承含义所在吧。而对于覆写（重写，override）来说，只要在子类中，父类的属性或方法可见，则子类就可以选择覆写父类中的属性或方法。（属性被覆写的话，可能体现在不同子类中的属性初始值应该不一样的情况下吧）

类中的静态成员不可以被覆盖，只能被隐藏。

注意：但是父类中的私有方法是不能被子类覆写的。

*非静态方法属于类的实例，是可以被子类重写，从而达到多态的效果；
静态方法属于类，是不能被重写，故而也不能实现多态。*

重写：若子类中的方法与父类中的方法具有相同的方法名，子类中的返回值可以是父类函数返回值的子类，子类的访问权限不能少于父类，则将覆盖原来的方法。

字段不可以被覆盖只能被隐藏，如果再类中声明了与超类中某个字段同名的字段，那么虽然

超类的字段仍然存在，但是简单名已经无法直接访问，必须用super（）或超类类型的另一个

引用来访问。

成员方法是由对象的实际类而不是引用类型决定，而字段是由引用的类型决定。

java的编程语言是强类型的，需要在编译器检查类型的兼容性。

如果得到对超类的引用需要将其使用显示的强制类型转换。

object类：是整个类层次结构的根，因此object类型的变量可以引用任何对象。

object中定义了大量的可以被所有对象继承的方法，主要是通用方法和支持线程的方法。

public boolean equals(object obj):比较接收参数的对象和由obj引用的对象的等价性，如果又有相同的值

则返回true，否则返回false。如果想确定两个引用是否所指向的对象是否相同，可以通过==或！=来比较。

equals方法关系的是值的等价性。object中的equals的默认实现是this==obj的结果。

public int hashCode（）：返回该对象的散列码，默认返回的是一个有别于其他不同对象的值，在把对象保存到散列集合中，

就需要用到该方法。

protected object clone() throws cloneNotSupportedException:返回当前对象的一个克隆体。克隆体是一个新对象，它

是被调用了clone方法的对象的副本。

public final class<?> getClass():返回表示该对象所属类的类型标记。

protected void finalize() throws throwable:在垃圾回收时终结对象。

public stringtoString（）：返回一个该对象的字符串表示，当对象引用作为+操作符的操作运算的时候，该方法会

隐式的调用toString方法。返回所属对象的类名+@+一个十六进制的散列码表示。

如果想要实现有别于object中默认的等价性，就要覆盖hashCode和equals（）方法。

 protected native Object clone() throws CloneNotSupportedException;

protected Object clone() throws CloneNotSupportedException {  
    if (!(this instanceof Cloneable)) {  
        throw new CloneNotSupportedException("Class doesn't implement Cloneable");  
    }  
  
    return internalClone((Cloneable) this);  
}

clone方法首先会判断对象是否实现了cloneable借口，若无则抛出clonenotsupportexception，最后会调用clone。interlClone

，一般来说native方法的执行效率高于非native方法。

浅克隆

克隆就是复制一个对象的副本，若只需要复制对象的字段值（对于基本数据类型：如int，float则复制值，

对于复合数据类型仅复制该字段值，如数组变量则复制地址，对于对象变量则复制对象的reference）

可以看出，基本类型可以使用浅克隆，而对于引用类型，由于引用的是内容相同，所以改变c2实例对象中的属性就会影响到c

深克隆与浅克隆的区别在于对复合数据类型的复制。若对象中的某个字段为复合类型，在克隆对象的时候，需要为该字段重新创建一个对象。

克隆方法用于创建对象的拷贝，为了使用clone方法，类必须实现java.lang.Cloneable接口重写protected方法clone，如果没有实现Clonebale接口会抛出CloneNotSupportedException.
在克隆java对象的时候不会调用构造器
java提供一种叫浅拷贝（shallow copy）的默认方式实现clone，创建好对象的副本后然后通过赋值拷贝内容，意味着如果你的类包含引用类型，那么原始对象和克隆都将指向相同的引用内容，这是很危险的，因为发生在可变的字段上任何改变将反应到他们所引用的共同内容上。为了避免这种情况，需要对引用的内容进行深度克隆
深克隆：方法有两种：
1.先对对象进行序列化操作，然后立马反序列化出。

2.先调用super.clone()方法克隆出一个新对象来，然后在子类的clone()方法中手动给克隆出来的非基本数据类型（引用类型）赋值。（这个是网上别人的观点，稍后会去研究各个集合内的克隆原理，也是一个知识点）

接口：接口是通过interface关键字来声明的，接口成员可以声明3种类型：

常量（字段）、方法、嵌套类和嵌套接口。

因为接口不包含任何实现的细节，所以接口不能定义普通的字段。

在接口中，声明的方法都是隐式是abstract的，所以不能刻意省略abstract；

除注解外，在接口上不允许使用其他修饰符。不能是final。static、

扩展接口继承了其超接口中声明的所有常量，如果一个接口声明了一个和继承而来的某个常量同名的常量。那么不论他们属于

何种类型，新声明的常量都将隐藏继承而来的常量。

子接口继承了在其超接口中声明的所有方法。如果子接口中声明的某个方法与继承而来的某个方法具有相同的函数和相同的或者共变

的返回类型，那么新的声明会覆盖所有的已有声明。

嵌套类和嵌套接口：

类和接口可以在其他的类和接口的内部进行声明。要么声明在代码内部。

定义嵌套类型主要有两个用途，第一，嵌套类和嵌套接口使多个类型可以组织成逻辑上相关的组，并具有相应的作用域。

第二:嵌套类可以简单而有效地连接逻辑上相关的对象。

嵌套类型可以看做是其包围类型的一部分，他们之间互相通信，彼此可以访问对方的所有成员。

静态嵌套类型

如果嵌套类或嵌套接口被声明为其包围类或包围接口的静态成员，那么他的行为就与非嵌套的类或接口是一样的，只是

它的名字和可访问性是由其包围类型决定的，只有当包围类型可访问时，嵌套类型才是可访问的。

静态嵌套类型可以访问其包围类型的成员，包括私有成员。

静态嵌套类是嵌套类的最简形式。只要在类声明的前面加上static修饰符就可以声明一个静态嵌套类。嵌套在一个接口中

一般是静态的。

静态嵌套类的(static nested class)：

可以独立于外部类被实例化
无法访问外部类中的非静态变量和方法
静态嵌套类要和其外部类的实例变量（或者其他类）交互的话，其行为和一般顶级类一样
实际上，静态嵌套类就是一个为了打包方便而被嵌套进外部类的顶级类。

非静态嵌套类(内部类inner class)：

想要实例化必须先实例化外部类。
可以访问外部类中的需要实例化的变量和方法，

1、内部类可以直接访问外部类中的成员，包括私有。之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式为：外部类明.this
2、外部类要访问内部类，必须创建内部类对象。

1、当内部类定义在外部类的成员位置上是，而且非私有，可以在外部其他类中
可以直接建立内部类对象
格式：

外部类明.内部类名变量名=外部类对象.内部类对象；

Outer.Inter in=new Outer().new Inner();

2、当内部类在成员位置上时，就可以成员修饰符所修饰

比如：private：将内部类在外部类中进行封装
static：内部类就具备static特性
当内部类被静态修饰后，只能访问外部类中的静态成员了，出现了访问局限。

在外部其他类中，如何直接访问静态内部类的非静态成员呢？

new Outer.Inner().function();

在外部其他类中，如何直接访问静态内部类的静态成员呢？

Outer.Inner.function();

1、匿名内部类其实就是内部类的简写格式
2、定义匿名内部类的前提
内部类必须是继承一个类或者是实现接口
3、匿名内部类的格式：new 父类或者接口(){定义子类的内容}
4、其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖
也可以把它理解成一个带内容的对象
5、匿名内部类中定义的方法最好不要超过3个