java8 第二章-----面向对象

Xiayebuliang

于 2022-12-27 16:08:44 发布

阅读量186

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/xiayebuliang/article/details/128456050

版权

2.1、类

2.1.1、类的定义

[public] class 类名 {
    // 成员变量（可多个）
    [权限修饰符] {基本数据类型|引用数据类型} 变量名;

    // 成员常量（可多个）
    [权限修饰符] final {基本数据类型|引用数据类型} 变量名;

    // 成员方法（可多个）
    [权限修饰符] 返回值类型 方法名([参数类型 参数名,...]) {
        ...
        [return 返回值;]
    }

    // 构造方法（无参，只一个）
    public 类名() {
        ...
    }

    // 构造方法（有参，可多个）
    public 类名([参数类型 参数名,...]) {
        ...
    }
}

成员变量和局部变量的区别？

2.1.2、类的继承

[public] class 父类 { }
[public] class 子类 extends 父类 { }

this 和 super关键字的对比？

继承中变量使用的访问特点？

子类局部范围找
子类成员范围找
父类成员范围找
如果都没有就报错(不考虑父亲的父亲…)

继承中成员方法的访问特点？

子类成员范围找
父类成员范围找
如果都没有就报错(不考虑父亲的父亲…)

继承中构造方法的访问特点？

子类中所有的构造方法默认都会访问父类中无参的构造方法，每一个子类构造方法的第一条语句默认都是：super()
如果父类中没有无参的构造方法，只有带参的构造方法，通过使用 super 关键字去显示的调用父类的带参构造方法。
多态中成员变量的访问特点？

编译看父类，运行看父类

多态中成员方法的访问特点？

编译看父类，运行看子类

多态中向上转型和向下转型？

向上转型：父类引用指向子类对象就是向上转型
向下转型：子类型对象名 = (子类型)父类引用;

方法重写和方法重载的区别？

方法重写：子类对父类允许访问的方法的实现过程进行重新编写就是方法重写。英文名：Override
方法重载：在一个类里面，方法名字相同而参数列表不同的方法就是方法重载。英文名：Overload

2.1.3、static关键字

由 static 关键字修饰的成员变量、成员常量、成员方法和内部类被称为静态成员变量、静态成员常量、静态成员方法和静态内部类。

修饰成员变量时，将其变为类的静态成员变量，从而实现所有对象对于该变量的共享，可直接使用"类名.变量名"的方式调用。
修饰成员常量时，将其变为类的静态成员常量，从而实现所有对象对于该常量的共享，可直接使用"类名.常量名"的方式调用。
修饰成员方法时，将其变为类的静态成员方法，从而实现所有对象对于该方法的共享，可直接使用"类名.方法名"的方式调用。
修饰内部类时，将其变为类的静态内部类，从而实现所有对象对于该内部类的共享，可直接使用"类名.内部类名"的方式调用。
静态导包用法时，将指定类的方法直接导入到当前类中，从而直接使用"方法名"即可调用指定类的指定方法。
静态代码块用法时，随着类的加载而执行，而且只执行一次，常用于初始化成员变量。

非静态的成员方法和静态的成员方法的区别？

2.1.4、final关键字

final 关键字修饰基本数据类型时，其数值不能发生改变。
final 关键字修饰引用数据类型时，其地址不能发生改变。
final 关键字修饰成员方法时，表示该方法不能被重写。
final 关键字修饰 class 类时，表示该类不能被继承。

2.1.5、package关键字

概述：包就是文件夹，用来管理类文件的。

语法：package 包名; （多级包名用点分隔）

带包编译：javac –d . 类名.java
例如：javac -d . com.company.demo.HelloWorld.java

带包运行：java 包名+类名
例如：java com.company.demo.HelloWorld

2.1.6、import关键字

概述：使用不同包下的类时，使用的时候要写类的全路径，为了简化操作，Java就提供了导包的功能。

语法：import 包名; （多级包名用点分隔）

2.1.7、权限修饰符

2.2、对象

对象的创建：

通过无参构造创建对象：对象类型 对象名 = new 对象类型();
通过有参构造创建对象：对象类型 对象名 = new 对象类型(参数列表);

对象的使用：

对象名.成员变量;
对象名.成员方法();

对象的比较：

==：用于比较两个对象的地址是否相同。
equals()：用于比较两个对象的内容是否相同，需要对象重写equals()、hashCode()两个方法。
instanceof运算符：用于判断运算符前的对象是否是运算符后的类、抽象类或接口的子类或实现类所创建的对象。语法：boolean result = 对象 instanceof (类/抽象类/接口);

对象的销毁：

每个对象都有生命周期，当对象生命周期结束时，分配给该对象的内存地址将会被回收，在 Java 中拥有一套完整的垃圾回收机制，用户不必担心废弃的对象占用内存，他会被垃圾回收器自动回收，垃圾回收不保证一定会发生，具体执行时间也不确定，可以手动调用：System.gc();回收。

当对象被置为null时将消亡。
当对象超出作用域时将消亡。

2.3、接口

[public] interface 父接口 { }
[public] class 子实现 implements 父接口 { }

成员变量：只能是静态常量，默认修饰符：public static final
成员方法：只能是抽象方法，默认修饰符：public abstract
构造方法：没有构造方法
默认方法：public default 返回值类型方法名(参数列表) { }
静态方法：public static 返回值类型方法名(参数列表) { }

如何解决默认方法冲突？

如果先在一个接口中将一个方法定义为默认方法，然后又在超类或另一个接口中定义了同样方法，遵循如下规则：

超类优先。如果超类提供了一个具体方法，同名且有相同参数类型的默认方法会被忽略。
接口冲突。如果一个接口提供了一个默认方法，另一个接口提供了一个同名而且参数类型相同的方法，必须覆盖这个方法来解决冲突。

2.4、抽象类

[public] abstract 抽象类名 { }
[public] class 实现类 extends 抽象类名 { }

成员变量：既可以成员变量，也可以成员常量
成员方法：既可以普通方法，也可以抽象方法
构造方法：既可以无参构造，也可以有参构造
注意事项：与abstract不能共存的关键字：final、private、static

2.5、内部类

[public] class Outer {
    [public] class Inner { }
}

内部类的常见分类：

成员内部类：在成员变量位置定义的内部类
	   格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
	   注意：Outer.Inner oi = new Outer().new Inner();

局部内部类：在成员方法位置定义的内部类
	   格式：外界是无法直接使用，需要在方法内部创建对象并使用
	   注意：局部内部类可以直接访问外部类的成员，也可以访问方法内的局部变量

匿名内部类：前提是继承一个类或实现接口
	   格式：new 类名 ( ) { 重写方法 } 、 new 接口名 ( ) { 重写方法 }
	   注意：本质上是一个继承了该类或者实现了该接口的子类匿名对象

静态内部类：在成员变量位置定义的内部类
	   格式：使用 static 关键字修饰的成员内部类
	   注意：静态内部类中可以声明静态成员，而成员内部类中不可以声明静态成员，而且静态内部类不可以访问外部类的非静态成员

2.6、枚举类

[public] enum 枚举名 { 枚举项1,枚举项2,枚举项3,... }

成员变量：既可以成员变量，也可以成员常量
成员方法：既可以普通方法，也可以抽象方法，但是枚举项必须实现抽象方法
构造方法：既可以无参构造，也可以有参构造，但是修饰符必须都是 private
注意事项：枚举类第一行必须是枚举项，多个枚举项之间使用逗号隔开，最后一个枚举项使用分号结束，如果最后一个枚举项后没有其他东西，最后一个分号可以省略，所有枚举类都是Enum的子类，有参构造函数的枚举类的枚举项的用法比较特殊：枚举项("")

枚举类的常用方法：

2.7、注解

//基本注解
public @interface 注解名 {
    成员类型 value() default "默认值; 
}

基本注解可以取啥？

@Document注解：表示将此注解包含在 javadoc 中
@Inherited注解：表示该注解的继承特性
@Retention注解：表示该注解的生命周期
RetentionPolicy.SOURCE：源码期间有效
RetentionPolicy.CLASS：编译期间有效
RetentionPolicy.RUNTIME：运行期间有效
@Target注解：表示该注解的标注位置
ElementType.TYPE：表示用于类、接口、枚举类以及注解上
ElementType.FIELD：表示用于成员变量和枚举变量上
ElementType.METHOD：表示用于成员方法上
ElementType.PARAMETER：表示用于方法参数上
ElementType.CONSTRUCTOR：表示用于构造方法上
ElementType.LOCAL_VARIABLE：表示用于局部变量上
ElementType.ANNOTATION_TYPE：表示用于注解上
ElementType.PACKAGE：表示用于包上
ElementType.TYPE_PARAMETER：表示用于类上泛型参数上
ElementType.TYPE_USE：表示用于任何类型声明上
@Repeatable：表示该注解可重复使用

成员类型可以取啥？

八种基本数据类型、String、Class、枚举类、注解类及以上所列类型的数组

平时开发常用注解？

@Override：表示当前方法覆盖了父类的方法
@Deprecated：表示当前方法已经过时不建议使用
@SuppressWarnings：表示关闭一些警告信息，抑制信息如下：

2.8、泛型

泛型类：

[public] class 类名<T> { }

泛型方法：

权限修饰符 <T> 返回值类型 方法名(T t) {
    return 返回值类型;
}

泛型接口：

[public] interface 类名<T> { }

泛型通配符：

类型通配符：<?>
    List<?>：表示元素类型未知的List，它的元素可以匹配任何的类型
    
类型通配符上限：<? extends 类型>
    List<? extends Number>：它表示的类型是Number或者其子类型
    
类型通配符下限：<? super 类型>
    List<? super Number>：它表示的类型是Number或者其父类型

泛型局限性：

不能用八种基本类型实例化类型参数，而是用他们所对应的包装类
无论何时定义一个泛型类型，都自动提供了一个相应的原始类型（ raw type )，原始类型的名字就是删去类型参数后的泛型类型名。擦除（ erased ) 类型变量，并替换为限定类型，无限定的变量用Object替换
运行时类型查询只适用于原始类型，试图查询一个对象是否属于某个泛型类型时，倘若使用instanceof会得到一个编译器错误，如果使用强制类型转换会得到一个警告，正确的做法是调用getClass()方法进行比较原始类型是否一致
不能创建参数化类型的数组，例如：Pair<String>[] table = new Pair<String>[10] ;这是错误的，可以声明通配类型的数组，然后进行类型转换：Pair<String>[] table = (Pair<String>[]) new Pair<?>[10];
不能实例化类型变量，不能使用像new T(...)，newT[...] 或T.class这样的表达式
不能在静态域或方法中引用类型变量
不能抛出或捕获泛型类的实例

2.9、注释

单行注释：// 注释内容
多行注释：/* 注释内容 */
文档注释：/** 注释内容 */

文档注释加在类上的标签：

@author：指定类的作者
@version：指定类的版本
@since：从以下版本开始
@see：另请参阅一个类

文档注释加在方法上的标签：

@param：说明一个方法的参数
@return：说明一个方法的返回值
@throws：说明一个方法的异常

Xiayebuliang

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java8 第二章-----面向对象

每个对象都有生命周期，当对象生命周期结束时，分配给该对象的内存地址将会被回收，在 Java 中拥有一套完整的垃圾回收机制，用户不必担心废弃的对象占用内存，他会被垃圾回收器自动回收，垃圾回收不保证一定会发生，具体执行时间也不确定，可以手动调用：System.gc();由 static 关键字修饰的成员变量、成员常量、成员方法和内部类被称为静态成员变量、静态成员常量、静态成员方法和静态内部类。概述：使用不同包下的类时，使用的时候要写类的全路径，为了简化操作，Java就提供了导包的功能。
复制链接

扫一扫