JAVA面向对象基础篇（一）

目录

面向对象

三大特征

---------------------------------------------------------------------------------------------------------------------------------

一、面向对象

万物皆对象，我们通常把现实生活中的事物抽象为对象，例如人、车、动物等，每个对象都具有各自的状态特征（属性）及行为特征（方法）。

面向对象就是把构成问题的事物分解成一个个对象，建立对象是为了描述某个事物在解决问题中的行为。

类是许多个具有相同属性的行为特征的对象抽象出来的，对象是类的一个实例。

二、三大特征

封装性概念

核心思想就是“隐藏细节”、“数据安全”，将对象不需要让外界访问的成员变量和方法私有化，只提供符合开发者意愿的公有方法来访问这些数据和逻辑，保证了数据的安全和程序的稳定。所有的内容对外部不可见。

封装的好处（优点）：

1）通过隐藏对象的属性来保护对象内部的状态（隐藏信息、实现细节）。

2）提高了代码的可用性和可维护性，因为对象的行为可以被单独的改变或者是扩展（将变化隔离，类内部的结构可以自由修改，增加内部实现部分的可替换性）。

3）禁止对象之间的不良交互提高模块化（良好的封装能够减少耦合）。

4）可以对成员变量进行更精确的控制。

5）容易保证类内部数据间的一致性，从而提高软件的可靠性。

示例

public class Person{
    /**
     * 修改属性的可见性来限制对属性的访问（一般限制为private）
     * name和age属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。
     */
    private String name;
    private int age;
    /**
     * public方法是外部类访问该类成员变量的入口。
     * 通常情况下，这些方法被称为getter和setter方法。
     * 因此，任何要访问类中私有成员变量的类都要通过这些getter和setter方法。
     */
    public int getAge(){
      return age;
    }
​    // 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问。
    public String getName(){
      return name;
    }​
    public void setAge(int age){
      // 采用 this 关键字是为了解决实例变量(属性age)和局部变量(参数age)之间发生的同名的冲突。
      this.age = age;
    }​
    public void setName(String name){
      this.name = name;
    }
}

继承的概念

子类可以继承父类的属性和方法，并对其进行拓展。将其他的功能继承下来继续发展 。

基本格式

class 父类{
 
 }
class 子类 extends 父类{
 
         
}

继承类型

//单继承
public class A
{

}
public class B extends A
{

}

//多重继承
public class A
{

}

public class B extends A
{

}

public class C extends B
{

}

//不同类继承同一个类
public class A
{

}

public class B extends A
{

}

public class C extends A
{

}

注：java不支持多继承！！！！！

​//多继承
public class A
{

}

public class B
{

}

public class C extends A,B
{

}

​

super关键字

关键字super指代父类，可以用于调用父类中的普通方法和构造方法

super()调用父类中无参的构造方法    super(parameters)用来调用与参数匹配的父类中的构造方法

当调用子类构造方法产生子类对象时，先调用父类的构造方法产生父类。

super().方法名（参数）    调用父类中其他的方法

 注意：1.尤其当子父类出现同名成员时，可以用super进行区分  2.super的追朔不仅限于直接父类  3.super和this的用法差不多，this代表类对象的引用，super代表父类的内存空间的标识

示例

  class  Animal{//动物类
    public String name;
    protected int age;
    public   Animal()
    {
    }
    public   Animal(String name,int age)
    {
        this.age=age;
        this.name=name;
    }
    public void eat(String food)
    {
        System.out.println("动物吃"+food);
    }
}
class Dog extends  Animal{//子类无法继承父类中private属性
 public Dog()
 {};
    public  Dog(String name,int age)
    {
        super(name,age);
    }

    public void yell()
    {
        System.out.println("汪汪汪");
    }

}
class Main
{
    public static void main(String[] args)
    {
        Dog dog=new Dog();
        dog.eat("狗粮");//继承了父类的功能
        dog.yell();  //自己拓展的方法
    }
}

多态性概念

同一种类型的对象执行同一个方法时可以表现出不同的行为特征。通过继承的上下转型、接口的回调以及方法的重写和重载可以实现多态。方法的重载本身就是一个多态性的体现。

优点

1、降低使用者的使用门槛

2、方便扩展

实现条件

继承：在多态中必须存在有继承关系的子类和父类。

方法覆写

概念： 在有继承关系的类的之间，子类定义了和父类完全想用的方

要求：1、只能重写成员方法/实例方法，不能重写静态方法（static）

           2、子类方法的权限修饰符>=父类方法

           3、方法覆写的返回值必须相同，至少是向上转型的返回值

向上转型

概念：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。

向上转型的最大意义在于参数用一会。我们可以用一个父类引用，接受所有子类实例。

应用场景：1、直接赋值 Animal animal=new Dog();

                  2、方法参数传递

                  3、方法返回值向上转型

示例

public class Wine {
    private String name;
    
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Wine(){
    }
    
    public String drink(){
        return "品的是 " + getName();
    }
    
    /**
     * 重写toString()
     */
    public String toString(){
        return null;
    }
}
 
public class MT extends Wine{
    public MT(){
        setName("MT");
    }
    
    /**
     * 重写父类方法，实现多态
     */
    public String drink(){
        return "品的是 " + getName();
    }
    
    /**
     * 重写toString()
     */
    public String toString(){
        return "Wine : " + getName();
    }
}
 
public class XF extends Wine{
    public XF(){
        setName("XF");
    }
    
    /**
     * 重写父类方法，实现多态
     */
    public String drink(){
        return "品的是 " + getName();
    }
    
    /**
     * 重写toString()
     */
    public String toString(){
        return "Wine : " + getName();
    }
}
 
public class Test {
    public static void main(String[] args) {
        //定义父类数组
        Wine[] wines = new Wine[2];
        //定义两个子类
        MT mt = new MT();
        JGJ xf = new XF();
        
        //父类引用子类对象
        wines[0] = mt;
        wines[1] = xf;
        
        for(int i = 0 ; i < 2 ; i++){
            System.out.println(wines[i].toString() + "--" + wines[i].drink());
        }
        System.out.println("-------------------------------");
 
    }
}
OUTPUT:
Wine : MT--品的是 MT
Wine : XF--品的是 XF