面向对象编程
本质
以类的方式组织代码，以对象组织(封装)数据
抽象(将像的部分抽离出来)
三大特性
封装
该露的露，该藏的藏
"高内聚，低耦合"，高内聚：就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用
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，抽象方法必须写在抽象类中 抽象类可以提高开发效率
