[Java知识库]java对象

对象

面向对象编程

本质

以类的方式组织代码，以对象的组织(封装)数据

抽象(将像的部分抽离出来)

三大特性

封装

该露的露，该藏的藏

"高内聚，低耦合"，高内聚：就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用

1,提高程序的安全性，保护数据

2，隐藏代码是实现过程

属性私有，get/set

public class Demo7 {
 ?private int id;
?
 ? // 获得这个数据
 ? ?public int getId() {
 ? ? ? ?return id;
 ?  }
 ? // 设置这个数据
 ? ?public void setId(int id) {
 ? ? ? ?this.id = id;
 ?  }
?
 ? ?public static void main(String[] args) {
 ? ? ? ?Demo7 demo7=new Demo7();
 ? ? ? ?demo7.setId(72);
 ? ? ? ?System.out.print(demo7.getId());
 ?  }
}
?

继承(如：直角三角形继承于三角形，前者是后者的子类)

本质是对某一类的抽象，从而实现对现实世界更好的建模

1,子类继承父类就有了父类的所有方法

2,java中所有的类都默认继承Object类

3,java中只有单继承没有多继承 父类只能有一个，子类可以有多个

4,私有的属性无法被继承

extends 继承

super

public class person{
 ? ?public String name="opq";
 ? ?public void f(){
 ? ? ? ?
 ?  }
}
?
class student extends person{
 ? ?public String name="waz";
 ? ?public void f(){
 ? ? ? ?this.name;//子类的name=waz
 ? ? ? ?super.name;//父类的name=opq
 ?  }
 ? ?public void k(){
 ? ? ? ?this.f();//子类的方法
 ? ? ? ?super.f();//父类的方法
 ?  } ? 
}
当子类实例化运行时，会调用父类默认的方法
 ? ?super();在子类中一般被隐藏了指的的 super.person();
调用父类的构造器必须要在子类的第一行
 ? ?当父类为有参构造时，子类的构造器也必须为有参构造

super的注意点

• super调用父类的构造方法，必须放在子类构造方法的第一个

• super必须只能出现在子类的方法或构造器中

• super和this不能同时调用构造方法

this 区别

this:本身调用者这个对象

super:代表父类对象的应用

前提

this：没有继承也可以使用

super：必须继承后才能使用

构造方法

this(); 子类的构造方法

super(); 父类的构造方法

方法的重写

重写都是方法的重写，与属性无关

public class A{
 ? ?@Override ?//重写
 ? ?public void test(){
 ? ? ? ?super.test();
 ?  }
 ? 
}
public class B extends A{
 ? ?public void test(){
 ? ? ? ?
 ?  }
}
 public static void main(String[] args) {
 ? ? //静态方法：调用只和左边，定义的数据类型有关
 ? ? //非静态方法；重写
 ? ? A a=new A();
 ? ? a.test();//A
 ? ? //父类的引用指向了子类
 ? ? B b=new A();
 ? ? b.test();//非静态为A，静态为B
 ? ?
 }

重写：需要有继承关系，子类重写父类的方法

重写：子类的方法和父类必须相同：方法体不同

• 方法名必须相同

• 参数列表必须相同

• 修饰符：范围可以扩大，不能缩小

• 抛出的异常：范围，可以缩小，但不能扩大

为什么要重写

• 父类的功能，子类不一定需要，或者不一定满足

多态(同一种事物会有多种形态，每种形态都不一样)

认识角度，先有对象后有类

代码角度，先有类后有对象

多态存在条件

• 有继承关系

• 子类重写父类方法

• 父类指向子类对象

一个对象的实际类型是确定的，但可以指向的引用类型不确定了：父类的引用指向子类

public class ?person{
 ? ?
}
public class ?student extends person{
 ? ?
}
public static void main(String[] args)
{ ? 
 ? ? //一个对象的实际类型是确定的
 ? ?new student();
 ? ?new person();
 ? ?//指向的引用类型不确定：父类的引用指向子类
 ? ?//student 能调用的方法都是自己的或者继承父类的
 ? ?student s1=new student();
 ? ?//person 父类型，可以指向子类，但是不能调用子类独有的方法
 ? ?person s2=new student();
 ? ?object s3=new student();
}
总结：编译，看左边；运行，看右边

多态注意事项

• 多态是方法的多态，属性没有多态

• 父类和子类，有联系，类型转换异常(ClassCastException)

• 存在条件:继承关系，方法需要重写。父类引用指向子类

无法重写的情况

• static 方法，属于类，它不属于实例

• final 常量，final修饰的方法也不能被继承

• private 方法

instanceof

判断类的类型是否相似

public class ?person{
 ? ?
}
public class ?student extends person{
 ? ?public void go(){
 ? ? ? ?
 ?  }
}
public class ?teacher extends person{
 ? ?
}
public static void main(String[] args)
{ ? 
 ? ?// Object>person>studnet
 ? ?//Object>person>teacher
 ? ?Object o=new student();
 ? ?System.out.print(o instanceof person); true
 ? ?System.out.print(o instanceof student); true
 ? ?System.out.print(o instanceof object); ? true
 ? ?System.out.print(o instanceof teacher); ?flase
}
总结 ?System.out.print(A instanceof B);/当A与B有关系时，编写通过，否则，编译不通过
类型的转换 ?父 ? ?子
 高 ? ? ? ?低
 ? ?//父类转换为子类时，才能调用子类独有的方法
 ? ?person ?p=new studnet();
 ? ? student s=(student) p;
    s.go();
低 ? ? ?高
 ? ?//子类转换为父类可能会丢失自己本来的一些方法
 ? ?student s=new studnet();
 ? ?person p=s;
?

public class person{
 ? ?//2
 ?  {
 ? ? ? System.out.print("匿名代码块"); 
 ?  } 
 ? ?//1最先执行 只会执行一次 跟着类一起执行
     ?static{
 ? ? ? ? ?System.out.print("静态代码块"); 
 ? ?  }
 ? ?//3
 ? ?public person(){
 ? ? ? ?System.out.print("构造方法") 
 ?  }
}
?

抽象类

abstract 抽象类 单继承 extends

//abstract 抽象方法，只有方法名字，没有方法的实现
public abstract void doSomething();
1,不能new这个抽象类，只能靠子类去实现它：约束
2，抽象类中可以写普通的方法
3，抽象方法必须写在抽象类中
抽象类可以提高开发效率