java基础（5）- 面向对象（2）

目录

5.1 继承和多态

5.2访问修饰符

5.4static和final修饰符

---

5.1 继承和多态

1、  什么是继承，继承的特点？

子类继承父类的特征和行为，使得子类具有父类的各种属性和方法。或子类从父类继承方法，使得子类具有父类相同的行为。

特点：在继承关系中，父类更通用、子类更具体。父类具有更一般的特征和行为，而子类除了具有父类的特征和行为，还具有一些自己特殊的特征和行为。

在继承关系中。父类和子类需要满足is-a的关系。子类是父类。

表示父类和子类的术语：父类和子类、超类和子类、基类和派生类，他们表示的是同一个意思。

2、  为什么需要继承？什么时候应该继承？

使用继承可以有效实现代码复用，避免重复代码的出现。

当两个类具有相同的特征（属性）和行为（方法）时，可以将相同的部分抽取出来放到一个类中作为父类，其它两个类继承这个父类。

继承实现了面向对象的原则：write once,only once（编写一次、且编写一次

3、  如何实现继承？

在java语言中，用extends（扩展）关键字来表示一个类继承了另一个类。

在父类中只定义一些通用的属性和方法。

子类自动继承父类的属性和方法，子类中可以定义特定的属性和方法。或子类重新定义父类的属性、重写父类的方法可以获得与父类不同的功能。

4、  什么是方法重写？

如果在子类中定义的一个方法，其名称、返回类型及参数列表正好与父类中某个方法的名称、返回类型及参数列表相匹配，那么可以说，子类的方法重写了父类的方法。

方法重写在不同类，是实现多态的必要条件。

5、  super关键字的用法和位置，super关键字调用父类的构造方法，super关键字调用父类的方法？

在子类的构造方法中，通过super关键字调用父类的构造方法。

如果子类中重写了父类的方法，可以通过super关键字调用父类的方法。

父类：

private String name;
private String sex;
public xinxin1(String name,String sex){
           this.name=name;
           this.sex=sex;
}
public void hello(){
                   System.out.println(“嗨！我是”+name+”我是”+sex+”孩”);
 }

子类：

public xinxin2(String name,String sex)
{
           //调用父类的构造方法
           super(name,sex);
}
public void hello(){
                   System.out.println(“我是新来的！”);
           //调用父类的方法
           super.hello();
}

位置注意：调用父类的构造方法的语句（super语句）必须是构造方法中的第一条语句。

因为创建对象的时候，需要先创建父类对象，再创建子类对象。

注意：创建对象时，先创建父类对象，在创建子类对象。如果没有显示调用父类的构造方法，将自动调用父类的无参构造方法。

6、  一切类的老大（祖先）Object。

所有类都直接或者间接地继承了java.lang.Object类，Object类中定义了所有的java对象都具有的相同行为，是所有类的祖先。

一个类如果没有使用extends关键字，那么这个类直接继承自Object类。

7、  什么是多态？

多态的特征是表现出多种形态，具有多种实现方式。或者多态是具有表现多种形态的能力的特征。或者同一个实现接口，使用不同的实例而执行不同的操作。

8、  为什么需要使用多态？多态的好处？

可以增强程序的可扩展性及可维护性，使代码更加简洁。

不但能减少编码的工作量，也能大大提高程序的可维护性及可扩展性。

9、  如何实现多态？

一般做法是：写一个方法，它只接收父类作为参数，编写的代码只与父类打交道。调用这个方法时，实例化不同的子类对象（new 一个对象）。

更具体的说：

（1）子类重写父类的方法。使子类具有不同的方法实现。

（2）把父类类型作为参数类型，该父类及其子类对象作为参数转入。

（3）运行时，根据实际创建的对象类型动态决定使用那个方法。

在运行时，java虚拟机会根据实际创建的对象类型决定使用那个方法。一般将这称为动态绑定。   

10、多态小结：多态与继承、方法重写密切相关，我们在方法中接收父类类型作为参数，在方法实现中调用父类类型的各种方法。当把子类作为参数传递给这个方法时，java虚拟机会根据实际创建的对象类型，调用子类中相应的方法（存在方法重写时）。

5.2访问修饰符

一、访问修饰符的介绍

信息隐藏是 OOP 最重要的功能之一，也是使用访问修饰符的原因。信息隐藏的原因包括：（1）对任何实现细节所作的更改不会影响使用该类的代码，（2）防止用户意外删除数据。访问修饰符使用的关键字有三个:private（私有） ,protected（保护），public（公共）。他们既可以修饰属性，也可以修饰方法。还有一个就是默认修饰符，就是属性或者方法前面不添加任何访问修饰符，它们的功能如下：

private：只有该类可以访问

protected：该类及其子类的成员可以访问，同一个包中的类也可访问

public：该类或非该类均可访问

默认：相同数据包中的类可以访问

列一个表看起来更加清晰：

二、示例

我们现在可以把类修改一下，定义几个使用不同修饰符的属性和方法。

public class Animals {
    private String name;// 私有属性
    protected boolean gender;// 保护属性
    public int age;//公有属性
    public Animals() {
        System.out.println("新建一个动物");
    }
    public Animals(String name) {
        this.name = name;
        System.out.println("新建一个叫" + name + "的动物");
    }
            //公有方法
    public void eat() {
        System.out.println(name+"我是父类的eat方法，动物吃东西");//name是私有属性，只能本类访问
    }
            //保护方法
    protected void test() {
        System.out.println("保护方法");
    }
            //私有方法
    private void mymethod(){
        System.out.println("私有方法");
    }
}

这个时候也许我们之前的代码就会报错了。首先我们看看Run类：如下图

所有的私有属性和方法都只能在本类中方法所以Run类中访问就会报错。

我们在看看子类Carnivorous中，我们修改eat的方法。

通过访问修饰符，我们就可以限制属性和方法的访问限制了。

5.4static和final修饰符

一、static修饰符

static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。

被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。

只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。

用public修饰的static成员变量和成员方法本质是全局变量和全局方法，是类的所有实例共享同一个static变量。

static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过对象或者类名直接访问，访问语法为：
类名.静态方法名(参数列表...)
类名.静态变量名

用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块。

1、static变量

按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是：对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问，当然也可以通过对象来访问（但是这是不推荐的）。

　对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响。

所以一般在需要实现以下两个功能时使用静态变量：
 （1）在对象之间共享值时
 （2）方便访问变量时

public class Test {
 public static int a;//静态属性
}

我们可以在Run访问这个属性

public class Run {
public static void main(String[] args) {
       //我们可以使用类名直接访问
       Test.a=1;
      //当然我们也可以使用对象来访问，虽然不推荐这样做
       Test t1=new Test();
       Test t2=new Test();
       
       //如果是普通变量，那么每个变量输入各自的对象
       //但是静态变量是所有的对象所共享的
       t1.a++;
       t2.a++;
       System.out.println(Test.a);//输出为3  
   }
}

2、静态方法

静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。

静态方法是类内部的一类特殊方法，只有在需要时才将对应的方法声明成静态的，一个类内部的方法一般都是非静态的。

我们在Test类中添加一个静态方法

public static void hello(){
    System.out.println("静态方法");
}

我们可以直接使用类名访问。

Test.hello();//直接使用类名访问

3、static代码块

static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。例如：

//静态语句块

static{
    Test.a = 3;
    System.out.println("Test类中："+a);
}

运行结果：

Test类中：3

3

静态方法

利用静态代码块在main方法运行之前就运行了。我们可以对一些static变量进行赋值。

二、final修饰符

final可以修饰类、属性和方法，final的作用随着所修饰的类型而不同

1、final修饰类中的属性

无论属性是基本类型还是对象类，final所起的作用都是变量里面存放的“值”不能变。这个值，对于基本类型来说，变量里面放的就是实实在在的值，如1，“abc”等。 而引用类型变量里面放的是个地址，所以用final修饰引用类型变量指的是它里面的地址不能变，并不是说这个地址所指向的对象或数组的内容不可以变，这个一定要注意。

final修饰属性，声明变量时可以不赋值，而且一旦赋值就不能被修改了。对final属性可以在三个地方赋值：声明时、初始化块中、构造方法中。总之一定要赋值。 在Test类中点击一个属性

public final int b=100;//必须赋值，而且不能修改该值。

如果你想在Run类中main方法中修改b的值，就会报错。

例如：类中有一个属性是final Book b=new Book("name")； 那么你不能对p进行重新赋值，但是可以改变p里面属性的值，p.setName('新名称');

2、final修饰类中的方法。可以被继承，但继承后不能被重写。

public final void hi(){
    System.out.println("");//子类不能重写这个方法
}

3、final修饰类。类不可以被继承，也就是不能有子类，俗称太监类。

三、static和final一起使用

static final用来修饰成员变量和成员方法，可简单理解为“全局常量”。对于变量，表示一旦给值就不可修改，并且通过类名可以访问。对于方法，表示不可覆盖，并且可以通过类名直接访问。我们可以在Test类中定义一个常量。常量的命名规范一般是全大写。

public final static int ABC=100;//全局常量