Java面向对象

面向过程和面向对象的区别

面向过程

• 步骤清晰，一步一步执行
• 面对过程处理一些较为简单的问题

面向对象

本质就是以类的方式组织代码，以对象的组织（封装）数据

• 分类的思维模式，首先需要考虑解决问题需要哪些分类，最后才对某个分类下的细节进行面向过程的思索
• 面向对象适合处理复杂的问题，适合处理多人协作的问题
• 类：抽象实例化
• 类实例化之后会返回一个自己的对象

对于描述复杂的事物，为了从宏观上把我，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统，但是具体到微观操作，仍需要面向过程的思路去处理

类和对象

1. 类是一个模板，对象是一个具体的实例
2. 方法，调用
3. 对应的引用，对象是通过引用来操作的
4. 属性：字段Field 成员变量；默认初始化

对象的创建和使用

1. 必须使用new关键字创建

类名 名称 = new 类名；

2. 对象的属性

名称.属性；

3. 对象的方法

名称.方法()；

构造器

• 和类名相同
• 没有返回值
• 当new一个对象的时候就会 调用构造器

构造器作用

• 使用new关键字，本质是在调用构造器
• 用来初始化对象值

注意点

1. 定义有参构造之后，如果想使用无参构造，必须要显示的一个无参的构造
2. 生成构造器快捷键：Alt + Insert

面向对象的三大特征

封装

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

封装的作用

1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 系统可维护性增加

• 属性私有化: get/set
• 关键字（私有）：private

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模；其中使用到extends关键字的意思是“扩展”，子类是父类的扩展；JAVA中只有单继承，没有多继承

修饰符

1. public：公共的
2. protected：受保护的
3. default：默认的
4. private：私有的

• 子类继承了父类，就会拥有父类的全部public方法

• super注意点

• • super调用父类的构造方法，必须在构造器的第一行
  • super必须只能出现在子类的方法或者构造方法中
  • super和this不能同时调用构造方法

• this注意点

• • 代表的对象不通
  • this：本身调用这个对象
  • super：父类对象的应用
  • this在没有继承也可以使用，super只能在继承条件下使用

• 构造方法

• • this()：本类的构造
  • super()：父类的构造

方法重写

重写都是方法的重写和属性无关，重写的修饰符必须是public

• 重写需要有继承关系，子类继承父类

• • 方法名必须相同
  • 参数列表必须相同
  • static方法属于类不能重写
  • final常量，不能重写
  • private属于私有 不能重写
  • 修饰符：范围可以扩大，但不能缩小
  • 抛出的异常：范围可以被缩小，但不能扩大

• 静态方法和非静态方法是有区别的

• • 静态方法：和重写无关
  • 非静态方法：子类重写了父类的方法

多态

• • 子类能调用的方法都是自己的或者继承父类的
  • 父类可以指向子类，但是不能调用子类独有的方法

• 注意事项

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

  • 多态存在的条件：有继承关系，方法需要重写，父类的引用指向子类对象

  • Father f1 = new son();
    

  关键字：instanof

  （类型转换）引用类型，判断一个对象是什么类型

  Father instanof Son //返回布尔值
  

  • 高转低需要强转（父类转子类）

  • ((子类) 父类引用).方法
    

  • 低转高，可能会丢失自己本来的方法（子类转父类）

  • Father f1 =  子类引用;
    

  关键字：static

  • 静态方法，可以通过类名点方法调用

  • 非静态方法可以去调用静态方法，但是静态方法无法调用非静态方法

  • 静态方法跟类一块加载

  • 非静态方法跟对象一块加载

  • 匿名代码块

  • {
        //匿名代码块
    }
    

  • 静态代码块

  • static {
    //一般用来赋初始值
    //静态代码块，跟类一块加载，永久只执行一次
    //最早执行
    }
    

  • 构造方法

  • public Person(){
        //匿名代码块执行之后执行
    }
    

抽象类

关键字：abstract

• 通过关键字来定义抽象类

• 也可以通过abstract来定义抽象方法

• package com.oop.Demo09;
  
  //抽象类
  public abstract class  Action {
  
      //约束：抽象方法，只有方法名字，没有方法实现
      public void doSomething(){
  
      }
  
  }
  

• 抽象方法只有方法名，没有方法实现

• 抽象类的所有方法，继承了它的子类，都必须要实现它的方法

• 不能new抽象类，只能靠子类去实现它

• 抽象方法必须写在抽象类中，但是抽象类中可以写普通方法

接口

关键字：interface，implements

• 接口中的所有定义都是抽象的：public abstract

  • package com.oop.Demo10;
    
    public interface UserService {
        void add();
        void del();
        void alt();
        void query();
    }
    
    

• 接口都需要有实现类,一般接口实现类名称采用接口名加***Impl***

  • 实现接口的类，就必须要重写接口的方法

  • package com.oop.Demo10;
    
    //类 可以实现接口 implements 接口            伪多继承
    public class UserServiceImpl implements UserService,TimService {
    
        @Override
        public void add() {
    
        }
    
        @Override
        public void del() {
    
        }
    
        @Override
        public void alt() {
    
        }
    
        @Override
        public void query() {
    
        }
    
        @Override
        public void timer() {
            
        }
    }
    
    
    

  接口的作用

  • 约束
  • 定义一些方法
  • 接口中的默认方法都是：public abstract
  • 接口的属性都是：public static final
  • 接口不能被实例化，接口中没有构造方法
  • 可以实现多个继承：implements
  • 实现接口，必须要重写接口中的方法

内部类

成员内部类

• 内部类可以获得外部类的属性

• 可以通过类名.方法调用

• 创建内部类对象

• package com.oop.Demo11;
  
  public class Outer {
  
      public static void main(String[] args) {
          Outer outer = new Outer();
          Inner inner = outer.new Inner();
          inner.getID();
  
      }
      private int id=10;
      public void out(){
          System.out.println("This is Outer");
      }
  
      public class Inner{
  
          //获得外部类的私有属性
          public void getID(){
              System.out.println(id);
          }
  
      }
  }
  
  

• Outer outer = new Outer(); //首先创建外部类对象
  outer.new Inner();   //通过外部类来new内部类
  
  

• 一个java类中可以有多个class类，但是只有有一个public class类

局部内部类

• 写在方法中