houjiheng-java-day06
2021/7/29 14:35:48
本文主要是介绍houjiheng-java-day06,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!
抽象类
- 概述: 使用abstract关键字修饰的类就是抽象类
- 特点: 这种类不能被创建对象,它就是用来做父类的,被子类继承的
格式
修饰符 abstract class 类名{ }
抽象类中的成员
- 成员变量
- 成员方法
- 构造方法
- 抽象方法
抽象方法: 没有方法体,使用abstract修饰的方法就是抽象方法
修饰符 abstract 返回值类型 方法名(形参列表); 例如: public abstract void work();
抽象方法的作用: 强制要求子类重写的
- 抽象方法: 没有方法体,使用abstract修饰的方法就是抽象方法
- 抽象方法定义格式: 修饰符 abstract 返回值类型 方法名(形参列表);
- 使用场景:如果父类中某个方法,所有子类都有不同的实现,那么就可以把该方法定义为抽象方法
- 抽象方法的作用: 强制要求子类重写
package com.company.day06.chouxianglei; // 抽象类 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 abstract void eat(); 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; } @Override public String toString() { return "Animal{" + "name='" + name + '\'' + ", age=" + age + '}'; } } public class Dog extends Animal{ @Override public void eat() { System.out.println("狗狗吃肉"); } } public class Cat extends Animal { @Override public void eat() { System.out.println("猫吃鱼"); } } public class Test { public static void main(String[] args) { Cat cat = new Cat(); cat.eat(); Dog dog = new Dog(); dog.eat(); } }
抽象类的注意事项
- 抽象类不能被创建对象,就是用来做“父类”,被子类继承的。
- 抽象类不能被创建对象,但可以有“构造方法”——为成员变量初始化。
- 抽象类中可以没有抽象方法,但抽象方法必须定义在抽象类中
- 子类继承抽象类后,必须重写抽象类中所有的抽象方法,否则子类必须也是一个抽象类
匿名类
new Animal() { @Override public void eat() { System.out.println("匿名动物吃"); } }.eat();
模板设计模式
设计模式就是解决一些问题时的固定思路,也就是代码设计思路经验的总结。
针对某些情况,在父类中指定一个模板,然后根据具体情况,在子类中灵活的具体实现该模板
public abstract class Person{ // 有方法体的方法: 通用模板 public void sleep(){ System.out.println("两眼一闭,就睡觉..."); } // 没有方法体的方法(抽象方法): 填充模板(要子类重新实现的) public abstract void eat(); }
抽象类体现的就是模板设计思想,模板是将通用的东西在抽象类中具体的实现,而模板中不能决定的东西定义成抽象方法,让使用模板(继承抽象类的类)的类去重写抽象方法实现需求
模板模式的实现步骤
- 定义抽象父类作为模板
- 在父类中定义"模板方法"— 实现方法(通用模板)+抽象方法(填充模板)
- 子类继承父类,重写抽象方法(填充父类的模板)
- 测试类: -创建子类对象,通过子类调用父类的“实现的方法”+ “子类重写后的方法”
案例
假如我现在需要定义新司机和老司机类,新司机和老司机都有开车功能,开车的步骤都一样,只是驾驶时的姿势有点不同,新司机:开门,点火,双手紧握方向盘,刹车,熄火,老司机:开门,点火,右手握方向盘左手抽烟,刹车,熄火。那么这个时候我们就可以将固定流程写到父类中,不同的地方就定义成抽象方法,让不同的子类去重写
分析:
- 司机类
- 开车方法: 确定实现–通用模板
- 开门
- 点火
- (姿势)
- 刹车
- 熄火
- 姿势方法: 不确定实现–填充模板
- 开车方法: 确定实现–通用模板
- 新司机类继承司机类,重写姿势方法
- 老司机类继承司机类,重写姿势方法
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{ @Override public void ziShi() { System.out.println("双手紧握方向盘"); } } public class OldDriver extends Driver{ @Override public void ziShi() { System.out.println("右手握方向盘左手抽烟"); } } public class Test2 { public static void main(String[] args) { NewDriver newDriver = new NewDriver(); newDriver.driveCar(); OldDriver oldDriver = new OldDriver(); oldDriver.driveCar(); } }
final关键字
final关键字的概述
final: 不可改变。可以用于修饰类、方法和变量。
- 类:被修饰的类,不能被继承 比如String。
- 方法:被修饰的方法,不能被重写。
- 变量:被修饰的变量,就只能赋值一次,不能被重新赋值。
修饰类
修饰符 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 { /*@Override public void show() { }*/ // 无法重写父类中的show方法,因为父类中的show方法被final修饰了 }
修饰变量
局部变量——基本类型
基本类型的局部变量,被final修饰后,只能赋值一次,不能再更改。代码如下:
final int NUM = 10; NUM = 220; // 报错
局部变量——引用类型
引用类型的局部变量,被final修饰后,只能指向一个对象,地址不能再更改。但是不影响对象内部的成员变量值的修改,代码如下:
public class Test3 { public static void main(String[] args) { final Student student1 = new Student("eric", 11); System.out.println(student1); // student1 = new Student("bob", 20); 不能有新的指向 student1.setAge(30); System.out.println(student1.getAge()); System.out.println(student1); } }
成员变量涉及到初始化的问题,初始化方式有两种,只能二选一:
public class FinalVariable { final int NUM1 = 10; }
public class FinalVariable { final int NUM2; public FinalVariable(int NUM2){ this.NUM2 = NUM2; } public FinalVariable(){ this.NUM2 = 10; } }
被final修饰的常量名称,一般都有书写规范,所有字母都大写
- final修饰类,类不能被继承。
- final修饰方法,方法不能被重写。
- final修饰变量,变量不能被改值,只能赋值一次.
static关键字
static是一个静态修饰符关键字,表示静态的意思,可以修饰成员变量和成员方法以及代码块。
static修饰成员变量
当 static 修饰成员变量时,该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值,但也可以在不创建该类的对象的情况下对类变量进行操作
static 数据类型 变量名; // 调用 对象名.静态成员变量名; 不推荐 类名.静态成员变量名; 推荐
public class Person { String name; static int id; public Person(String name) { this.name = name; ++id; } public static void main(String[] args) { System.out.println(Person.id); Person p1 = new Person("张三"); Person p2 = new Person(";李四"); Person p3 = new Person(";李四"); System.out.println(Person.id); //3 System.out.println(p3.id); } }
静成员会随着类的加载而加载, 并且只加载一次, 会加载到静态区
static修饰成员方法
被static修饰的方法会变成静态方法,也称为类方法,该静态方法可以使用类名直接调用。
修饰符 static 返回值类型 方法名 (参数列表){ // 执行语句 } 访问 对象名.方法名(实参); 类名.方法名(实参); 推荐
package com.company.day06.chouxianglei; import java.util.Arrays; public class Person { String name; static int id; public Person(String name) { this.name = name; ++id; } public static void m1(){ System.out.println("m1()"); } public static void main(String[] args) { Person p1 = new Person("张三"); p1.m1(); Person.m1(); int arr[] = {111, 223, 444}; System.out.println(Arrays.toString(arr)); } }
静态方法调用的注意事项:
- 静态方法中不能出现this关键字
- 静态方法中只能直接访问静态成员变量和静态成员方法
- 静态方法中不能直接访问非静态成员变量和非静态成员方法
- 非静态方法中可以直接访问一切成员变量和成员方法
public class Person { String name; static int id; public Person(String name) { this.name = name; ++id; } public void m2(){ this.name = "haha"; id = 100; } public static void m1(){ // this.name 错 // name = "" 错 id = 100; }
以后开发中static的应用
概述
以后的项目中,通常会需要一些“全局变量”或者“全局的工具方法”,这些全局变量和方法,可以单独定义在一个类中,并声明为static(静态)的,可以很方便的通过类名访问
package com.company.day06.utils; public class Utils { // 静态代码块, 优先于main方法执行 static { AGE = 10; } public static int AGE; // "全局变量" 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; } } import com.company.day06.utils.Utils; public class Test4 { public static void main(String[] args) { System.out.println(Utils.WIDTH); System.out.println(Utils.HEIGHT); int[] arr = {122, 334,444}; System.out.println(Utils.getArrayMax(arr)); System.out.println(Utils.AGE); } }
接口
- 引用数据类型除了类其实还有接口,接下来学习接口的概述
概述: 接口是Java语言中的一种引用类型,是方法的"集合",所以接口的内部主要就是定义方法,包含常量,抽象方法(JDK 7及以前),默认方法和静态方法(JDK 8),私有方法(jdk9)。
接口的定义,它与定义类方式相似,但是使用 interface 关键字。它也会被编译成.class文件,但一定要明确它并不是类,而是另外一种引用数据类型。
public class 类名{}–>.class
public interface 接口名{}->.class
引用数据类型:数组,类,接口
接口的使用,它不能创建对象,但是可以被实现(implements ,类似于被继承)。一个实现接口的类(可以看做是接口的子类),需要实现接口中所有的抽象方法,创建该类对象,就可以调用方法了,否则它必须是一个抽象类
格式
public interface 接口名称 { // 常量(jdk7及其以前) // 抽象方法(jdk7及其以前) // 默认方法(jdk8) // 静态方法(jdk8) // 私有方法(jdk9) }
package com.company.day06.jiekou; public interface IA { // 常量(jdk7及其以前) 使用public static final关键字修饰,这三个关键字都可以省略 public static final int NUM = 10; // 抽象方法(jdk7及其以前) 使用public abstract关键字修饰,这2个关键字都可以省略 public abstract void method1(); void method2(); // 默认方法(jdk8) 使用public default关键字修饰,public可以省略,default不可以省略 public default void method3(){ System.out.println("默认方法"); } // 静态方法(jdk8) 使用public static关键字修饰,public可以省略,static不可以省略 public static void method4(){ System.out.println("静态方法"); } // 私有方法(jdk9) 使用private关键字修饰,private不可以省略 private void method5(){ System.out.println("method5"); } private static void method6(){ System.out.println("method6"); } }
实现接口
类与接口的关系为实现关系,即类实现接口,该类可以称为接口的实现类,也可以称为接口的子类。实现的动作类似继承,格式相仿,只是关键字不同,实现使用 implements关键字。
public class ZI implements IA, IB{ @Override public void method1() { } @Override public void method2() { } @Override public void show() { } }
接口中成员的访问特点:
- 接口中的常量: 主要是供接口直接使用
- 接口中的抽象方法: 供实现类重写的
- 接口中的默认方法: 供实现类继承的(实现类中可以直接调用,实现类对象也可以直接调用)
- 接口中的静态方法: 只供接口直接调用,实现类继承不了
- 接口中的私有方法: 只能在接口中直接调用,实现类继承不了
多实现时的几种冲突情况
- 公有静态常量的冲突
- 公有抽象方法的冲突
- 公有默认方法的冲突
- 公有静态方法的冲突
- 私有方法的冲突
公有静态常量的冲突
public interface A { public static final int NUM1 = 10; } public interface B { public static final int NUM1 = 20; public static final int NUM2 = 30; } public class Impl implements A, B{ public static void main(String[] args) { // 公有静态常量的冲突: 如果多个接口中有相同的常量,那么实现类就无法继承 // System.out.println(Impl.NUM1); // 报错 System.out.println(Impl.NUM2); } }
公有抽象方法的冲突
实现类只需要重写一个
public interface A { public static final int NUM1 = 10; public abstract void method(); } public interface B { public static final int NUM1 = 20; public static final int NUM2 = 30; public abstract void method(); } public class Impl implements A, B{ public static void main(String[] args) { // 公有静态常量的冲突: 如果多个接口中有相同的常量,那么实现类就无法继承 // System.out.println(Impl.NUM1); // 报错 System.out.println(Impl.NUM2); } @Override public void method() { System.out.println("重写"); } }
公有默认方法的冲突
- 实现类必须重写一次最终版本
public interface A { public static final int NUM1 = 10; public abstract void method(); public default void method2(){ System.out.println("A 接口的默认方法method2"); } } public interface B { public static final int NUM1 = 20; public static final int NUM2 = 30; public abstract void method(); public default void method2(){ System.out.println("B 接口的默认方法method2"); } } public class Impl implements A, B{ @Override public void method() { System.out.println("重写"); } @Override public void method2() { B.super.method2(); } public static void main(String[] args) { Impl impl = new Impl(); impl.method2(); } }
公有静态方法的冲突:
静态方法是直接属于接口的,不能被继承,所以不存在冲突
私有方法的冲突
- 私有方法只能在本接口中直接使用,不存在冲突
抽象类和接口的练习
通过实例进行分析和代码演示抽象类和接口的用法。
1、举例:
犬: —抽象父类
行为:吼叫;吃饭;
缉毒犬:继承犬类,实现缉毒接口
行为:吼叫;吃饭;缉毒;
缉毒接口:
缉毒
- 如果一个父类中的某个方法,所有子类都有不同的实现,那么该方法就应该定义成抽象方法,所以该父类就是抽象类 (父类一般都是抽象类)
- 如果某个功能是一个类额外增加的,那么就可以把这个额外的功能定义到接口中,再这个类去实现
分析:
由于犬分为很多种类,他们吼叫和吃饭的方式不一样,在描述的时候不能具体化,也就是吼叫和吃饭的行为不能明确。当描述行为时,行为的具体动作不能明确,这时,可以将这个行为写为抽象行为,那么这个类也就是抽象类。
可是有的犬还有其他额外功能,而这个功能并不在这个事物的体系中 , 例如 : 缉毒犬。缉毒的这个功能有好多种动物都有 , 例如 : 缉毒猪 , 缉毒鼠。我们可以将这个额外功能定义接口中 ,让缉毒犬继承犬且实现缉毒接口 , 这样缉毒犬既具备犬科自身特点也有缉毒功能。
- 额外的功能—> 在接口中定义,让实现类实现
- 共性的功能—> 在父类中定义,让子类继承
public interface JiDu { public abstract void jiDu(); } public abstract class Dog { public abstract void houJiao(); public abstract void eat(); } public class JiDuDog extends Dog implements JiDu{ @Override public void houJiao() { System.out.println("缉毒犬找到了毒品,开始吼叫,汪汪汪...."); } @Override public void eat() { System.out.println("缉毒之前,开始吃骨头..."); } @Override public void jiDu() { System.out.println("吃完东西后,开始使用鼻子查找毒品...."); } } public class Test { public static void main(String[] args) { JiDuDog jiDuDog = new JiDuDog(); jiDuDog.eat(); jiDuDog.jiDu(); jiDuDog.houJiao(); } }
这篇关于houjiheng-java-day06的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!
- 2024-11-20RabbitMQ教程:新手入门指南
- 2024-11-20Redis教程:新手入门指南
- 2024-11-20SaToken教程:新手入门指南
- 2024-11-20SpringBoot教程:从入门到实践
- 2024-11-20Java全栈教程:从入门到实战
- 2024-11-20Java微服务系统教程:入门与实践指南
- 2024-11-20Less教程:初学者快速上手指南
- 2024-11-20MyBatis教程:新手快速入门指南
- 2024-11-20QLExpress教程:初学者快速入门指南
- 2024-11-20订单系统教程:从入门到实践的全面指南