JavaSE_面向对象

JavaSE

Java ⾯向对象编程OOP

什么是⾯向对象对象编程OOP

类：就是模板，⽤来定义⼀类对象的⽅法和属性，⽐如⼈、学⽣、猫，万物都是有模板，都是可
以定义为类。 (类名⾸字⺟⼤写)

class Student{
 
}
class Person{
 
}
class Cat{
 
}

对象:类的实例化，⽐如 学⽣这个类实例化，就是 XX同学

Student student = new Student();
Cat cat1 = new Cat();
new Persion();

⽅法

• ⽅法是语句的集合，在⼀起完成⼀个功能
• ⽅法包含于类或对象中，即普通⽅法或者类⽅法

继承

• ⼦类继承⽗类的特征和⾏为，使得⼦类对象具有⽗类的⽅法和属性
• ⽗类也叫基类，具有公共的⽅法和属性

多态

• 同⼀个⾏为具有多个不同表现形式的能⼒
• 优点：减少耦合、灵活可拓展
• ⼀般是继承类或者重写⽅法实现

抽象

• 关键词abstract声明的类叫作抽象类，abstract声明的⽅法叫抽象⽅法
• ⼀个类⾥包含了⼀个或多个抽象⽅法，类就必须指定成抽象类
• 抽象⽅法属于⼀种特殊⽅法，只含有⼀个声明，没有⽅法体

Java⾯向对象的中的构造函数和封装

• 什么是构造函数
  1.⼀种特殊的⽅法
  2.创建对象时⽤来初始化对象，每次使⽤new 创建对象的时候，就会使⽤构造函数
  3.与类具有相同的名称，但是没有返回值
  4.Java会⾃动为每个类提供⼀个默认构造函数
  5.如果⾃⼰定义了构造函数，就不再使⽤默认构造函数，如果没有显示的写出默认构造函数，
  则会消失
  注：如果构造函数之间互相调⽤，务必写在⽅法第⼀⾏

• 构造函数种类
  默认 无参 有参

• 构造函数的修饰符
  1.public ⽤的最多，⽤来创建对象
  2.private 私有化构造函数，不给外部创建对象，⽐如⼯具类，或者单例设计模式
  3.default 默认的话，只能在当前包⾥⾯使⽤new 创建对象，⼏乎不⽤

• 什么是封装
  1.封装是把过程和数据包围起来，对数据的访问只能通过已定义的接⼝即⽅法
  2.在java中通过关键字private，protected和public实现封装
  3.什么是封装？封装把对象的所有组成部分组合在⼀起，封装定义程序如何引⽤对象的数据，
  封装实际上使⽤⽅法将类的数据隐藏起来，控制⽤户对类的修改和访问数据的程度。 适当的
  封装可以让代码更容易理解和维护，也加强了代码的安全性
  4.类封装
  5.⽅法封装

• overload（重载，过载）
  在⼀个类⾥⾯，⽅法名字相同，⽽参数不同，和返回类型⽆关

• override（重写，覆盖）
  ⼦类对⽗类的允许访问的⽅法的实现过程进⾏重新编写, 返回值和形参都不能改变
  返回值类型，⽅法名，参数类型以及个数
  ⼦类能够根据需要实现⽗类的⽅法

Java⾯向对象核⼼关键字this

• this关键字
  1.当⼀个对象创建后，JVM会给这个对象分配⼀个引⽤⾃身的指针，这个指针的名字就是 this
  2.只能⽤于⾮静态⽅法体内，静态⽅法和代码块不能出现this
  3.this就是指向当前对象本身

• 使用场景
  1.this(参数类型1 参数名，…) 表示当前类对应的构造函数
  2.⽅法形参和对象的属性重名，⽤this来区分

Java⾯向对象编程之继承

• 继承
  1.⼦类继承⽗类的特征和⾏为，使得⼦类对象具有⽗类的⽅法和属性
  2.⽗类也叫基类，具有公共的⽅法和属性

class ⽗类名称{
 
}
class ⼦类名称 extends ⽗类名称{
 
}

• 特点：
  1.⼦类拥有⽗类的⾮private的属性和⽅法
  2.⼦类可以⽤⾃⼰的⽅式实现⽗类的⽅法 override(重写，覆盖)
  3.实现了代码的复⽤
  4.重写从⽗类那⾥继承来的⽅法的，当调⽤⽅法时候会优先调⽤⼦类的⽅法（默认就近原则）

• 注意：
  1.不⽀持多继承，⽀持多重继承，多重继承提⾼了耦合性，组合优于继承
  2.所有的类都是继承于 java.lang.Object
  3.final关键字 修饰的类，则这个类不可以被继承 修饰⽅法，则这个⽅法不允许被覆盖（重写）

Java⾯向对象编程之继承的super关键词

• super关键字
  1.一个引⽤变量，⽤于引⽤⽗类对象
  2.⽗类和⼦类都具有相同的命名⽅法，要调⽤⽗类⽅法时使⽤
  3.⽗类和⼦类都具有相同的命名属性，要调⽤⽗类中的属性时使⽤
  4.super也是⽗类的构造函数，格式 super(参数) 调⽤super() 必须是类构造函数中的第⼀条语句，否则编译不通过

• 每个⼦类构造⽅法的第⼀条语句，都是隐含地调⽤super()，如果⽗类没有这种形式的构造函
  数，那么在编译的时候就会报错

public class Father {
 public Father(){
 System.out.println("father ⽆参构造函数");
 }
}
public class Children extends Father{
 public Children(){
 //默认存在，写和不写都⾏
 super();
 System.out.println("Child⽆参构造函数");
 }
}

• this()和super()都指的是对象，均不可以在static环境中使⽤
  包括：static变量,static⽅法，static语句块

• 构造函数 super和this
  1.this 和super在构造函数中只能有⼀个，且都必须是构造函数当中的第⼀⾏
  2.当⽗类的构造函数是⽆参构造函数时，在⼦类的构造函数中，不⽤显式super()去调⽤⽗类的
  构造函数,
  3.当⽗类的构造函数是有参构造函数时，如果⼦类的构造函数中不写super()进⾏调⽤⽗类的构
  造函数，编译器会报错

• java继承后类的初始化顺序
  问题：静态代码块、⾮静态代码、⽗类/⼦类⽆参构造⽅法、⽗类/⼦类的⼀般⽅法

public class Father {
 static {
 System.out.println("⽗类静态代码块");
 }
 public Father(){
 System.out.println("father ⽆参构造函数");
 }
 public Father(int age){
 System.out.println("father 有参构造函数");
 }
 public void sleep(){
 System.out.println("father sleep⽅法");
 }
}
public class Children extends Father{
 static {
 System.out.println("Child静态代码块");
 }
 public Children(){
 //super();
 System.out.println("Child⽆参构造函数");
 super.sleep();
 }
 public void sleep(){
 System.out.println("Child sleep⽅法");
 }
}
public static void main(String[] args) {
 new Children().sleep();
 }

Java⾯向对象编程之抽象

• 什么是抽象
  1.当⽗类的某些⽅法不确定时，可以⽤abstract关键字来修饰该⽅法，即抽象⽅法，⽤abstract
  来修饰该类，即抽象类
  2.抽象类将事物的共性的东⻄提取出来，由⼦类继承去实现，代码易扩展、易维护
  3.java中的抽象类和抽象⽅法

//抽象类
abstract class 类名{ }
//抽象⽅法，不能有⽅法主体
abstract 返回类型 ⽅法名();

public abstract class Vehicle {
 
 public abstract void run();
 public void stop(){
 System.out.println("停在路上");
 } }
class Bicycle extends Vehicle{
 @Override
 public void run() {
 System.out.println("⼈⼯驱动");
 } 
}
class Automobile extends Vehicle{
 @Override
 public void run() {
 System.out.println("汽油驱动");
 } }

• 抽象特点
  1.抽象类不能被实例化，因为抽象类中⽅法未具体化，这是⼀种不完整的类，所以不能直
  接实例化，编译⽆法通过
  2.抽象类中不⼀定包含抽象⽅法，但是有抽象⽅法的类必定是抽象类
  3.如果⼀个抽象类中可以没有抽象⽅法，这样做的⽬的是为了此类不能被实例化。
  4.抽象类的⼦类必须给出抽象类中的抽象⽅法的具体实现，否则⼦类也是抽象类，需要⽤
  abstract声明
  5.抽象类不能使⽤final关键字修饰，因为final修饰的类是⽆法被继承

• 抽象方法特点：
  1.抽象类中的抽象⽅法只是声明，不包含⽅法体
  2.抽象⽅法不能⽤private修饰，因为抽象⽅法必须被⼦类实现（覆写），⽽private权限
  对于⼦类来 说是不能访问的
  3.⼀个类继承了⼀个抽象类，那么它必须全部覆写抽象类中的抽象⽅法，当然也可以不全
  部覆写，如果 不覆写全部抽象⽅法则这个⼦类也必须是抽象类

• 构造⽅法，类⽅法（即static 修饰的⽅法）不能声明为抽象⽅法

Java⾯向对象编程之接⼝

• 什么是接口
  是抽象⽅法的集合，接⼝通常以interface来声明，⼀个类通过继承接⼝的⽅式，从⽽来继承
  接⼝的抽象⽅法

interface 名称 [extends 其他的接⼝名] {
 // 声明变量
 // 抽象⽅法
 int getMoney();
}

• 接口的特点：
  1.接⼝的⽅法都是抽象⽅法，默认都是 public abstract，其他修饰符都会报错
  2.接⼝中可以含有变量，但是接⼝中的变量会被隐式的指定为 public static final
  3.类描述对象的属性和⽅法，⽽接⼝则包含类要实现的⽅法
  4.接⼝⽆法被实例化，需要被实现才⾏
  5.⼀个实现接⼝的类，必须实现接⼝内所描述的所有⽅法，否则就必须声明为抽象类

• 接口和类的区别
  接⼝没有构造函数
  1.接⼝⾥可以有静态⽅法和⽅法体
  2.接⼝中所有的⽅法必须是抽象⽅法（JDK8之后就不是）
  3.接⼝不是被类继承了，⽽是要被类实现
  4.接⼝⽀持多继承, 类不⽀持多个类继承

• 接⼝的实现implements
  当类实现接⼝的时候，类要实现接⼝中所有的⽅法，不然类必须声明为抽象的类，使⽤
  implements关键字实现所有接⼝

• 注意：
  1.⼀个类只能继承⼀个类，但是能实现多个接⼝
  2.接⼝能继承另⼀个接⼝，接⼝的继承使⽤extends关键字，和类继承⼀样

• JDK8新特性
  1.interface中可以有static⽅法，但必须有⽅法实现体，该⽅法只属于该接⼝，接⼝名直接调⽤
  该⽅法
  2.接⼝中新增default关键字修饰的⽅法，default⽅法只能定义在接⼝中，可以在⼦类或⼦接⼝
  中被重写
  3.default定义的⽅法必须有⽅法体
  4.⽗接⼝的default⽅法如果在⼦接⼝或⼦类被重写，那么⼦接⼝实现对象、⼦类对象，调⽤该
  ⽅法，以重写为准
  5.本类、接⼝如果没有重写⽗类（即接⼝）的default⽅法，则在调⽤default⽅法时，使⽤⽗类
  定义的default⽅法逻辑

public interface IPay{ 
 // static修饰符定义静态⽅法 
 static void staticMethod() { 
 System.out.println("接⼝中的静态⽅法"); 
 } 
 
 // default修饰符定义默认⽅法 ,默认⽅法不是抽象⽅法，可以不重写也可以重写
 default void defaultMethod() { 
 System.out.println("接⼝中的默认⽅法"); 
 } 
}

// static⽅法必须通过接⼝类调⽤ 
 IPay.staticMethod(); 
 
 //default⽅法必须通过实现类的对象调⽤ 
 new IPay().defaultMethod();

Java⾯向对象编程之InstanceOf关键词和多态

• InstanceOf 关键词
  是Java的⼀个⼆元操作符（运算符）,也是Java的保留关键字

作⽤：判断⼀个类是否实现了某个接⼝，或者判断⼀个实例对象是否属于⼀个类

语法：

//如果该object 是该class的⼀个实例，那么返回true。如果该object 不是该class的
⼀个实例，或者object是null，则返回false
boolean result = object instanceof class
参数：
　　result ：boolean类型。
　　object ：必选项。任意对象表达式。
　　class：必选项。任意已定义的对象类。

• 对象类型强制转换前的判断

Person p1 = new Student();
//判断对象p是否为Student类的实例
if(p1 instanceof Student)
{
 //向下转型
 Student s = (Student)p1;
}

• ⽅法重写 overriede
  1.⼦类对⽗类的允许访问的⽅法的实现过程进⾏重新编写
  返回值和形参都不能改变
  ⽗类的成员⽅法只能被它的⼦类重写
  final 和 static的⽅法不能被重写
  构造⽅法不能被重写
  访问权限不能⽐⽗类中被重写的⽅法的访问权限更低

• ⽅法重载 overload
  1.⼀个类⾥⾯，⽅法名字相同但参数不同，返回类型可以相同也可以不同
  2.⽐如构造函数重载

注意核⼼区分

• override是在不同类之间的⾏为，overload是在同⼀个类中的⾏为

总结：java多态 同⼀个⾏为具有多个不同表现形式或形态的能⼒