java面向对象语法

继承

继承的特性

• 子类拥有父类非 private 的属性、方法。
• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
• 子类可以用自己的方式实现父类的方法。
• Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
• 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

---

继承关键字

继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。

extends关键字

在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

public class Animal { 
    private String name;   
    private int id; 
    public Animal(String myName, int myid) { 
        //初始化属性值
    } 
    public void eat() {  //吃东西方法的具体实现  } 
    public void sleep() { //睡觉方法的具体实现  } 
} 
 
public class Penguin  extends  Animal{ 
}

使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

implements

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

super 与 this

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

this关键字：指向自己的引用。

实例

class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}
 
class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
    this.eat();   // this 调用自己的方法
    super.eat();  // super 调用父类方法
  }
}
 
public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    a.eat();
    Dog d = new Dog();
    d.eatTest();
  }
}

输出结果为：

animal : eat
dog : eat
animal : eat

final 关键字

final 可以用来修饰变量（包括类属性、对象属性、局部变量和形参）、方法（包括类方法和对象方法）和类。

final 含义为 “最终的”。

使用 final 关键字声明类，就是把类定义定义为最终类，不能被继承，或者用于修饰方法，该方法不能被子类重写：

• 声明类：

  final class 类名 {//类体}
  

• 声明方法：

  修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}
  

注： final 定义的类，其中的属性、方法不是 final 的。

重写&重载

重写(Override)

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如： 父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception 是 IOException 的父类，抛出 IOException 异常或者 IOException 的子类异常。

---

方法的重写规则

• 参数列表与被重写方法的参数列表必须完全相同。
• 返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。
• 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。
• 父类的成员方法只能被它的子类重写。
• 声明为 final 的方法不能被重写。
• 声明为 static 的方法不能被重写，但是能够被再次声明。
• 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
• 子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
• 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
• 构造方法不能被重写。
• 如果不能继承一个类，则不能重写该类的方法。

重载(Overload)

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

最常用的地方就是构造器的重载。

重载规则:

• 被重载的方法必须改变参数列表(参数个数或类型不一样)；
• 被重载的方法可以改变返回类型；
• 被重载的方法可以改变访问修饰符；
• 被重载的方法可以声明新的或更广的检查异常；
• 方法能够在同一个类中或者在一个子类中被重载。
• 无法以返回值类型作为重载函数的区分标准。

重写与重载之间的区别

区别点	重载方法	重写方法
参数列表	必须修改	一定不能修改
返回类型	可以修改	一定不能修改
异常	可以修改	可以减少或删除，一定不能抛出新的或者更广的异常
访问	可以修改	一定不能做更严格的限制（可以降低限制）

---

总结

方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。

• (1)方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
• (2)方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
• (3)方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

从编译和运行的角度看：

重载是允许存在多个同名方法，而这些方法的参数不同，对于编译器来说这些是不同的方法，他们的调用地址在编译期就绑定了，

所以：对于重载而言，在方法调用之前；编译器就已经确定了所要调用的方法，称为“早绑定”或者“静态绑定”

​ 而对于多态：只有等到调用的那一刻，解释运行器才会确定所需要调用的具体方法，称为“晚绑定”或者“动态绑定 ”

多态

多态的实现方式

方式一：重写：

这个内容已经在上一章节详细讲过，就不再阐述，详细可访问：Java 重写(Override)与重载(Overload)。

方式二：接口

• \1. 生活中的接口最具代表性的就是插座，例如一个三接头的插头都能接在三孔插座中，因为这个是每个国家都有各自规定的接口规则，有可能到国外就不行，那是因为国外自己定义的接口类型。

• \2. java中的接口类似于生活中的接口，就是一些方法特征的集合，但没有方法的实现。具体可以看 java接口 这一章节的内容。

向下转型

package 面向对象.duotai;

public class dtTest {
    public static void main(String[] args) {
        Person person = new Man("zy", "女", 21);
        person.eat();

        //编译时，无法调用子类定义的新函数。需要向下转型才可调用子类方法和属性
        /**
         * 使用强制转换时，可能出现ClassCastException异常
         */
        Man man = (Man)person;
        man.sport();

        /*
             a instanceof A
            判断对象a是否是类A的实例：是 返回true  不是返回false

            使用场景：
                为了避免在向下转型时出现ClassCastException异常，我们在向下转型之前可以用
                instanceof 判断，当返回true时，就进行向下转型，否则不可以
         */
        System.out.println(man instanceof Person);//true
    }
}

抽象类

abstract

抽象类：

抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。

一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。

抽象类可以包含抽象方法和非抽象方法。

抽象方法

抽象方法是一种没有任何实现的方法，该方法的具体实现由子类提供。

抽象方法不能被声明成 final 和 static。

任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。

如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

抽象方法的声明以分号结尾，例如：public abstract sample();。

封装

接口

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

接口与类相似点：

• 一个接口可以有多个方法。
• 接口文件保存在 .java 结尾的文件中，文件名使用接口名。
• 接口的字节码文件保存在 .class 结尾的文件中。
• 接口相应的字节码文件必须在与包名称相匹配的目录结构中。

接口与类的区别：

• 接口不能用于实例化对象。
• 接口没有构造方法。
• 接口中所有的方法必须是抽象方法，Java 8 之后 接口中可以使用 default 关键字修饰的非抽象方法。
• 接口不能包含成员变量，除了 static 和 final 变量。
• 接口不是被类继承了，而是要被类实现。
• 接口支持多继承。

接口特性

• 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
• 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
• 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

抽象类和接口的区别

• \1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
• \2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
• \3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
• \4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

枚举

包

属性&局部变量

类中属性的使用
    1.相同点
     1.1 定义变量的格式
     1.2 先声明后使用
     1.3 变量都有其作用域
    
 	2.不同点
    	2.1 在类中的位置不同
    		属性：直接定义在类的一对{}内
    		局部变量：在方法内，方法形参，代码块内，构造函数内，构造函数形参
    
    	2.2 关于权限修饰符的不同
    		属性：可以使用public、private、缺省、protected... ---> 封装性
    		局部变量：不可以进行修饰
    
    
    	2.3 默认初始值不同
    		属性：按基本类型的初始值
    		局部变量：没有默认值，声明时必须赋值
    
    	2.3 在内存中的位置不同
    		属性：在堆中
    		局部变量：栈中

构造器

package 面向对象;


/*
    1.如果没有构造器，系统提供一个默认的构造器
    2.如果自定义了构造器，系统不提供默认构造器，如果要空参构造器，此时需要自己再定义一个空参构造器
    3，一个类中可以定义多个构造器，彼此重载
 */

public class EncapsulationTest {
    public static void main(String[] args) {
        Lover zy = new Lover();
        zy.setName("一颗栗栗子");
        zy.setSex("女");
        zy.setAge(21);
        System.out.println("zy.getName() = " + zy.getName());
    }
}

Lover类

package 面向对象;

public class Lover {
    private String name;
    private String sex;
    private int age;


    //构造器
    public Lover() {
        System.out.println("空参构造器");
    }

    public Lover(String name,String sex,int age) {
        System.out.println("自定义构造器");
        this.name = name;
        this.sex = sex;
        this.age = age;
    }


    public void setName(String name) {
        this.name = name;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public String getSex() {
        return sex;
    }

    public int getAge() {
        return age;
    }
}

运行结果

空参构造器
zy.getName() = 一颗栗栗子

单例模式

饿汉式

package 面向对象.SingleTon;

/*
    单例设计模式：
     1、所谓类的单例设计模式,就是采用一定的方法保证整个软件系统中，对于某个类只存在一个设计模式


     2.如何实现

     3.区分饿汉和懒汉式
            饿汉：先创建好了实例   坏处：对象加载时间过长
            懒汉式： 调用getInstance()的时候再创建实例   好处：饿汉式线程安全


 */
public class SingtonTest {
    public static void main(String[] args) {
//        Bank bank = new Bank();

        Bank bank1 = Bank.getInstance();
        Bank bank2 = Bank.getInstance();

        System.out.println(bank1 == bank2);//true 证明是同一个实例


    }

}

//饿汉式
class  Bank{

    //1.私有化类的构造器
    private Bank() {

    }

    //2. 内部创建类的对象
    //要求此对象也必须声明为静态的
    private static Bank instance = new Bank();

    //3. 提供公共的静态方法，返回类的对象
    public static Bank getInstance() {
        return instance;
    }



}

懒汉式

package 面向对象.SingleTon;

public class SingletonTest2 {

    public static void main(String[] args) {

        Order order1 = Order.getInstance();
        Order order2 = Order.getInstance();
        System.out.println(order1 == order2);//true



    }
}

//懒汉式
class  Order{
    //1.私有化类的构造器
    private Order() {

    }

    //2. 内部创建类的对象
    //要求此对象也必须声明为静态的
    private static Order instance = null;

    //3. 提供公共的静态方法，返回类的对象
    public static Order getInstance() {
        if (instance == null) {
            instance = new Order();
        }
        return instance;
    }
}