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，抽象方法必须写在抽象类中
抽象类可以提高开发效率