java学习记录九：面向对象:对象的继承

一、匿名对象

1.匿名对象解释

没有变量接收的新创建的对象，只能使用一次。

2.格式

 //匿名对象
        new Student("aa",18).show();// 没有名字的对象，调用方法
     

3.使用注意点

• 匿名对象只能使用一次

二、垃圾回收机制

当堆内存的对象没有变量指向时，会被回收

三、面向对象第二大特性:继承

1.继承解释

java中类和js的原型差不多。都是为了创建对象服务。使对象拥有各自的属性和方法，也 有相同的属性和方法。
子类继承后会拥有父类的成员方法和成员变量了。提高代码的复用性，让类与类直接产生了关系，作为多态的前提。
在java中指的是“一个类”可以“继承自”“另一个类”。 "被继承的类"叫做: 父类/超类/基类，"继承其他类的类"叫做:子类。继承后，“子类”中就“拥有”了“父类”中所有的成员(成员变量、成员方法)。 “子类就不需要再定义了”。

2.继承语法

extends关键字

public class 父类名{

}

public class 子类名 extends  父类名{
 //j继承语法
}

3.继承使用注意点

• Java是单继承的，一个类只能继承一个直接父类,但是一个父类可以有多个子类。

四、继承后子类访问父类成员规则

• 父类构造方法：有参构造方法子类不能继承，子类直接new会报错，无参构造方法也不会继承，不会报错是因为子类new时，系统会自动创建一个无参构造方法，所以子类引用super来调用父类的构造方法创建对象。
• 私有成员：使用parvate修饰的成员，子类可以继承，但是无法访问，要区分继承和访问。
• 非私有成员：可以继承和访问，当通过“子类”访问非私有成员时，先在子类中找，如果找到就使用子类的，找不到就继续去“父类”中找。即子类有这个非私有成员就使用子类的，没有就访问非私有父类的。要是子类的这个成员是私有的，父类是非私有的，不能访问，会报错。要是父类是私有的，子类是非私有的，可以方法，是访问的子类的。

五、一个类文件定义多个类

一个类文件里面只能有一个public类，该类的类名和文件名一致，还可以有其他类，但是其他类不能再写public。只能有一个public修饰的类，且该类的类名要和文件名一致。

六、方法重写

1.方法重写解释

子类和父类出现一模一样的方法时（返回值类型，方法名和参数列表都相同时），会出现覆盖效果，也称为重写或者复写，要区分方法重载。
方法重载是在一个类中，不是父子类，而且只有参数个数不同时，才会出现。

2.重写写法

//父类
class Fu{
    public void method(){
        System.out.println("Fu method");
    }
}
//子类
class Zi extends Fu{
     //重写method方法
    @Override
    public void method() {
        System.out.println("Zi method");
    }

}

可以用@override注解标识，如果不是重写的方法标识，就会报错。
权限修饰符可以不一样，子类重写父类的方法的访问权限不能低于父类的访问权限,一般都是相同的。
public - protected - 默认 - private

super.方法（）
会在重写方法里调用父类的要重写的方法，保留了父类的方法功能。

3.重写注意点

• 权限修饰符可以不一样，子类重写父类的方法的访问权限不能低于父类的访问权限,一般都是相同的，public - protected - 默认（不写） - private。
• 一定要是父子类关系。
• 子类中重写的方法返回值类型,方法名,参数列表一定要和父类一模一样。
• 子类中重写的方法可以使用@Override注解进行标识,如果不是重写的方法使用@Override注解标识就会报错。
• 当父类的方法不能满足子类的时候,就需要重写了。

七、this关键字

1.this解释

this存储“当前对象的引用”
this可以方法本类的成员属性、成员方法和构造方法

2.写法

public class Student{
    String name = "张三";
     public Student(){
        System.out.println("空参构造方法...");
    }
      public Student(String name) {
        this();
        //调用另一个构造方法即上面的空参构造方法
        //当使用this()调用另一个构造方法时，此代码必须是此构造方法的第一句有效代码。这个this()必须放在第一行
        //在使用this访问本类的构造方法时，只能在本类的构造方法使用
        //本类构造方法之间不能同时相互调用，即在无参构造方法里调用有参，有参里调用无参，会进行死循环。所以不能相互调用
        //this(参数)是访问有参的构造方法
        System.out.println("有参构造方法...");
    }
    public void show(){
        System.out.println("name = " + this.name);// 张三，访问本类的成员属性
         this.eat();//访问本类的成员方法，在本类中调用其实可以省略this
    }
    public void eat(){
        System.out.println("eat方法...");
    }
}

3.this使用注意点

• this可以访问本类的成员变量: this.成员变量 一般用来区分同名的成员变量和局部变量
• this可以访问本类的成员访问: this.成员方法名(实参);
• this可以访问本类的构造方法:
• 空参构造: this();
• 有参构造: this(实参);
  注意:
  1.只能在本类的构造方法中使用this调用其他构造方法
  2.在本类的构造方法中使用this调用其他构造方法,必须放在该构造方法的第一行,否则会报错
  3.两个构造方法不能使用this同时相互调用

八、super关键字

1.super解释

super存储“父类对象”的引用
super可以访问父类的成员属性、成员方法和构造方法。
super一定是在子类中。
super是表示父类，可以看作是父类的当前对象

2.super写法

class Fu{
    int num = 100;
   //父类成员方法
     public void method1(){
        System.out.println("Fu method1...");
          public Fu(){   //父类构方法
        System.out.println("Fu 类的空参构造方法..");
    }
    public Fu(String name, int age) {
  
        System.out.println("Fu 类的有参构造方法..");
    }
    }
}

class Zi extends Fu{
    int num = 10;
    //子类构造方法
      public Zi(){
        super();// 调用父类的空参构造方法，必须放在第一行,这样可以使用父类的构造方法来创建有参的子类对象。
        //要区分好继承和访问，继承的不一定能访问，能访问的一定继承了。
        System.out.println("Zi 类的空参构造方法..");
    }
    public Zi(String name,int age){
        super(name,age);// 调用父类的有参构造方法，必须放在第一行，这样new Zi时也能给子类对象赋值。
         System.out.println("Zi 类的有参构造方法..");
    }
 @Override
    public void method1(){ //重写的同时还可以调用父类的方法
        super.method1();// 调用父类的method1方法
        System.out.println("Zi method1...");
    }
    public void show(){
        int num = 1;
        System.out.println("局部变量num:"+num);// 1
        System.out.println("Zi 类中的num:"+this.num);// 10
        System.out.println("Fu 类中的num:"+super.num);// 100

      }
}

3.super使用注意点

• super可以访问父类的成员变量: super.成员变量 一般用来区分父子类中同名的成员变量,要是没有就去爷爷类，所有类的父类都继承object类。
• super可以访问父类的成员方法: super.成员方法(实参); 一般用来在子类中访问父类的成员方法
• super可以访问父类的构造方法:
• 空参构造: super();
• 有参构造: super(实参);
  注意:
  1.子类的构造方法默认会调用父类的空参构造方法
  2.super访问父类的构造方法,可以用来初始化从父类继承过来的属性
  3.在子类的构造方法中,使用super调用父类的构造方法,必须放在子类构造方法的第一行

九、继承特点

• java只支持单继承,只能有一个父类,不可以有多个父类，但是一个父类可以有多个子类。
• 可以多层继承

十、抽象类

1.抽象类解释

使用abstract关键字修饰的类就是抽象类，它不能创建对象，只能给子类继承，一般抽象类都是用来做为父类。

2.写法

修饰符 abstract class 类名{
    
}

3.抽象方法

1.抽象方法解释

没有方法体,使用abstract修饰的方法就是抽象方法,抽象方法一般都是作为方法模板，给子类继承后重写使用,因为子类肯有不同的实现，父类有抽象方法后，子类必须重写。

2.写法

//修饰符 abstract 返回值类型 方法名(形参列表);
	public abstract void work();//抽象方法没有方法体

4.使用抽象类的注意点

• 抽象类不能被创建对象，就是用来做“父类”，被子类继承的。
• 抽象类不能被创建对象，但可以有“构造方法”——为成员变量初始化。
• 抽象类中可以没有抽象方法,但抽象方法必须定义在抽象类中
• 子类继承抽象类后,必须重写抽象类中所有的抽象方法,否则子类必须也是一个抽象类

十一、模板设计模式

1.设计模式解释

设计模式就是解决问题的固定思路，也就是代码设计思路经验。

2.抽象模板设计模式

抽象类体系的就是模板设计思想，
抽象方法作为填充模板，各个子类重写填充模板。抽象类中再定一个主方法，调用抽象方法，这样子类调用这个方法时，会自动调用子类重写的抽象方法，实现不同的功能。

3.设计模式实现步骤

• 定义抽象父类作为模板
• 在父类中定义"模板方法"— 实现方法(通用模板)+抽象方法(填充模板)
• 子类继承父类,重写抽象方法(填充父类的模板)

十二、fianl关键字

1.final解释

被final修饰后不可变，可以修饰类，方法和变量。

2.final写法

//权限修饰符 final class 类名 {}
  

//例如:
public final class FinalClassFu {
  // final修饰基本数据类型
        final int NUM = 10;
        // NUM = 20;// 编译报错,final修饰的变量只能赋值一次,不能重复赋值
 public final void show(){

    }
}
public class FinalClassZi /*extends FinalClassFu*/ {
    // FinalClassFu类被final修饰了,所以不能被继承，下面的代码假装已继承
    
    /*@Override
    public void show() {

    }*/
    // 无法重写父类中的show方法,因为父类中的show方法被final修饰了
}

3.fianl的使用注意点

• 被final修饰的类不可以被继承。
• 被修饰的方法不可以重写，
• 被修饰的变量只能赋值一次。
• 一般都是定义的时候赋好值，也可以通过构造方法赋值一次。
• 被final修饰的常量名称，一般都有书写规范，所有字母都大写。

十三、statci关键字

1.static关键字解释

static是一个静态修饰符关键字，表示静态的意思,可以修饰成员变量和成员方法以及代码块，不能修饰局部变量。
当 static修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。没有被static修饰的成员变量是每个对象独有的，每个对象修改都不影响其他对象的这个值，statci修饰的成员变量，相当于一个公关的变量，给所有对象使用。

2.static用法

public class Person {
 // 非静态变量
    String name;// 姓名
    // 静态变量
    static String country;// 国籍
     public Person() {
    }
    public Person(String name, String country) {
        this.name = name;
        this.country = country;
    }
    // 非静态方法
    public void method1(){
        System.out.println("Person method1...");
    }

    // 静态方法
    public static void method2(){
    //静态方法中不能直接访问非静态成员变量和非静态成员方法
        //System.out.println("非静态的成员变量:"+name);// 编译报错
          //method1();// 编译报错
           //静态方法中只能直接访问静态成员变量和静态成员方法
        System.out.println("静态成员变量:"+country);
        method4();
        //报错，静态方法不能出现this
       // this.method4();
        System.out.println("Person method2...");
    }
    //静态方法
    public static void method4(){
        System.out.println("静态 method4方法");
    }
}

3.static使用注意点

• 静态修饰符关键字，可以修改成员变量和成员方法和代码块
• 被修饰的变量变成公共的了。每个对象都能使用，且每个对象都能修改，会影响其他对象。这个成员变量是属于类的。一般叫静态成员变量/类变量。
• 访问一般是类名.静态成员变量。也能通过对象访问，但是 不推荐。
• 静态方法也是类名.方法名（），也能通过对象，但是不推荐。
• 静态方法不能直接访问非静态方法，在类里面创建的方法一定要注意是否是静态方法。
• 静态方法里不能出现this关键字。
• 一般static是使用开发一些工具类，通过类名直接调用方法来实现某种功能，不用创建对象，十分的方便。
• 静态方法中只能直接访问静态成员变量和静态成员方法
• 非静态方法中可以直接访问一切成员变量和成员方法，既可以访问静态和非静态的。