Java面向对象之封装继承

一、前言

我们上次学过java的方法，现在我们来学习新的一篇，也算是java中比较重要的一节了

面向对象基础是java中核心。

面向对象主要包括封装、继承、多态

我们这节主要讲的是封装，在这之前我们先来了解一下类和对象的定义和关系

什么是对象？

世间一切都是对象，万物解释对象，对象就是看得见摸得着的东西。

什么是类？

类是现实生活中对具有属性和行为同一类的总称。

类和对象的关系？

类是对象的抽象化，对象是类的实例化

类的定义 ？

类是java中的基本概念，java中就是以类为基础的，由类所构成的

怎么创建对象？

创建对象是java中常用的形式

格式：

类名 对象名=new 类名();举例 Phone p=new Phone();

创建对象的作用？

通过创建对象，该类实例化，我们就可以通过创建的对象访问该类下所有成员也可以修改

所访问的成员变量。(不包括private修饰的成员)

创建两个类，

Phone类下：

​

PhoneDemo下：

​

Phone类下：

public class Phone {
    public int price=3999;
    public String brand="华为";
    public static void playGame(){
        System.out.println("这手机可以打游戏");
    }
}
复制代码

PhoneDemo下:

public class PhoneDemo {
    public static void main(String[] args) {
        Phone p=new Phone();//创建对象
        System.out.println(p.brand);
        System.out.println(p.price);
        p.playGame();
    }
}
复制代码

以上我们演示了创建对象的作用功能。

通过对象的修改这里就不一一演示了。

二、封装

封装是把类中的成员用private修饰使他不能被所以改变，然后提供get/set方法对锁封装

的成员进行赋值和赋值限制。

封装的好处？

封装使数据变得更有条理，我们提供的条件可以对外接输入的值进行筛选和判断，比如

设一个年龄，我们可以设置年龄的范围，和年龄的非负，并且给出相应的提示。

封装的演示图：

Student类下：

​

代码：

    public class Student {
        private String name;
        private int age;
        public Student(){}//无参构造
       public Student(String name,int age){// 有参构造
           if(age<0){
               System.out.println("你输入的年龄有误，默认为18岁");
               this.age=18;   this.name=name;}
           else{
           this.age=age;this.name=name;}
       }
       public void setName(String name){//get/set方法
           this.name=name;
       }
       public String getName(){
            return name;
        }
       public void setAge(int age){
           if(age<0){
               System.out.println("你输入的年龄有误，默认为18岁");
               this.age=18;
           }else{
               this.age=age;
           }
       }
       public int getAge(){
           return age;
       }
}
复制代码

StudentDemo类下：

​

代码：

public class StudentDemo {
    public static void main(String[] args) {
        Student s=new Student();//创建无参对象
        s.setAge(20);
        s.setName("张三");
        System.out.println(s.getName()+" ,"+s.getAge());
        s=new Student("李四",-1);//创建对象的同时赋值
        System.out.println(s.getName()+","+s.getAge());
    }
}
复制代码

我们也可以在输入年龄的时候加上Sanner进行键盘上的输入这里就不演示了

​

二、继承

什么是继承呢？

继承在显示生活中也不少见，比如继承财产之类的，在我们java学习中也有类似的使用，

继承者称作子类也叫派生类，被继承者称作父类、基类或超类，objec类是所有类的父类

（后期介绍）

继承的好处与弊端

**好处：**就是提高了代码的维护性（多个代码需要修改，只需要修该一处即可）。

提高了代码的复用性（多个相同的成员可以方法到同一个类中）

**弊端：**继承的缺点就是使代码之间的耦合度高，修改父类子类也会跟着变化

继承的使用场景？

两个有从属关系的，比如猫和动物，学生和人等。

继承的关键词是extends。

继承的格式：

public class  子类名 extends  父类名{}
复制代码

举例：

public class Cat extends Animal{}//猫继承动物类
复制代码

继承的特点：

子类可以拥有父类的非私有方法和成员变量，也可以重写父类的非私有(private修饰的)方法。所有子类的方法都默认访问父类的无参构造

重写的概念：

重写是子类重述父类中的非私有方法，重写的一般特点是方法名相同，格式相同，返回类型相同、方法体不同

如：

fu类中：

public class fu{
  public void  play(){
   System.out.println("fu喜欢打羽毛球");
  }
}
复制代码

zi类中：

public class  zi extends fu{
    public void play(){//对父类的方法重写
   System.out.println("zi喜欢打篮球");
    }
} 
复制代码

还可以这么写，访问权限需要zi类大于等于fu类

fu类中修饰是默认：

public class fu{
   void eat(){
   System.out.println("fu中eat方法");
  }
}
复制代码

zi类中：

public class Zi extends Fu {
    @Override//检测方法重写的正确性
   public void eat() {
        System.out.println("zi中的eat方法");
    }
}
复制代码

zi类中重写：

public class Zi extends Fu {
   // @Override写不写不会影响，这个只是起到辅助作用
   void eat() {
        System.out.println("zi中的eat方法");
    }
}
复制代码

zi还可以：

public class Zi extends Fu {
    @Override
  protected  void eat() {
        System.out.println("zi中的eat方法");
    }
}
复制代码

修饰访问关系：public>protected>默认(不写)>private

当父类的权限修饰符是默认（也就是不写修饰符)，子类重写的修饰方法可以是默认和

默认之前的以此类推。**注：**当父类的权限修饰符是private时，那子类可不是private

之前的。当父类被private修饰时，子类不能重写此类方法。

super关键字

当子类中的成员变量和父类中成员变量同名时，我们想使用父类中的成员变量时，

或者我们重写了父类中方法时，我们还想调用父类中的方法时。此时我们就要使用super

关键字来调用父类中的成员。

super和this的比较

super和this的使用原理差不多，this是解决了局部变量和成员变量同名时，局部变量对

成员的覆盖super是解决子类对父类的覆盖。

当局部变量，成员变量，父类中的变量同名时，访问的是局部变量。可以用this和super改变。

public class fu{
  public int age=40; 
public fu(){}//无参构造
public fu(int age){//带参构造
  this.age=age;}
  public void eat(){
   System.out.println("fu中eat方法");
  }
}

public class Zi extends Fu {
  public  int age=18;
public Zi(){}
public Zi(int age){
  this.age=age;}
    public void eat() {
      super.eat();
        System.out.println("zi中的eat方法");
    }
public void show(){
  int age=1;
  System.out.println(age);//1局部变量的值
  System.out.println(this.age);//18子类成员中的值
  System.out.println(super.age);//40父类中的值
}

public class Demo{
  public static void main(String[] args){
    zi z=new zi();
     z.eat();
     z.show();
  }

}
复制代码