本专栏将从基础开始，循序渐进，由浅入深讲解Java的基本使用，希望大家都能够从中有所收获，也请大家多多支持。
专栏地址:26天高效学习Java编程
相关软件地址:软件地址
所有代码地址:代码地址
如果文章知识点有错误的地方，请指正！大家一起学习，一起进步。
如果感觉博主的文章还不错的话，还请关注、点赞、收藏三连支持一下博主哦

本章内容如下

• 面向对象复习
  • 制作标准类
  • 创建对象和使用对象
  • 对象的内存图
  • 匿名对象
• 继承--------------------重点
  • 如何继承
  • 继承后成员访问特点
• 抽象方法
• 模板设计模式
• final 关键字
  • 修饰类\方法\变量
• static关键字
  • 修饰成员变量\成员方法

第一章 面向对象复习

1.1 类和对象

目标:

• 掌握如何定义一个标准类以及创建并使用对象

讲解:

定义一个标准类

• 定义类的格式:

  public class 类名{// 成员变量(private修饰)// 构造方法(空参,满参)// set\get方法// 成员方法(行为)
  }
  

• 案例

  public class Student {// 成员变量---privateprivate String name;// 姓名private int age;// 年龄// 构造方法public Student(){}public Student(String name,int age){this.name = name;this.age = age;}// set\get方法public void setName(String name){this.name = name;}public void setAge(int age){this.age = age;}public String getName(){return name;}public int getAge(){return age;}// 成员方法public void show(){System.out.println(name+","+age);}
  }

创建并使用对象

• 创建对象的格式

  通过调用构造方法创对象:类名 对象名 = new 类名(实参);
  

• 使用对象:

  • 对象访问成员变量

    对象名.成员变量名
    

  • 对象访问成员方法

    对象名.成员方法名(实参);
    

• 案例

  public class Test {public static void main(String[] args) {/*定义一个标准类使用对象*/// 创建对象Student stu1 = new Student();Student stu2 = new Student("张三", 18);// 访问成员变量stu1.setName("李四");stu1.setAge(19);// 访问成员方法stu1.show();// 李四,19stu2.show();// 张三,18}
  }

小结:

• 使用对象
  • 访问成员变量: 对象名.成员变量名
  • 访问成员方法:
    • 无返回值的方法: 对象名.成员方法名(实参);
    • 有返回值的方法:
      • 直接调用: 对象名.成员方法名(实参);
      • 赋值调用: 数据类型 变量名 = 对象名.成员方法名(实参);
      • 输出调用: System.out.println(对象名.成员方法名(实参));

知识点–1.2 对象的内存图

目标

• 理解对象的内存图

讲解

小结

• 只要是new对象就会在堆区开辟一块独立的空间
• 只要调用方法,方法就会被加载进栈
• 只要方法执行完毕,方法就会被弹栈

知识点–1.3 匿名对象

目标

• 理解什么是匿名对象并会使用匿名对象

讲解

匿名对象的概述

什么是匿名对象：就是指"没有名字"的对象。

有名字的对象：Student stu = new Student();stu.show();stu.study();
匿名对象：new Student();

使用匿名对象

• 特点:匿名对象只能使用一次

  public class Test {public static void main(String[] args) {/*匿名对象:概述:没有名字的对象特点:匿名对象只能使用一次使用场景:当某个类的对象只需要使用一次的时候,就可以使用该类的匿名对象例如:方法的参数,方法的返回值*/// 创建对象Student stu1 = new Student("热巴",18);// 有名字的对象stu1.show();stu1.show();System.out.println("==================================");//匿名对象new Student("热巴",18).show();// 没有名字的对象new Student("热巴",18).show();// 没有名字的对象System.out.println("==================================");// 调用method1方法Student stu2 = new Student("热巴",18);// 0x11901method1(stu2);// 有名字的对象传参method1(new Student("热巴",18));// 匿名对象的方式传参数System.out.println("==================================");Student stu3 = method2();// 0x11908stu3.show();// 丽颖,18}public static void method1(Student stu){// 0x11901stu.show();}public static Student method2(){//Student stu = new Student("丽颖",18);// 0x11908//return stu;// 0x11908return new Student("丽颖",18);}}

小结

• 匿名对象：就是指"没有名字"的对象。
• 特点: 只能使用一次

第二章 继承

面向对象语言的三大特征:封装,继承,多态

知识点–2.1 继承概述

目标:

• 能够理解什么继承

讲解:

2.1.1 为什么要有继承

继承常常用于面向对象的编程语言之中，通过继承，一个子类可以获得父类的部分（或全部）的属性、数据和方法。继承又可以分成单继承和多继承。例如，在 Java 中，子类只能有一个父类，所以叫单继承，而在 C++等语言中，一个子类可以有多个父类，所以叫多继承。

在程序中我们可以把一些公有属性给抽象出来形成一个父类，这样做的好处是当子类继承该类时可以少写很多方法，对属性可以进行复用，如下图所示：

2.1.2 继承的含义

继承：在java中指的是“一个类”可以“继承自”“另一个类”。 "被继承的类"叫做: 父类/超类/基类，"继承其他类的类"叫做:子类。继承后，“子类”中就“拥有”了“父类”中所有的成员(成员变量、成员方法)。 “子类就不需要再定义了”。

2.1.3 继承的好处

1. 提高**代码的复用性**（减少代码冗余，相同代码重复利用）。
2. 使类与类之间产生了关系。

小结

• 继承：在java中指的是“一个类”可以“继承自”“另一个类”。 "被继承的类"叫做: 父类/超类/基类，"继承其他类的类"叫做:子类。继承后，“子类”中就“拥有”了“父类”中所有的成员(成员变量、成员方法)。 “子类就不需要再定义了”。

知识点–2.2 继承的格式

目标:

• 能够掌握如何实现继承

讲解:

继承的格式

通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：

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

需要注意：Java是单继承的，一个类只能继承一个直接父类，并且满足is-a的关系,例如:Dog is a Animal, Student is a Person

继承的演示

//人类:
public class Person {// 成员变量String name;int age;// 功能方法public void eat(){System.out.println("吃东西...");}public void sleep(){System.out.println("睡觉...");}
}
老师类: extends 人类
public class Teacher extends Person {double salary;// 独有的属性public void teach(){}// 独有的方法
}
学生类: extends 人类
public class Student extends Person{}
Dog:  extends 人类
public class Dog extends Person{// 语法上是可以的,但不符合现实逻辑(不符合is a的关系)}
测试:
public class Test {public static void main(String[] args) {Teacher t = new Teacher();System.out.println(t.name);System.out.println(t.age);t.eat();t.sleep();}
}

小结

• public class 子类名 extends 父类名{}
  

• 通过继承可以将一些共性的属性,行为抽取到一个父类中,子类只需要继承即可,提供了代码的复用性

知识点–2.3 继承后成员访问规则

目标:

• 能够掌握继承后成员访问规则

讲解:

继承后构造方法的访问规则

• 构造方法不能被继承

  class Fu {// 构造方法Fu(){}Fu(String name,int age){}
  }class Zi extends Fu{}public class Test {public static void main(String[] args) {/*构造方法的访问规则:父类的构造方法不能被子类继承*///Zi zi = new Zi("张三",18);// 编译报错,因为没有继承}
  }

继承后私有成员的访问规则

• 父类的“私有成员”可以被子类继承，但子类不能被直接访问。

  public class Fu{private int num = 100;//私有成员，只能在父类内部使用。private void method(){System.out.println("私有成员方法");}
  }
  public class Zi extends Fu{}
  public class Demo {public static void main(String[] args) {Zi z = new Zi();System.out.println(z.num);// 编译错误z.method();// 编译错误}
  }

继承后非私有成员的访问规则

• 当通过“子类”访问非私有成员时，先在子类中找，如果找到就使用子类的，找不到就继续去“父类”中找。

  public class Fu{int money = 100;public void method(){System.out.println("Fu 类中的成员方法method");}
  }
  public class Zi extends Fu{int money = 1;public void method(){System.out.println("Zi 类中的成员方法method");}
  }
  public class Demo{public static void main(String[] args){Zi z = new Zi();System.out.println(z.money);//1z.method();// Zi 类中的成员方法method}
  }
  

小结

• 构造方法不能被继承
• 父类的“私有成员”可以被子类继承，但子类不能被直接访问。
• 当通过“子类”访问非私有成员时，先在子类中找，如果找到就使用子类的，找不到就继续去“父类”中找。

知识点–2.4 方法重写

目标:

• 能够正确对父类中的方法进行重写

讲解:

方法重写的概念

方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。

class Fu{public void method(){System.out.println("Fu method");}
}
class Zi extends Fu{@Overridepublic void method() {System.out.println("Zi method");}public void show(){System.out.println("Zi show");}
}
public class Test {public static void main(String[] args) {/*方法重写:方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。注意事项:1.一定要是父子类关系2.子类中重写的方法返回值类型,方法名,参数列表一定要和父类一模一样3.子类中重写的方法可以使用@Override注解进行标识,如果不是重写的方法使用@Override注解标识就会报错建议开发中重写的方法使用@Override注解标识,这样可以提高代码的可读性4.子类重写父类的方法的访问权限不能低于父类的访问权限访问权限: public >  protected  >  默认(空)   >  private*/Zi zi = new Zi();zi.method();}
}

重写的注意事项

• 方法重写是发生在子父类之间的关系。

• 子类方法重写父类方法，返回值类型、方法名和参数列表都要一模一样。

• 子类方法重写父类方法，必须要保证权限大于等于父类权限。

  • 访问权限从大到小: public protected (默认) private

• 使用@Override注解，检验是否重写成功，重写注解校验！

  • 建议重写方法都加上这个注解，一方面可以提高代码的可读性，一方面可以防止重写出错！

方法重写的使用场景

class Fu{public void sport(){System.out.println("Fu 运动的方式跑步");}public void run(){System.out.println("Fu 第1圈");System.out.println("Fu 第2圈");System.out.println("Fu 第3圈");}
}class Zi extends Fu{// 子类方法的实现和父类方法的实现完全不同@Overridepublic void sport() {System.out.println("Zi 运动的方式游泳");}// 子类方法的实现要保留父类方法的功能,但要在父类功能的基础之上额外增加功能@Overridepublic void run() {// 让父类的方法执行=====复制父类的代码过来super.run();// 调用父类的方法// 额外增加的代码System.out.println("Zi 第4圈");System.out.println("Zi 第5圈");System.out.println("Zi 第6圈");System.out.println("Zi 第7圈");System.out.println("Zi 第8圈");System.out.println("Zi 第9圈");System.out.println("Zi 第10圈");}
}public class Test {public static void main(String[] args) {/*方法重写的使用场景:当父类的方法无法满足子类的需求的时候,子类就会去重写父类的方法*/// 创建子类对象Zi zi = new Zi();// 调用运动的方法zi.sport();// 调用跑步的方法zi.run();}
}

小结

• 方法重写:子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同）
• 使用场景: 当父类的某个方法,子类有不同的实现,那么就可以重写该方法
• 建议: 校验方法重写或者标识方法重写,可以使用@Override注解

知识点–2.5 this和super关键字

目标:

• 掌握super和this 的用法

讲解:

this和super关键字的介绍

• this：存储的“当前对象”的引用；
  • this可以访问：本类的成员属性、成员方法、构造方法；
• super：存储的“父类对象”的引用；
  • super可以访问：父类的成员属性、成员方法、构造方法；

this关键字的三种用法

• this访问本类成员变量: this.成员变量

  public class Student{String name = "张三";public void show(){String name = "李四";System.out.println("name = " + name);// 李四System.out.println("name = " + this.name);// 张三}
  }
  

• this访问本类成员方法: this.成员方法名();

  public class Student{public void show(){System.out.println("show方法...");this.eat();}public void eat(){System.out.println("eat方法...");}
  }
  

• this访问本类构造方法: this()可以在本类的一个构造方法中，调用另一个构造方法

  public class Student{public Student(){System.out.println("空参构造方法...");}public Student(String name) {this();//当使用this()调用另一个构造方法时，此代码必须是此构造方法的第一句有效代码。System.out.println("有参构造方法...");}
  }
  public class Demo {public static void main(String[] args) {Student stu2 = new Student();}
  }
  

super关键字的三种用法

• super访问父类的成员变量: super.父类成员变量名

  class Fu{int num = 100;
  }class Zi extends Fu{int num = 10;public void show(){int num = 1;System.out.println("局部变量num:"+num);// 1System.out.println("Zi 类中的num:"+this.num);// 10System.out.println("Fu 类中的num:"+super.num);// 100}
  }
  

• super访问父类的成员方法: super.成员方法名();

  class Fu{public void method1(){System.out.println("Fu method1...");}
  }class Zi extends Fu{public void show(){// 访问父类的method1方法super.method1();}@Overridepublic void method1(){super.method1();// 调用父类的method1方法System.out.println("Zi method1...");}
  }
  

• super访问父类的构造方法: super()

  public class Fu{public Fu(){System.out.println("Fu 类的空参构造方法..");}public Fu(String name, int age) {System.out.println("Fu 类的有参构造方法..");}
  }
  public class Zi extends Fu{public Zi(){super();// 调用父类的空参构造方法System.out.println("Zi 类的空参构造方法..");}public Zi(String name,int age){super(name,age);// 调用父类的有参构造方法System.out.println("Zi 类的有参构造方法..");}
  }
  public class Demo {public static void main(String[] args) {Zi zi = new Zi();System.out.println("----------------------");Zi z2 = new Zi("刘德华", 17);}
  }

小结

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

• super关键字的三种用法:super可以访问父类的成员变量: super.成员变量         一般用来区分父子类中同名的成员变量super可以访问父类的成员方法: super.成员方法(实参);   一般用来在子类中访问父类的成员方法super可以访问父类的构造方法:空参构造: super();有参构造: super(实参);注意:1.子类的构造方法默认会调用父类的空参构造方法2.super访问父类的构造方法,可以用来初始化从父类继承过来的属性3.在子类的构造方法中,使用super调用父类的构造方法,必须放在子类构造方法的第一行
  

知识点-- 2.6 super的注意事项

目标

• 关于super的注意事项

讲解

super的注意事项一

• super访问成员变量和成员方法: 优先去父类中找,如果有就直接使用,如果没有就去爷爷类中找,如果有,就用,依次类推…

  class Ye{int num = 10;public void method(){System.out.println("Ye method");}
  }
  class Fu extends Ye{int num = 100;public void method(){System.out.println("Fu method");}
  }
  class Zi extends Fu{int num = 1000;public void show(){System.out.println(super.num);super.method();}
  }public class Test {public static void main(String[] args) {Zi zi = new Zi();zi.show();}
  }
  

super的注意事项二

• 子类的构造方法默认会调用父类的空参构造方法,如果父类中的没有空参构造方法,只定义了有参构造方法,会编译报错

  class Fu1{public Fu1(){System.out.println("Fu1 空参构造");}public Fu1(int num){System.out.println("Fu1 有参构造");}
  }class Zi1 extends Fu1{public Zi1(){// super();}public Zi1(int num){// super();}
  }// 问题: super调用父类的构造方法有什么用?
  class Person{private String name;private int age;public Person(String name, int age) {this.name = name;this.age = age;}public void show(){System.out.println(name+","+age);}
  }class Student extends Person{public Student(String name,int age){super(name,age);}
  }public class Test2 {public static void main(String[] args) {/*super的注意事项二1.子类的构造方法默认会调用父类的空参构造方法2.如果父类中的没有空参构造方法,只定义了有参构造方法,会编译报错问题: super调用父类的构造方法有什么用?结果: 为了在创建子类对象的时候,初始化从父类继承过来的属性*/// 通过调用子类的空参构造方法,创建子类对象// Zi1 zi = new Zi1();// 通过调用子类的有参构造方法,创建子类对象//Zi1 zi = new Zi1(100);// 创建Student类的对象Student stu = new Student("张三", 18);stu.show();}
  }

小结

• super访问成员变量和成员方法: 优先去父类中找,如果有就直接使用,如果没有就去爷爷类中找,如果有,就用,依次类推…
• 子类的构造方法默认会调用父类的空参构造方法,如果父类中的没有空参构造方法,只定义了有参构造方法,会编译报错
• 子类构造方法中使用super调用父类的构造方法,是为了在创建子类对象的时候,初始化从父类继承过来的属性

知识点–2.7 继承的特点

目标:

• 继承的特点

讲解:

1. Java只支持单继承，不支持多继承。

  // 一个类只能有一个父类，不可以有多个父类。
class A {}
class B {}
class C1 extends A {// ok}
class C2 extends A, B {// error}

1. 一个类只能有一个父类,但可以有多个子类。

  // A可以有多个子类
class A {}
class C1 extends A {}
class C2 extends  A {}

1. 可以多层继承。

class A /*extends Object*/{// 爷爷   默认继承Object类}
class B extends A {// 父亲}
class C extends B {// 儿子}

补充: 顶层父类是Object类。所有的类默认继承Object，作为父类。

class A {} 默认继承Object类 直接继承Object类

class B extends A{} B的父类就是A,但是A的父类是Object类 间接继承Object类

java中所有类都是直接或者间接继承Object,所有类都是Object类的子类

小结:

• 类的继承只能是单继承,不能多继承,但是可以多层继承
• java中所有类都是直接或者间接继承Object,所有类都是Object类的子类

第三章 抽象类

知识点–3.1 抽象类的概述和定义

目标

• 理解抽象类的概述和抽象类的定义

讲解

抽象类的概述

• 概述: 使用abstract关键字修饰的类就是抽象类
• 特点: 这种类不能被创建对象,它就是用来做父类的,被子类继承的

抽象类的定义

• 格式:

  修饰符 abstract class 类名{}
  

• 例如:

  public abstract class Person{}
  

抽象类中的成员

• 成员变量
• 成员方法
• 构造方法
• 抽象方法

public abstract class Animal {// 成员变量private String name;private int age;// 构造方法public Animal(){}public Animal(String name,int age){this.name = name;this.age = age;}// 成员方法public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public void show(){System.out.println(name+","+age);}// 抽象方法 ---??}public class Test {public static void main(String[] args) {/*抽象类:概述:使用abstract关键字修饰的类就是抽象类特点:抽象类不能创建对象,主要用来给子类继承的格式:public abstract class 类名{成员变量构造方法成员方法抽象方法}抽象类成员:成员变量构造方法成员方法抽象方法普通类和抽象类的区别:1.普通类可以创建对象,抽象类不可以创建对象2.普通类没有抽象方法,抽象类有抽象方法*///Animal anl1 = new Animal();// 编译报错,抽象类不能创建对象//Animal anl2 = new Animal("旺财",2);// 编译报错,抽象类不能创建对象}
}

小结

• 使用abstract关键字修饰的类就是抽象类
• 抽象类中的成员
  • 成员变量
  • 构造方法
  • 成员方法
  • 抽象方法
• 抽象类的特点
  • 不能创建对象,主要用来给子类继承的

知识点–3.2 抽象方法的概述和定义

目标

• 掌握抽象方法的概述和定义

讲解

抽象方法的概述

• 没有方法体,使用abstract修饰的方法就是抽象方法

抽象方法的定义

修饰符 abstract 返回值类型 方法名(形参列表);
例如:public abstract void work();

抽象方法的作用: 强制要求子类重写的

public abstract class Animal {// 成员变量private String name;private int age;// 构造方法public Animal(){}public Animal(String name, int age){this.name = name;this.age = age;}// 成员方法public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}// 所有子类显示信息的方法实现都是一样的public void show(){System.out.println(name+","+age);}// 抽象方法 ---// 因为所有子类吃东西的方法实现不一样public abstract void eat();}public class Dog extends Animal {@Overridepublic void eat() {System.out.println("狗吃骨头...");}
}public class Cat extends Animal {@Overridepublic void eat() {System.out.println("猫吃鱼...");}
}public class Test {public static void main(String[] args) {/*抽象方法:概述: 使用abstract修饰,并且没有方法体的方法格式: 修饰符 abstract 返回值类型 方法名(形参列表);抽象方法的使用场景:如果父类中某个方法,所有子类都有不同的实现,那么就可以把该方法定义为抽象方法抽象方法的作用: 强制要求子类重写*/Dog d = new Dog();d.eat();Cat c = new Cat();c.eat();}
}

小结

• 抽象方法: 没有方法体,使用abstract修饰的方法就是抽象方法
• 抽象方法定义格式: 修饰符 abstract 返回值类型 方法名(形参列表);
• 使用场景:如果父类中某个方法,所有子类都有不同的实现,那么就可以把该方法定义为抽象方法
• 抽象方法的作用: 强制要求子类重写

知识点–3.3 抽象类的注意事项

目标

• 理解抽象类的特点

讲解

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

abstract class Animal{private String name;private int age;public Animal() {}public Animal(String name, int age) {this.name = name;this.age = age;}public void show(){System.out.println(name+","+age);}// 抽象类没有抽象方法
}
class Dog extends Animal{public Dog() {super();}public Dog(String name, int age) {super(name, age);}
}abstract class Person{// 抽象方法public abstract void eat();public abstract void drink();}//普通子类继承抽象类后,必须重写抽象类中所有的抽象方法
class Student extends Person{@Overridepublic void eat() {// ...}@Overridepublic void drink() {// ...}
}//抽象子类继承抽象类后,可以不用重写抽象类中的抽象方法abstract class Teacher extends Person{@Overridepublic void eat() {// ... 可以重写...}
}public class Test {public static void main(String[] args) {/*抽象类的注意事项:- 抽象类不能被创建对象，就是用来做“父类”，被子类继承的。- 抽象类不能被创建对象，但可以有“构造方法”——为成员变量初始化。- 抽象类中可以没有抽象方法,但抽象方法必须定义在抽象类中(抽象类中不一定有抽象方法,但抽象方法一定在抽象类中)- 子类继承抽象类后,必须重写抽象类中所有的抽象方法,否则子类必须也是一个抽象类*/// 抽象类不能被创建对象，就是用来做“父类”，被子类继承的。//Animal anl = new Animal();// 抽象类不能被创建对象，但可以有“构造方法”——为成员变量初始化。Dog d = new Dog("旺财", 2);d.show();// 旺财,2}
}

小结

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

知识点–3.4 模板设计模式

目标:

• 理解模板设计模式

讲解:

设计模式概述

• 设计模式就是解决一些问题时的固定思路，也就是代码设计思路经验的总结。

模板设计模式概述

• 针对某些情况,在父类中指定一个模板,然后根据具体情况,在子类中灵活的具体实现该模板

public abstract class Person{// 有方法体的方法: 通用模板public void sleep(){System.out.println("两眼一闭,就睡觉...");}// 没有方法体的方法(抽象方法):  填充模板(要子类重新实现的)public abstract void eat();
}

• 抽象类体现的就是模板设计思想，模板是将通用的东西在抽象类中具体的实现，而模板中不能决定的东西定义成抽象方法，让使用模板（继承抽象类的类）的类去重写抽象方法实现需求

模板模式的实现步骤

• 定义抽象父类作为模板
• 在父类中定义"模板方法"— 实现方法(通用模板)+抽象方法(填充模板)
• 子类继承父类,重写抽象方法(填充父类的模板)
• 测试类:
  • 创建子类对象，通过子类调用父类的“实现的方法”+ “子类重写后的方法” e

案例演示

假如我现在需要定义新司机和老司机类，新司机和老司机都有开车功能，开车的步骤都一样，只是驾驶时的姿势有点不同，新司机:开门,点火,双手紧握方向盘,刹车,熄火，老司机:开门,点火,右手握方向盘左手抽烟,刹车,熄火。那么这个时候我们就可以将固定流程写到父类中，不同的地方就定义成抽象方法，让不同的子类去重写

分析:

• 司机类
  • 开车方法: 确定实现–通用模板
    • 开门
    • 点火
    • (姿势)
    • 刹车
    • 熄火
  • 姿势方法: 不确定实现–填充模板
• 新司机类继承司机类,重写姿势方法
• 老司机类继承司机类,重写姿势方法

// 父类
public abstract class Driver {// 开车方法 通用模板public void driveCar(){System.out.println("开门");System.out.println("点火");// 姿势??ziShi();System.out.println("刹车");System.out.println("熄火");}// 姿势方法  填充模板public abstract void ziShi();
}

现在定义两个使用模板的司机：

public class NewDriver extends Driver {@Overridepublic void ziShi() {System.out.println("双手紧握方向盘");}
}public class OldDriver extends Driver {@Overridepublic void ziShi() {System.out.println("右手握方向盘左手抽烟");}
}

编写测试类

public class Test {public static void main(String[] args) {// 创建新司机对象NewDriver d1 = new NewDriver();d1.driveCar();// 创建老司机对象OldDriver d2 = new OldDriver();d2.driveCar();}}

运行效果

可以看出，模板模式的优势是，模板已经定义了通用架构，使用者只需要关心自己需要实现的功能即可！非常的强大！

小结

• 定义一个抽象类作为父类
• 在抽象类中,该模板可以确定的功能,就定义成一个有方法体的方法,作为通用模板
• 在抽象类中,该模板不可以确定的功能,就定义成一个抽象方法,作为填充模板
• 让需要使用该模板的类,去继承该抽象类,填充模板\使用模板

第四章 final关键字

知识点-- final关键字的概述和使用

目标:

• final关键字的概述和使用

讲解:

final关键字的概述

final： 不可改变。可以用于修饰类、方法和变量。

• 类：被修饰的类，不能被继承。
• 方法：被修饰的方法，不能被重写。
• 变量：被修饰的变量，就只能赋值一次,不能被重新赋值。

final关键字的使用

修饰类

格式如下：

修饰符 final class 类名 {}
例如:
public final class FinalClassFu {}
public class FinalClassZi /*extends FinalClassFu*/ {// FinalClassFu类被final修饰了,所以不能被继承
}

查询API发现像 public final class String 、public final class Math 、public final class Scanner 等，很多我们学习过的类，都是被final修饰的，目的就是供我们使用，而不让我们所以改变其内容。

修饰方法

格式如下：

修饰符 final 返回值类型 方法名(参数列表){//方法体
}

重写被 final修饰的方法，编译时就会报错。

public class FinalMethodFu {public final void show(){}
}
public class FinalMethodZi extends FinalMethodFu {/*@Overridepublic void show() {}*/// 无法重写父类中的show方法,因为父类中的show方法被final修饰了
}

修饰变量

局部变量——基本类型

基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改。代码如下：

public class FinalDemo1 {public static void main(String[] args) {// final修饰基本数据类型final int NUM = 10;// NUM = 20;// 编译报错,final修饰的变量只能赋值一次,不能重复赋值}
}

局部变量——引用类型

引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的修改，代码如下：

public class FinalDemo2 {public static void main(String[] args) {// 引用类型final Student stu = new Student("张三",18);//stu = new Student("李四",19);// 编译报错stu.setAge(19);}
}

成员变量

成员变量涉及到初始化的问题，初始化方式有两种，只能二选一：

1. 显示初始化；

   public class FinalVariable {final int NUM1 = 10;
   }
   

2. 构造方法初始化。

   public class FinalVariable {final int NUM2;public FinalVariable(int NUM2){this.NUM2 = NUM2;}public FinalVariable(){this.NUM2 = 10;}
   }
   

被final修饰的常量名称，一般都有书写规范，所有字母都大写。

小结：

• final修饰类，类不能被继承。
• final修饰方法，方法不能被重写。
• final修饰变量，变量不能被改值,只能赋值一次.

第五章 static关键字

知识点-- static关键字

目标:

• 之前咋们写main方法的时候,使用过了一个static关键字,接下来我们来学习一下static关键字

讲解:

1.1 static关键字概述

static是一个静态修饰符关键字，表示静态的意思,可以修饰成员变量和成员方法以及代码块。

1.2 static关键字的使用

static修饰成员变量

当 static 修饰成员变量时，该变量称为**类变量**。该类的每个对象都==共享==同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。

定义格式：

static 数据类型 变量名；

静态成员变量的访问方式:

对象名.静态成员变量名; 不推荐
类名.静态成员变量名;  推荐

案例:

public class Person {// 非静态变量String name;// 姓名// 静态变量static String country;// 国籍// 构造方法public Person() {}public Person(String name, String country) {this.name = name;this.country = country;}
}public class Test {public static void main(String[] args) {// 创建Person对象Person p1 = new Person("张三", "中国");System.out.println(p1.name+","+p1.country);// 张三,中国System.out.println("=======================");// 创建Person对象Person p2 = new Person();// 没有使用static修饰country// System.out.println(p2.name+","+p2.country);// null,null// 使用static修饰countrySystem.out.println(p2.name+","+p2.country);// null,中国System.out.println("=======================");System.out.println(Person.country);// 中国}
}

static修饰成员方法

概述

• 被static修饰的方法会变成静态方法,也称为类方法,该静态方法可以使用类名直接调用。

格式

修饰符 static 返回值类型 方法名 (参数列表){ // 执行语句
}

访问方式

对象名.方法名(实参);
类名.方法名(实参);   推荐

public class Person {// 非静态方法public void method1(){System.out.println("Person method1...");}// 静态方法public static void method2(){System.out.println("Person method2...");}
}
public class Test {public static void main(String[] args) {/*static修饰成员方法:格式:修饰符 static 返回值类型 方法名(形参列表){方法体}特点:被static修饰的成员方法叫做静态成员方法使用:对象名.静态成员方法名(实参);类名.静态成员方法名(实参); ----->推荐*/Person p = new Person();p.method2();// 类名.静态成员方法名(实参);Person.method2();}
}

静态方法调用的注意事项：

• 静态方法中不能出现this关键字
• 静态方法中只能直接访问静态成员变量和静态成员方法
• 静态方法中不能直接访问非静态成员变量和非静态成员方法
• 非静态方法中可以直接访问一切成员变量和成员方法

public class ChinesePeople {// 非静态成员变量String name;// 姓名// 静态成员变量static String country;// 国籍// 非静态方法public void method1(){System.out.println("非静态 method2方法");}public void method2(){// 非静态方法中可以直接访问一切成员变量和成员方法System.out.println(name);System.out.println(country);method1();method4();System.out.println("非静态 method2方法");}// 静态方法public static void method3(){//静态方法中不能直接访问非静态成员变量和非静态成员方法//System.out.println("非静态的成员变量:"+name);// 编译报错//method1();// 编译报错//静态方法中只能直接访问静态成员变量和静态成员方法System.out.println("静态成员变量:"+country);method4();// 静态方法中不能出现this关键字//System.out.println(this.name);// 编译报错//System.out.println(this.country);// 编译报错System.out.println("非静态 method3方法");}public static void method4(){System.out.println("非静态 method4方法");}
}public class Test {public static void main(String[] args) {/*概述: 被static修饰的方法就是静态方法,否则就是非静态方法static修饰成员方法: 在方法的返回值类型前面加上static访问静态方法:对象名.静态方法名(参数);  不推荐类名.静态方法名(参数);    推荐注意事项:1.静态方法中只能直接访问静态成员变量和静态成员方法2.静态方法中不能直接访问非静态成员变量和非静态成员方法3.非静态方法中可以直接访问一切成员变量和成员方法4.静态方法中不能出现this关键字*/ChinesePeople.method3();//ChinesePeople p = new ChinesePeople();//p.method2();/*// 对象名.静态方法名(参数);  不推荐ChinesePeople p1 = new ChinesePeople();p1.method3();p1.method4();// 类名.静态方法名(参数);    推荐ChinesePeople.method3();ChinesePeople.method4();*/}}

以后开发中static的应用

概述

以后的项目中，通常会需要一些“全局变量”或者“全局的工具方法”，这些全局变量和方法，可以单独定义在一个类中，并声明为static(静态)的，可以很方便的通过类名访问

例如:

public class Utils {// "全局变量"public static final int WIDTH = 800;public static final int HEIGHT = 800;// "全局方法"// 找int数组中的最大值public static int getArrayMax(int[] arr){int max = arr[0];for (int i = 0; i < arr.length; i++) {if(arr[i] > max){max = arr[i];}}return max;}
}public class Test {public static void main(String[] args) {/*以后的项目中，通常会需要一些“全局变量”或者“全局的工具方法”，这些全局变量和方法，可以单独定义在一个类中，并声明为static(静态)的，可以很方便的通过类名访问工具类*/System.out.println(Utils.width);System.out.println(Utils.height);int[] arr = {23,34,545,56};System.out.println(Utils.getArrayMax(arr));}
}

小结:

static修饰成员方法:格式: 在返回值类型前面加static关键字使用: 类名.静态方法名(实参);注意事项:1.静态方法中不能出现this2.静态方法中只能直接访问静态成员变量和成员方法3.非静态方法中可以直接访问一切成员变量和成员方法
static修饰成员变量:格式: static 数据类型 变量名;使用; 类名.静态成员变量名特点; 被static修饰的变量会被该类的所有对象共享

【26天高效学完Java编程】Day11：继承、抽象类、模板设计模式详解相关推荐

1. 【26天高效学完Java编程】Day03：Java中的运算符与流程控制语句的基本概念与实操

   本专栏将从基础开始,循序渐进,由浅入深讲解Java的基本使用,希望大家都能够从中有所收获,也请大家多多支持. 专栏地址:26天高效学完Java编程 相关软件地址:链接地址 所有代码地址:链接地址 如果 ...

2. 【26天高效学完Java编程】Day02：开发利器之IDEA的安装使用、Java标识符、字符串及运算符等基础知识点详解

   本专栏将从基础开始,循序渐进,由浅入深讲解Java的基本使用,希望大家都能够从中有所收获,也请大家多多支持. 专栏地址:26天高效学完Java编程 相关软件地址:链接地址 所有代码地址:链接地址 如果 ...

3. java编程里的values怎么使用,详解Java编程中super关键字的用法

   这篇文章主要介绍了Java编程中this与super关键字的用法,包括从内存结构方面分析super的作用域,需要的朋友可以参考下 通过用static来定义方法或成员,为我们编程提供了某种便利,从某种程 ...

4. Java编程之反射中的注解详解

   "注解"这个词,可谓是在Java编程中出镜率比较高,而且也是一个老生常谈的话题.我们之前在聊Spring相关的东西时,注解是无处不在,之前我们简单的聊过一些"注解&quo ...

5. Java开发中的23种设计模式详解(转)

   设计模式(Design Patterns) --可复用面向对象软件的基础 设计模式(Design pattern)是一套被反复使用.多数人知晓的.经过分类编目的.代码设计经验的总结.使用设计模式是为了 ...

6. 【java】java开发中的23种设计模式详解

   设计模式(Design Patterns) --可复用面向对象软件的基础 设计模式(Design pattern)是一套被反复使用.多数人知晓的.经过分类编目的.代码设计经验的总结.使用设计模式是为了 ...

7. java 抽象属性 设计_Java 抽象类与模板设计模式详解

   抽象类 抽象类是为了方法覆写而提供的类结构,因为其无法自身直接进行对象实例化操作,所以在实际应用中,抽象类主要目的是进行过程操作使用,当你要使用抽象类进行开发的时候,往往都是在你设计中需要解决类继承问 ...

8. Java开发中的23种设计模式详解

   设计模式(Design pattern)是一套被反复使用.多数人知晓的.经过分类编目的.代码设计经验的总结.使用设计模式是为了可重用代码.让代码更容易被他人理解.保证代码可靠性. 毫无疑问,设计模式于 ...

9. 介绍6点Java的发展方向，让你学完Java后不再迷茫

   众所周知,21世纪是计算机网络的世纪,而Java语言正是服务于网络编程的.Java作为一种语言,已然成为全球最时髦的开发工具之一,它拥有一套庞大且完善的类库,内置了其他语言需要靠库甚至是操作系统才能支 ...

最新文章

1. SAP IDoc Post不成功，报错 - A company code cannot be determined for LI 0000100061 –
2. C语言在生活中的小应用
3. 【Android 高性能音频】Oboe 开发流程 ( 导入 Oboe 库 | 使用预构建的二进制库和头文件 | 编译 Oboe 源码 )
4. eclipse中配置Tomcat，并进行简单测试
5. NSLog(@%@,类对象); 默认输出类名
6. 如何使用 TRACERT 解决 Windows 中的 TCP/IP 问题
7. sublime,gedit,vim和mousepad等都出现fribidi_get_par_embedding_levels_ex
8. JavaScript入门(part3)--变量
9. idea如何安装lombok
10. 【转】做好性能测试的6个关注点
11. pandas 批量修改列名_pandas修改DataFrame列名的方法
12. windows制作docker镜像_Windows镜像制作
13. C++二维vector初始化大小方法
14. 大年三十问候导师的后果
15. 华为android版本7.0,永不卡！华为手机全面升级安卓7.0：逆天
16. 几款开源SDR平台对比
17. Android okhttp3设置代理（http/https）
18. PMP项目管理—质量情景题
19. python泰坦尼克号生存预测论文_用Python预测泰坦尼克号生存情况
20. 了不起的中国公链 | Conflux AMA实录

热门文章

1. PPT转PDF后，ppt的动画分pdf多页显示方法(适用于office做的动画)
2. 电脑双系统启动顺序的切换方法
3. Trac系列(1)：Windows下Trac的安装与基本配置
4. 导轨安装DIN11 IPO EM系列电磁隔离转换器信号放大器
5. pure pursuit：无人车轨迹追踪算法
6. 【Arduino】Arduino IDE使用教程-超详细
7. 【Skill】NHK 的正确打开方式 / 如何优雅的学习 NHK
8. 关于笨蛋式病毒创作（CMD式）C++
9. 破解网页禁止复制的方法
10. c# 把DataTable中数据批量导入新的sqlite的db文件中