java基础笔记----面向对象的三大特性

Posted 2020-10-24 lvsling

简介：面向对象的三大特性就是封装，继承，多态，是面向对象的核心。

1. 封装
   1. 简介：封装是类的边界，可以对数据起到保护作用
   2. 特性：属性私有，提供公开的get/set方法
      1. 属性私有：private 数据类型 变量名；---->private修饰的属性只能在本类使用
      2. 公开的get/set方法 public修饰---- >在任何类中都可以使用
         1. get方法：----获取属性的值

            public 数据类型 getXxx(){

                return this.属性名

            }

         2. set方法：----修改属性的值

            public void setXxx(数据类型 变量名){

                this.属性名=变量名

            }

package com.lvsling.test;   public class Student {     private String name;     private int age;     private String clazz;     public Student() {         super();         // TODO Auto-generated constructor stub     }     public Student(String name, int age, String clazz) {         super();         this.name = name;         this.age = age;         this.clazz = clazz;     }     public String getName() {         return name;     }     public void setName(String name) {         this.name = name;     }     public int getAge() {         return age;     }     public void setAge(int age) {         this.age = age;     }     public String getClazz() {         return clazz;     }     public void setClazz(String clazz) {         this.clazz = clazz;     }      }

 

1. 继承
   1. 思想：类和类的共性，提取出来定义到父类中，由子类去继承。
   2. 语法： 关键字extends ----- >class 子类名 extends 父类名
   3. 特点：单继承-----一个子类只能有一个直接父类，一个父类可以有多个子类
   4. 子类对象的创建过程：
      1. 分配空间（父类和子类）---------给所有属性赋默认值
      2. 递归的创建父类对象
      3. 初始化本类属性----------给属性赋初值
      4. 调用本类构造方法------------给属性第三次赋值

package com.lvsling.test;   public class Monitor extends Student {     private String monitor;       public Monitor() {         super();     }       public Monitor(String monitor) {         super();         this.monitor = monitor;     }       public String getMonitor() {         return monitor;     }       public void setMonitor(String monitor) {         this.monitor = monitor;     }          public void testMonitor(){         System.out.println("test----monitor...");     }      }

 

1. 多态
   1. 简介：父类的引用可以指向其不同子类的对象
   2. 使用特点
      1. 子类对象，始终不变
      2. 编译时，只能使用父类中有的方法;
      3. 运行时，子类中覆盖的方法优先执行，没有覆盖的方法，则执行从父类中继承到的方法
   3. 引用类型的相互转换-------目标类型和源类型必须兼容（存在继承关系）。
      1. 自动类型转换（向上转型---装箱）-----目标类型>源类型；
      2. 强制类型转换（向下转型----拆箱）-----目标类型<源类型；

         注意：向下转型时，父类引用指向子类对象，必须和要转换的类型一致，否则只能保证编译时ok，运行出现ClassCastException

   4. interfaceof关键字---判断引用所指向的对象类型和后面的类型是否兼容
   5. 应用：
      1. 多态用在方法的参数上：方法的形参如果是父类类型，则给该方法传递的实参类型可以是其所有子类的对象
      2. 多态使用在方法的返回值上：方法的形参类型如果是父类类型，则该方法可以返回，其所有子类的对象
   6. 好处：
      1. 对于使用者屏蔽因参数/返回值不同而带来的差异，使用方法的调用更简单，通用灵活。

package com.lvsling.test;   public class Test1{     public static void main(String[] args){         Animal a=new Dog();         a.eat();         a.test();         Dog d=(Dog)a;         d.lookHouse();         if(a instanceof Dog){             d.lookHouse();         }     } } //父类 class Animal{     //封装属性     private String name;     //构造方法     public Animal(){}     public Animal(String name){         this.name=name;     }     public String getName(){         return this.name;     }     public void eat(){         System.out.println("------eat-------");     }     public void test(){         System.out.println("------test-------");     } } //子类 class Dog extends Animal{     //方法覆盖     public void eat(){         System.out.println("------eat骨头-------");     }     public void lookHouse(){         System.out.println("------lookhouse-------");     } } class Cat extends Animal{     public void eat(){         System.out.println("------eatfish-------");     }     public void climbTree(){         System.out.println("------climbTree-------");     } }

 

1. 拓展与提升
   1. 方法修饰符：
      1. private-----本类可用，
      2. 默认（什么都不写）----本类可用，同包可用
      3. protected ----本类可用，同包可用，不同包的子类可用
      4. public ----公共的都可用

         以上4个访问修饰符都可以用来修饰属性和方法，只有public和默认可以修饰类

   2. 方法覆盖：----override
      1. 在子类中，把父类中继承到的方法进行重新实现
      2. 要求：返回值类型，方法名和形参列表都必须相同，访问修饰符可同或者更宽。
      3. 使用：子类对象名.方法名（实参）