JavaSE--面向对象

JavaSE--面向对象

1. 面向过程 & 面向对象

面向过程思维

• 面向过程思维--步骤清晰，第一步，第二部...

• 适合处理一些简单的问题。顺序结构

面向对象思维

• 物以类聚，分类思维模式。解决问题把总的分类分到单独思考为止，再分类的进行步骤清晰为止
• 对描述的的复杂事务，为了宏观上把握，从整体上合理分析，需要使用面向对象的思路来分析整个系统。但是具体到微观操作，仍需要面向过程区处理。

面向对象的编程本质是：以类的方式组织代码，以对象的组织(封装)的数据。

2. 类与对象

• 对象：是具体的实列。

• 类：是抽象的，对某类事物的整体描述，不能代表具体的事物。类是对象的模板。

//类public class Student{//属性String name;int age;//方法public void study(){System.out.println("在学习")}
}
//类是抽象的，实列化。
//类实列化后返回一个对象
Student xiaoming=new Student();//具体的人new

3.使用New来创建对象

• 使用nwe创建后除了分配内存空间，默认进行初始化，以及对类中的构造器的调用。

• 类中的构造器也成为构造方法，在进行创建对象的时候必要调用的。

• 构造方法的特点:

  1. 必须和类名字相同
  2. 必须没有返回类型，也不能写void

  作业：

  1. 一个来什么都不写，它也会存在一个方法
  2. 使用new关键字，本质还是在调用构造器。用来初始化值

  public class Student{//构造方法public class(){}
  }
  

​ 值传递和引用传递(具体的值可以改变，如对象。本质还是值传递)

4.面向对象的三大特性

1.封装（数据的隐藏）

通常禁止直接访问一个对象的中数据的实际表示，应该通过操作接口来访问，成为信息的隐藏

• 属性私有：get & set
• 作用：
  1. 提高了程序的安全性，保护数据
  2. 隐藏代码实现的细节
  3. 统一接口
  4. 系统的可维护性增加了

2.继承

• Java类只有单继承，没有多继承
• 继承是类和类之间的一种关系，除此之外，还有依赖，组合，聚合。

super--this

• super调用父类的构造方法，必须在构造方法的第一个
• super只能出现在子类方法或构造方法中
• super和this不能同时调用构造方法
• this是本类的构造方法
• this本身调用这个对象

方法的重写

1. 重写需要有继承关系，子类重写父类的方法
2. 方法名和参数列表必须相同
3. 修饰符：范围可以扩大但不能缩小： public>protected>Default>Private
4. 抛出异常：范围可以缩小，不能扩大：
5. 子类的方法和父类方法必须一致，方法体不同。

多态

多态存在条件

1. 有继承关系
2. 子类重写父类方法
3. 父类引用指向子类对象

多态的注意点：多态是方法的多态，属性没有多态

不能 重写的方法：

1. static方法属于类，不属于实列
2. final 常量
3. private

instanceof

判断两类之间是否存在父子关系

//Object > Person > Student
//Object > Person > Teacher
//Object > String
Object object =new Student ();System.out.println(object instanceof Student);//tureSystem.out.println(object instanceof Person);//tureSystem.out.println(object instanceof Object);//tureSystem.out.println(object instanceof Teacher);//falseSystem.out.println(object instanceof String);//false

static(静态类)

• 静态属性 (静态变量) ---调用时可以直接调用(类名.属性)

• 静态方法------调用时可以直接调用(类名.方法)

• 静态代码块---和类一起执行，只进行第一次

• 静态包---可以直接用方法

  package oop.Demo09;
  import static java.lang.Math.random; //导入的静态包
  public class Student {{System.out.println("匿名代码块");}static{System.out.println("静态代码块");}static String name;//静态属性static int age;    //静态属性String gender;     //非静态属性public void run(){System.out.println("非静态方法");}public static void go(){System.out.println("静态方法");}public static void main(String[]args){System.out.println(random());//静态包的方法Student.name=("Lisi"); //静态属性Student.age=18; //静态属性Student s1=new Student();s1.gender=("男");  //非静态属性//调用s1.run();//非静态方法的调用go(); //静态方法的调用}
  }
  //运行结构
  静态代码块
  0.9773971854846296
  匿名代码块
  非静态方法
  静态方法
  

抽象类(abstract)

• 抽象类有子类来实现---》单继承。接口可以是多继承

• 抽象方法只能定义，不能实现

• 抽象方法必须在抽象类中

• 抽象类可以有普通方法

接口(interface)

• 接口不能实列化，只能定义
• implements必须重写方法然后实现

//interface来定义接口
public interface UserServes {//默认属性public static finalint age=18;//默认方法public abstractvoid add();void delete();void update();void query();
}
//implements来实现接口
public class UserServiseimpl implements UserServes{@Overridepublic void add() {}@Overridepublic void delete() {}@Overridepublic void update() {}@Overridepublic void query() {}
}

内部类

内部类就是在一个类的内部在定义一个类，比如A类中定义一个B类，那么B类相对A类成为内部类，而A类相对B类就是外部类。

1. 成员内部类
2. 静态内部类
3. 局部内部类
4. 匿名内部类