目录
一、类、超类和子类
1.定义子类
class People{
private String name;
private int age;
public People(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "name=" + name + " age="+ age;
}
public void action(){
System.out.println("呼吸");
}
}
class Student extends People{
public Student(String name, int age) {
super(name, age);
}
@Override
public String toString() {
return super.toString();
}
public void action(){
System.out.println("学习");
}
}
class Teacher extends People{
public Teacher(String name, int age) {
super(name, age);
}
public void action(){
System.out.println("教学");
}
}
2.覆盖方法
当父类的某个方法不适用于其子类的时候,我们需要提供新的方法来覆盖父类的方法。
3.子类构造器
由于Student类的构造器不能访问 People类的私有字段,所以必须通过一个构造器来初始化这些私有字段。可以利用特殊的 super 语法调用这个构造器。使用super调用构造器的语句必须是子类构造器的第一条语句。
如果子类的构造器没有显式地调用超类的构造器,将自动地调用超类的无参数构造器,如果超类没有无参数的构造器,并且在子类的构造器中又没有显式地调用超类的其他构器,Java编译器就会报告一个错误。
4.多态
多态指的是同一个方法调用,由于对象不同可能会有不同的行为。
class People{
public void action(){
System.out.println("呼吸");
}
}
class Student extends People{
public void action(){
System.out.println("学习");
}
}
class Teacher extends People{
public void action(){
System.out.println("教学");
}
}
public class Md {
public static void main(String[] args) {
People p1 = new Student();
People p2 = new Teacher();
p1.action();//学习
p2.action();//教学
}
}
5.阻止继承:final类和方法
final class T1{}//t1不能被继承
class T2{
String name;
public final String getName(){//getName不能被覆盖
return name;
}
}
6.抽象类
抽象方法充当着占位方法的角色,它们在子类中具体实现。扩展抽象类可以有两种选。一种是在子类中保留抽象类中的部分或所有抽象方法仍未定义,这样就必须将子类标记为抽象类;另一种做法是定义全部方法,这样一来,子类就不是抽象的了。
abstract class Person{
abstract void getDescription();
}
class Student extends Person{
abstract void getDescription(
System.out.println("学习");
)
}
二、Object:所有类的超类
在Java中所有的类都扩展了Object,如果没有明确指出超类,Object就被认为是这个类的超类。
1.Object类型的变量
Object[] object = new Integer [3];
2.equals方法
Object类中的equals方法用于检测一个对象是否等于另外一个对象。Object类中实现的 equals方法将确定两个对象引用是否相等。这是一个合理的默认行为:如果两个对象引用相等,这两个对象肯定就相等。对于很多类来说,这已经足够了。例如,比较两个 PrintStreai对象是否相等并没有多大的意义。不过,经常需要基于状态检测对象的相等性,如果两个对象有相同的状态,才认为这两个对象是相等的。
public boolean equals(Object obj) {
return (this == obj);
}
People p1 = new Student();
People p2 = new Teacher();
System.out.println(p1.equals(p2));//false
对于没用重写Object的equals()方法的类型所生成的对象的比较,equals()和==是效果一样的,==比较的是两个变量所指向的对象在内存中指向的地址是否一样,而当两个变量的类型中继承了Object的equals()方法的时候,由于该方法比较的标准是看哈希码是否相等,而哈希码是由hashCode()方法生成的,该方法生成哈希码的依据是对象在内存中的地址,最终比较的还是地址。(参考二--5)
3.相等测试与继承
Java语言规范要求equals方法具有下面的特性:
- 自反性:对于任何非空引用x,x.equals(x) 应该返回 true。
- 对称性:对于任何引用x和 y,当且仅当y.equals(x) 返回 true 时,x.equals(y)返回 true。
- 传递性:对于任何引用x、y和z,如果x.equals(y)返回true,y.equals(z)返回true, x.equals(z)也应该返回true。
- 一致性:如果x和y引用的对象没有发生变化,反复调用x.equals(y)应该返回同样的结果。
- 对于任意非空引用x,x.equals(null)应该返回 false。
4.hashCode方法
- 散列:散列也叫散列函数,是一种可以将任意长度的输入转换为固定长度输出的算法,因此不同的输入可能产生相同的输出。
- 散列码:散列码就是按照散列函数生成的结果。
字符串s与t有相同的散列码,这是因为字符串的散列码是由内容导出的。而字符串构建器sb与tb却有着不同的散列码,因为在StringBuilder类中没有定义hashCode方法,而Object 类的默认 hashcode方法会从对象的存储地址得出散列码。
Object的hashCode()方法返回的哈希码是根据对象的内存地址来生成的,所以每个对象的哈希码是不相同的,如果你要比较的两个变量的类型没有重写Obiect的hashCode()方法那么这两个变量除非是指向相同的对象(地址相同),否则返回的一定是false。而String以及基本数据类型的包装类中都重写了 hashCode()方法,他们生成的哈希码是跟他们的内容(这里就是指值)息息相关,也就是说在用equals()比较两个变量是否相等的时候只要他们的值相等,那么就返回true,因为他们生成的哈希码相等。
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}
String s = "fss";
String ss = new String("fss");
StringBuilder sss = new StringBuilder("fss");
System.out.println(s.hashCode());//101702
System.out.println(ss.hashCode());//101702
System.out.println(sss.hashCode());//460141958
5.toString
public String toString() {
return "name=" + name + " age="+ age;
}
三、泛型数组列表
1.声明数列列表
这个方法调用将分配一个包含100个对象的内部数组。这样一来,前 100 次 add 调用不会带来开销很大的重新分配空间。另外,还可以把初始容量传递给ArrayList构造器:
ArrayList<E>list = new ArrayList<>();
list.ensureCapacity(100);
ArrayList<E> list =new ArrayList<>(100);
2.访问数组列表元素
list.get(i);
list.set(i,10086);
四.对象包装器和自动装箱
在ArrayList<E>中,E是不能为int,double,long等基本类型的,要使用对应的包装类,例如int类型应该使用Integer。而包装类是不可变的,一旦构造了包装类,就不能改变包装在里面的值,而且包装器的类是fianl,不能派生子类。在日常代码中会发现有直接更改包装里面的值,但只是表面是起来而已。
Integer i = 4;
i = i + 4;//i = 8;
这种情况是因为在运算前,编译器会先给包装类的 “i” 进行拆箱,使其变为基本类型,然后再进行运算,最后再将 “i” 装箱。
//调用
list.add(3);
//会自动变成
list.add(Integer.valuOf(3));
//也就是自动装箱。
在比较包装类对象的值是否相等时候应该调用equal()方法,因为==是比较对像的内存地址。
Integer i = 1000,b = 1000;
System.out.println(i==b);//结果为false
五.常数数量可变的方法
System.out.printf("%d",i);
System.out.printf("%d %s",i,"hello");
在上述代码中两条语句都调用了同一个方法,不过在同一种方法中却可以有不同数量的参数。以下是printf方法的定义。
public PrintStream printf(String format, Object ... args) {
return format(format, args);
}
public static double max(double... values){
double largest = Double.NEGATIVE_INFINITY;//负无穷
for (double v : values){
if (v > largest) {
largest = v;
}
}
return largest;
}
可以像下面这样调用这个方法:
double m = max(3.1,40.4·5);
编译器将new double[]{3.1,40.4,-5}传递给max方法。
六、枚举类
1.枚举类的定义
- 所有的枚举类型都继承于Enum类。
- 枚举类的构造器总是私有的
- 因为定义的类型是一个类,且有四个实例,不能构造新的对象,所以比较两个枚举类型的值的时候可以直接使用“==”。
2.枚举类的简单使用
enum Size{
SMALL("S"),MEDIUM("M"),LARGE("L"),EXTRA_LARGE("XL");
private String abbreviation;
private Size(String abbreviation) {
this.abbreviation = abbreviation;
}
public String getAbbreviation() {
return abbreviation;
}
}
Size s = Size.LARGE;
switch (s) {
case SMALL: System.out.println("小码");
break;
case MEDIUM: System.out.println("中码");
break;
case LARGE: System.out.println("大码");
break;
case EXTRA_LARGE: System.out.println("大一码");
break;
default:
break;
}
Size s = Enum.valueOf(Size.class,"SMALL");
Size[] values = Size.values();//返回包含所有类型的数组
3.常用的方法
方法名称
|
描述
|
values()
|
以数组形式返回枚举类型的所有成员
|
ordinal()
|
获取枚举成员的索引位置
|
valueOf()
|
将普通字符串转换为枚举实例
|
compareTo() |
比较两个枚举成员在定义时的顺序
|
七、反射
Java的反射(reflection)机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意方法和属性,既然能拿到那么,我们就可以修改部分类型信息;这种动态获取信息以及动态调用对象方法的功能称为java语言的反射(reflection)机制。
1.反射的重要用途
- 在日常的第三方应用开发过程中,经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放,这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法 。
- 反射最重要的用途就是开发各种通用框架,比如在spring中,我们将所有的类Bean交给spring容器管理,无论是XML配置Bean还是注解配置,当我们从容器中获取Bean来依赖注入时,容器会读取配置,而配置中给的就是类的信息,spring根据这些信息,需要创建那些Bean,spring就动态的创建这些类。
2.反射机制的原理
Java文件被编译后,生成了.class文件,JVM此时就要去解读.class文件 ,被编译后的Java文件.class也被JVM解析为 一个对象,这个对象就是 java.lang.Class .这样当程序在运行时,每个java文件就最终变成了Class类对象的一个实例。我们通过Java的反射机制应用到这个实例,就可以去获得甚至去添加改变这个类的属性和动作,使得这个类成 为一个动态的类 。
3.反射的重要类
类名
|
用途
|
Class
类
|
代表类的实体,在运行的
Java
应用程序中表示类和接口
|
Field
类
|
代表类的成员变量
/
类的属性
|
Method
类
|
代表类的方法
|
Constructor
类
|
代表类的构造方法
|
4.class类中的常用方法
方法
|
用途
|
getClassLoader()
|
获得类的加载器
|
getDeclaredClasses()
|
返回一个数组,数组中包含该类中所有类和接口类的对象
(
包括私有的
)
|
forName(String className)
|
根据类名返回类的对象
|
newInstance()
|
创建类的实例
|
getName()
|
获得类的完整路径名字
|
5.获得类中属性常用的方法
方法
|
用途
|
getField(String name)
|
获得某个公有的属性对象
|
getFields()
|
获得所有公有的属性对象
|
getDeclaredField(String name)
|
获得某个属性对象
|
getDeclaredFields()
|
获得所有属性对象
|
6.获得类中构造器常用的方法
方法
|
用途
|
getConstructor(Class...<?> parameterTypes)
|
获得该类中与参数类型匹配的公有构造方法
|
getConstructors()
|
获得该类的所有公有构造方法
|
getDeclaredConstructor(Class...<?> parameterTypes)
|
获得该类中与参数类型匹配的构造方法
|
getDeclaredConstructors()
|
获得该类所有构造方法
|
7.获得类中方法常用的方法
方法
|
用途
|
getMethod(String name, Class...<?> parameterTypes)
|
获得该类某个公有的方法
|
getMethods()
|
获得该类所有公有的方法
|
getDeclaredMethod(String name, Class...<?> parameterTypes)
|
获得该类某个方法
|
getDeclaredMethods()
|
获得该类所有方法
|
总结
慢慢进步咯。