面向对象基础知识（三大特性）

面向对象

属性+方法=类

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

三大特性：

• 封装
• 继承
• 多态

方法

方法的定义

• 修饰符
• 返回类型
• break：跳出switch， 跳出循环和return：代表方法结束了，返回一个结果
• 方法名：注意规范（驼峰命名，见名知意）
• 参数列表：参数类型，参数名
• 异常抛出

方法的调用

• 静态方法 ： 类名.方法名

• 非静态方法 ：用一个类把类（new） 新建一个对象，再用对象名.方法名，进行调用

• 形参和实参

• 值传递和引用传递：传递对象，本质还是值传递

  //引用传递
  public class Demo {
      public static void main(String[] args) {
        Person a=new Person();
          System.out.println(a.name);//null
          Demo.change(a);
          System.out.println(a.name);//Yang
      }
       public static void change(Person person){
          person.name="Yang";
       }
  }
  class Person{
      String name;
  }
  

• this关键字

类和对象的创建

• 使用new关键字创建对象

  类名 对象名= new 方法名

  • 在使用new的时候，对象会自动进行初始化

• 构造器

  • 和类的名字相同
  • 没有返回类型，也不能写viod
  • 作用
    • new本质在调用构造方法
    • 初始化对象值
  • 注意点
    • 定义有参构造之后，如果想用无参构造，显示的定义一个无参的构造

• this . =

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tCV9qm5v-1597630835082)(C:\Users\big熊\Desktop\markDown\photo\构造器.png)]

无参构造

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Pvz5mLsV-1597630835084)(C:\Users\big熊\Desktop\markDown\photo\有参.png)]

有参构造

小结

1. 类与对象：

   类是一个模板：抽象 ，对象是一个具体的实例

2. 方法

   定义、调用

3. 对应的引用

   引用类型：基本类型

   对象是通过引用来操作的：栈---->堆

4. 属性：字段Filed成员变量

   默认初始化：

   ​ 数字：0 0.0

   ​ char： u0000

   ​ Boolean：false

   ​ 引用：null

5. 对象的创建和使用

   必须使用new关键字创建对象，构造器 Person yang = new Person( )

   对象的属性 yang.name

   对象的方法 yang.sleep( )

6. 类

   静态的属性 属性

   动态的行为 方法

三大特性

封装

高内聚，低耦合

属性私有，get/set

get set

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nuGNQPDK-1597630835087)(C:\Users\big熊\Desktop\markDown\photo\get set.png)]

封装的意义

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

继承

• 继承是类跟类之间的的一种关系，（类与类之间还有组合，依赖，聚合等关系）
• 继承关系的两个类，一个为子类，一个为父类，子类继承父类用extends来表示
• 子类和父类之间，从意义上讲应该有“is a”的关系

在Java中默认继承Object类

java中类只有单继承，没有多继承（一个儿子只有一个爸爸，一个爸爸可以有多个儿子）

私有的东西无法被继承

super

在调用父类构造器的时候，super必须要做子类构造器的第一行

super是调用父类的方法，属性

public void test(String name){
    System.out.println(name);     //值传递
    System.out.println(this.name);//调用子类
    System.out.println(super.name);//调用父类
}

注意点

super

1. super调用父类的构造方法，必须在构造方法的第一个
2. super必须只能出现在子类的方法或者构造方法中
3. super和this不能同时调用构造方法

与this的区别

1. 代表的对象不同

   this：本身调用者这个对象

   super：代表父类对象的应用

2. 前提

   this：没有继承也可以使用

   super：只有在继承条件才能够使用

3. 构造方法

   this（）：本类的构造

   super（）：父类的构造

重写

重写需要有继承关系，子类重写父类的方法！！

重写，子类的方法和父类必须一致，但方法体必须不同

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大但不能缩小：public->protected->default->private
4. 抛出异常：范围，可以缩小，但不能扩大：classnotfoundexception–>exception

为什么要重写：

1. 父类的功能，子类不一定需要，或者不一定满足

多态

多态存在的条件

• 有继承关系
• 子类重写父类方法
• 父类引用指向子类对象

多态主要事项

1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系，类型转换异常！classcastexception
3. 存在条件，继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new Son（）
   • static 方法：属于类，它不属于实例
   • final 常量：
   • private 方法：

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

//Object->String
//Object->Person->Student
//Object->Person->Teacher
Object object = new Student();

System.out.println(object instanceof Student);//true
System.out.println(object instanceof Person);//true
System.out.println(object instanceof String);//false
System.out.println(object instanceof Teacher);//false
System.out.println(object instanceof Object);//true
System.out.println("===================================");
Person person = new Person();
System.out.println(person instanceof Student);//false
System.out.println(person instanceof Person);//true
//System.out.println(person instanceof String);编译报错
System.out.println(person instanceof Teacher);//false
System.out.println(person instanceof Object);//true
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 String);编译报错
//System.out.println(student instanceof Teacher);编译报错
System.out.println(student instanceof Object);//true
System.out.println("===================================");
   }

//类型之间转化：父    子

//高                   低
Person student = new Student();

//student 这个对象转换为Student类型，我们就可以使用Student类型的方法了
((Student)student).go();


/*
        //子类转换为父类，可能会丢失自己本来的一些方法
        Student student = new Student();
        student.go();
        Person person = student;
        */

1. 父类引用指向子类对象
2. 把子类转换为父类，向上转型
3. 把父类转换为子了，向下转型，强制转换
4. 方便方法的调用，减少重复的代码：简洁

抽象类

abstract 抽象类

public abstract class 类名 //抽象类

public abstract 方法名//抽象方法，只有方法名，没有方法实现

//抽象类的所有方法，继承了他的子类，都必须要实现他的方法，除非，他的子类页是抽象的

抽象类的特点

1. 不能new抽象类，只能靠子类去实现：约束
2. 抽象类中可以写普通方法
3. 抽象方法必须在抽象类中

接口

只有规范，自己无法写方法，专业约束！约束和实现分离：面向接口编程

接口的本质是锲约

//抽象类：extends
//类   可以实现接口impls接口
//实现了接口的类，就需要重写接口中的方法

//多继承，利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService {
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
   public void query(String name){

    }

    @Override
    public void timer() {

    }

接口作用

1. 约束
2. 定义一些方法，让不同人实现
3. 默认方法public abstract
4. 默认常量public static final
5. 接口不能被实例化，接口中没有构造方法
6. implements可以实现多个接口
7. 必须要重写接口中的方法