java面向对象

面向对象

面向对象编程(OOP)

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

三大特性：继承，封装，多态

属性+方法–>类

面向过程思想适合处理一些简单的问题

类与对象关系

类是一种抽象的数据类型

对象是具体的

使用new关键字创建对象

构造器

默认会有一个无参构造方法，和类名相同

作用是初始化对象的值

//有参构造
public Person(String name){
    this.name=name;
}

封装

高内聚，低耦合

属性私有：private

提供一些操作这些私有属性的get和set方法

好处：隐藏代码细节，统一接口

继承

1. Java中只有单继承，没有多继承
2. 关键字extends，子类是父类的扩展
3. 继承的本质是某一批类的抽象
4. 所有的类都默认继承Object
5. super调用父类的构造方法，必须在构造方法的第一个
6. super只能出现在子类的方法中
7. super和this不能同时调用构造方法

重写

1. 重写都是方法的重写，和属性无关
2. 父类的引用指向子类
3. 静态方法和非静态方法是有区别的，重写只和非静态有关
4. 只能重写public方法
5. 子类重写父类
6. 参数列表相同，注意和重载的区别
7. 范围可以扩大但不能缩小，和抛出异常的区别
8. 为什么重写：父类的功能子类不一定需要或不一定满足

多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式

1. 动态编译，可扩展性

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

   Person person =new Student();
   

3. 对象能执行什么方法，看左边的类型，若子类重写了父类的方法，则执行子类的该方法

   public class Application {
       public static void main(String[] args) {
           Person person1 = new Person();
           Person person2= new Student();
           person1.test();
           person2.test();
       }
   }
   
   public class Person {
       public String name;
       public int age;
       public void test(){
           System.out.println("person");
       }
   }
   
   public class Student extends Person{
       @Override
       public void test(){
           System.out.println("student");
       }
   }
   
   结果：
       person
   	student
   

4. 父类想用子类的方法，需要强转（向下转型）

5. instanceof

           //Object >> Person >> Student
           //Object >> Person >> Teacher
           //Object >> String
           Object object= new Student();
           System.out.println(object instanceof Student);//true
           System.out.println(object instanceof Person);//true
           System.out.println(object instanceof Object);//true
           System.out.println(object instanceof Teacher);//false
           System.out.println(object instanceof String);//false
           System.out.println("===========================");
   
           Person person=new Student();
           System.out.println(person instanceof Student);//true
           System.out.println(person instanceof Person);//true
           System.out.println(person instanceof Object);//true
           System.out.println(person instanceof Teacher);//false
           //System.out.println(person instanceof String);编译报错
           System.out.println("===========================");
   
           Student student=new Student();
           System.out.println(student instanceof Student);//true
           System.out.println(student instanceof Person);//true
           System.out.println(student instanceof Object);//true
           //System.out.println(student instanceof Teacher);//编译报错
           //System.out.println(student instanceof String);编译报错
   

   static

   public class Person{   
   	{//赋初值
           System.out.println("匿名代码块");
       }
   
       static {//只执行一次
           System.out.println("静态代码块");
       }
   }
   //静态导入包
   import static java.lang.Math.random;
   

   接口

   1. 约束
   2. 定义一些方法，让不同人去实现
   3. public abstract
   4. public static final
   5. 接口不能被实例化，接口中没有构造方法
   6. implements可以实现多个接口

   内部类

   public class Outer {
       private int id;
       public void out(){
           System.out.println("这是外部类");
       }
       public class Inner {
           public void  in(){
               System.out.println("这是内部类");
           }
       }
   }
   
   public static void main(String[] args) {
       Outer outer= new Outer();
       Outer.Inner inner=outer.new Inner();
       outer.out();
       inner.in();
   }
   

   1. 内部类可以获取外部类的私有属性
   2. 一个java类中可以有多个class类，但只能有一个public class
   3. 局部内部类：在方法中定义
   4. 匿名内部类：没有名字初始化类，不用将实例保存到变量中