1.Object
Object类是java层次最顶层的基类(父类),java中所有的引用类都默认继承Object
所有引用类型的默认值是null
在引用类型中 " == " 是比较地址是否是同一个
finalize方法是一个对象的最后执行代码(要被销毁时)
package com.easy717;
public class EasyObject extends Object{
//Object类
//java是面向对象的,在java中所有的引用类默认继承Object
//所有引用类型的默认值是null
//在引用类型中 == 比较地址是否是同一个
public static void main(String[] args){
Object obj=new EasyObject();//向上转型
// Object objA=obj;
// System.out.println(obj==objA);//ture
Object objB=new EasyObject();//new就是创建了一个新的对象
System.out.println(obj==objB);//true
System.out.println(obj.toString());
obj=null;//让obj对象没有指向
System.gc();
}
public String toString(){//重写toString方法
return "this is a EasyObject";
}
@Override
public void finalize(){
//finalize方法是一个对象的最后执行代码(要被销毁时)
System.out.println("-----finalize");
}
}
2.包装类(缓存机制)
基本数据类型记录的是数值,不是面向对象的
java为了实现万物皆对象的理念,给每一个基本数据提供了对应的封装内容
基本数据类型的封装类型:
byte | short | int | long | float | double | char | boolean | |
封装类型 | Byte | Short | Integer | Long | Float | Double | Character | Booloean |
基本数据类型的封装类,可以和基本数据类型直接转换
Integer i=12;
Double d=12.0;
i=new Integer(22);
int aa=new Integer(22);
System.out.println(i+33);
3.装箱:把基本数据类型转换成对应的封装类型的过程叫做封箱
拆箱:把封装类型转换成对应的基本数据类型的过程叫做拆箱
4.基本类型的封装类型的缓存
整数类型缓存范围-128~127,只有Integer的范围可以调整
Character缓存范围是0-127
// Character缓存范围0-127
Character intA=0;
// Character intB='\000';
Character intB= new Character('\000');
System.out.println(intA==intB);
// Integer intA=-129;//超出范围值就为false
// Integer intB=-129;
// //Long intA=127L;Long不能直接赋值int型,要在数值后加L
// System.out.println(intA==intB);
// Integer intC=200;
// Integer intD=200;
// System.out.println(intC==intD);
基本数据类型和封装类型比较,封装类型拆箱后再比较
Number num=new Integer(12);//向上转型
Integer intN=1200;
int iN=1200;
System.out.println(intN==iN);
封装类型一定是一个封装类型,封装类型之间类型不一样就不能比较
Short sN=1200;
System.out.println(sN==iN);//封装类型一定是个数值类型
//封装类型之间类型不一样就不能比较
Double dN=1200.0;
System.out.println(dN==iN);
new Byte("12");
new Short("12");
new Float("12");
new Double("12");
new Character('a');
Integer.valueOf("34");//将字符转换成数值
Integer.parseInt("12");//把字符串转换成数值
valueof, parseInt作用:将字符串换成数值
5.包 package
使用本包下的类不需要导包
使用其他包的类需要导包
所有的类默认引入Java.lang包
类名重名的情况下可以使用类的全名指定具体使用哪一个类 类全名:包名+类名
包有封装性,包和包之间没有子父关系
6.static
static 修饰的属性是属于类的 静态的
可以使用类名直接调用static修饰的属性和方法
静态属性对所有本类的对象是共享的
本类的对象也可以调用静态的属性和方法,调用的方式还是静态方式
静态方法中不能直接调用非静态的属性和方法
package com.easy717;
public class EasyStatic {
public static void main(String[] args) {
StaticObject staA=new StaticObject();
StaticObject staB=new StaticObject();
//static 修饰的属性是属于类的
//可以使用类名直接调用static修饰的属性和方法
//静态属性对所有本类的对象是共享的
//本类的对象也可以调用静态的属性和方法,调用的方式还是静态方式
StaticObject.maxAge=21;
staA.age=22;
staB.age=23;
System.out.println(staA);
System.out.println(staB);
}
}
class StaticObject{
//static 静态的 类的
int age;//成员属性 非静态的
//类的成员就是对象
static int maxAge;
//空白行 右键 general
static void method(){
// age=22;//静态方法中不能直接调用非静态的属性和方法
new StaticObject().age=22;
}
@Override
public String toString() {
return "StaticObject{" +
"age=" + age +
"maxAge="+maxAge+
'}';
}
}
7.抽象类
使用abstract修饰的类都是抽象类
抽象类没有直接实例 不能实例化(不能new)
抽象类中可以定义抽象方法
抽象类可以用来继承
抽象方法 : 使用abstract修饰的方法 没有方法体
实体类继承抽象类,必须实现抽象类中抽象方法(重写)
重写:子类对父类中继承方法重新定义
抽象类实现抽象类可以不实现抽象方法
静态方法不能重写
8.final
final的用途:1.final可以修饰类 不能继承
2.final可以修饰方法 不能被重写
3.final可以修饰量 不能被重新赋值
9.接口
接口中只能定义方法,没有方法体(没有实现的能力)
接口中的方法 抽象方法:没有具体实现的方法
接口中可以定义属性,定义属性都是常量,常量必须全部大写,必须要初始化
接口中定义的属性都是常量,默认使用 public static final修饰
接口中定义的方法默认使用public abstra修饰
接口中可以定义default修饰的实体方法,虽然使用default修饰但是访问权限还是public
java中使用Implements声明一个类实现接口
一个类可以实现多个接口
如果一个接口中只有一个未实现的方法,那这个接口成为函数式接口
函数式接口:就是一个有且仅有一个抽象方法,但是可以有多个非抽象方法的接口。
package com.easy717;
import java.io.Serializable;
public class EasyInterface implements IVehicle{
@Override
public void transport() {
}
@Override
public void test() {
IVehicle.super.test();
}
}
@FunctionalInterface
//定义接口
//接口里面不能定义构造方法
//extends Cloneable
interface IVehicle extends Cloneable{
//接口中只能定义方法,没有方法体(没有实现的能力)
//接口中的方法 抽象方法 : --没有具体实现的方法
//接口中可以定义属性,定义的属性都是常量
//接口中定义的属性都是常量,默认使用public static final修饰
//常量必须全部大写,必须要初始化
public static final String MAX_SPEED="1000";
//public static final 修饰
String MIN_SPEED="90";
//接口中定义的方法默认使用publi abstract修饰
void transport();
//接口中可以定义default修饰的实体方法
//虽然使用default修饰但是访问权限还是public
default void test(){
}
}
//java中使用implements声明一个类实现接口
//一个类可以实现多个接口
//接口使用extends继承接口
//如果一个接口中只有一个未实现的方法,这个接口成为函数式接口
class ObjectInter implements IVehicle,Cloneable, Serializable {
public void transport(){
}
}
10.深浅拷贝
Object clone() 方法用于创建并返回一个对象的拷贝。
为什么要有clone?
new 与反射都可以创建内容一模一样的对象,
但是我们创建对象之后需要set方法来设置相关的一摸一样的内容,
如果需要创建更多的内容一致的对象,就需要一直重复上述操作----clone
clone使用步骤:
使用object的clone方法--使用步骤:
* 1.在需要调用clone方法的对象上添加实现cloneable接口
* 2.复写clone方法,在自己的clone方法中调用父类的clone方法,将返回值强转成本类类型,
* 将当前修饰符改成public
* 3.在测试中调用对象的clone方法
clone 方法是浅拷贝,对象内属性引用的对象只会拷贝引用地址,而不会将引用的对象重新分配内存,相对应的深拷贝则会连引用的对象也重新创建。
返回值:返回一个对象的拷贝。
由于 Object 本身没有实现 Cloneable 接口,所以不重写 clone 方法并且进行调用的话会发生 CloneNotSupportedException 异常。
以下实例创建了 obj1 对象,然后拷贝 obj1 给 obj2,通过 obj2 输出变量的值:
实例:
class RunoobTest implements Cloneable {
// 声明变量
String name;
int likes;
public static void main(String[] args) {
// 创建对象
RunoobTest obj1 = new RunoobTest();
// 初始化变量
obj1.name = "Runoob";
obj1.likes = 111;
// 打印输出
System.out.println(obj1.name); // Runoob
System.out.println(obj1.likes); // 111
try {
// 创建 obj1 的拷贝
RunoobTest obj2 = (RunoobTest) obj1.clone();
// 使用 obj2 输出变量
System.out.println(obj2.name); // Runoob
System.out.println(obj2.likes); // 111
} catch (Exception e) {
System.out.println(e);
}
}
}