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

末蓝、 2021-09-08 08:46 276阅读 0赞

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

*  一、匿名对象
 *   *  1.匿名对象解释
     *  2.格式
     *  3.使用注意点
 *  二、垃圾回收机制
 *  三、面向对象第二大特性:继承
 *   *  1.继承解释
     *  2.继承语法
     *  3.继承使用注意点
 *  四、继承后子类访问父类成员规则
 *  五、一个类文件定义多个类
 *  六、方法重写
 *   *  1.方法重写解释
     *  2.重写写法
     *  3.重写注意点
 *  七、this关键字
 *   *  1.this解释
     *  2.写法
     *  3.this使用注意点
 *  八、super关键字
 *   *  1.super解释
     *  2.super写法
     *  3.super使用注意点
 *  九、继承特点
 *  十、抽象类
 *   *  1.抽象类解释
     *  2.写法
     *  3.抽象方法
     *   *  1.抽象方法解释
         *  2.写法
     *  4.使用抽象类的注意点
 *  十一、模板设计模式
 *   *  1.设计模式解释
     *  2.抽象模板设计模式
     *  3.设计模式实现步骤
 *  十二、fianl关键字
 *   *  1.final解释
     *  2.final写法
     *  3.fianl的使用注意点
 *  十三、statci关键字
 *   *  1.static关键字解释
     *  2.static用法
     *  3.static使用注意点

# 一、匿名对象 #

## 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是使用开发一些工具类，通过类名直接调用方法来实现某种功能，不用创建对象，十分的方便。
 *  静态方法中只能直接访问静态成员变量和静态成员方法
 *  非静态方法中可以直接访问一切成员变量和成员方法，既可以访问静态和非静态的。