字符串的分割方法
package String;
/*
* 分割字符串的方法:
* public String[] split(String regex):按照参数的规则,将字符串切分成为若干部分。
*
* 注意事项:
* split方法的参数其实是一个“正则表达式”。
* 如果按照英文句点,"."进行切分,必须写"\\."(两个反斜杠)
* */
public class Demo05StringSplit {
public static void main(String[] args) {
String str1 = "abc,bbb,dnf";
String[] array1 = str1.split(",");
for (int i = 0; i < array1.length; i++) {
System.out.println(array1[i]); // abc bbb dnf
}
System.out.println("=====");
String str2 = "AAA BBB DDD";
String[] array2 = str2.split(" ");
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i]); // AAA BBB DDD
}
System.out.println("=====");
String str3 = "DDD.NNN.FFF";
String[] array3 = str3.split("\\.");
for (int i = 0; i < array3.length; i++) {
System.out.println(array3[i]); // DDD NNN FFF
}
}
}
练习:按指定格式拼接字符串
package String;
/*
* 题目:定义一个方法:把数组[1,2,3]按照指定格式成一个字符串,格式参照如下:[word1#word2#word3]
*
* 分析:
* 1.首先准备一个int[]数组,内容是:1,2,3
* 2.定义一个方法,用来将数组变成字符串
*
* 三要素:
* 返回值类型:String
* 方法名称:fromArrayToString
* 参数列表:int[]
* 3.格式:[word1#word2#word3]
* 用到:for循环、字符串拼接、每个数组元素之前都有一个word字样、分隔使用的是#、区分一下是不是最后一个
* 4.调用方法:得到返回值,并打印结果字符串
* */
public class Demo06StringParams {
public static void main(String[] args) {
int[] array = {1,2,3};
String result = fromArrayToString(array);
System.out.println(result); // [word1#word2#word3]
}
public static String fromArrayToString(int[] array) {
String str = "[";
for (int i = 0; i < array.length; i++) {
if (i == array.length - 1) {
str += "word" + array[i] + "]";
}else {
str += "word" + array[i] + "#";
}
}
return str;
}
}
练习:统计输入的字符串中各种字符的个数
package String;
import java.util.Scanner;
/*
* 题目:键盘输入一个字符串,并且统计其中各种字符出现的次数,
* 种类有:大写字母、小写字母、数字、其他
*
* 思路:
* 1.既然用到键盘输入,肯定是Scanner
* 2.键盘输入的是字符串,那么:String str = sc.next();
* 3.定义四个变量:分别代表四和字符各自的出现次数。
* 4.需要对字符串一个字、一个字检查,String --> char[],方法是:toCharArray();
* 5.遍历char[]字符数组,对当前字符的种类进行判断,并且用四个变量进行++动作。
* 6.打印输出四个变量,分别代表四种字符出现次数。
* */
public class Demo07StringCount {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串:");
String input = sc.next(); // 获取键盘输入的字符串
int countUpper = 0; // 大写字母
int countLower = 0; // 小写字母
int countNumber = 0; // 数字
int countOther = 0; // 其他字符
char[] charArray = input.toCharArray();
for (int i = 0; i < charArray.length; i++) {
char ch = charArray[i]; // 当前单个字符
if('A' <= ch && ch <= 'Z') {
countUpper++;
} else if ('a' <= ch && ch <= 'z') {
countLower++;
} else if ('0' <= ch && ch <= '9') {
countNumber++;
} else {
countOther++;
}
}
System.out.println("大写字母有:" + countUpper);
System.out.println("小写字母有:" + countLower);
System.out.println("数字有:" + countNumber);
System.out.println("其他字符有:" + countUpper);
}
}
静态static关键字概述
静态static关键字修饰成员变量
package Static;
public class Student {
private String name; // 姓名
private int age; // 年龄
static String room; // 所在教室
private static int idCounter = 0; // 学号计数器,每当new了一个新对象的时候,idCounter++
// 无参构造方法
public Student() {
this.idCounter = ++idCounter;
}
// 有参构造方法
public Student(String name, int age) {
this.name = name;
this.age = age;
this.idCounter = ++idCounter;
}
// Getter/Setter方法
public static int getIdCounter() {
return idCounter;
}
public static void setIdCounter(int idCounter) {
Student.idCounter = idCounter;
}
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;
}
}
package Static;
public class Demo01Static {
public static void main(String[] args) {
Student one = new Student("吴奇隆",19);
one.room = "101教室";
System.out.println("姓名:" + one.getName() + ",年龄:" + one.getAge() + ",教室:" + one.room + ",学号:" + one.getIdCounter());
Student two = new Student("刘诗诗",18);
System.out.println("姓名:" + two.getName() + ",年龄:" + two.getAge() + ",教室:" + two.room + ",学号:" + two.getIdCounter());
}
}
静态static关键字修饰成员方法
package Static;
public class MyClass {
int num; // 成员变量
static int numStatic; // 静态变量
// 成员方法
public void method(){
System.out.println("这是一个成员方法");
// 成员方法可以访问成员变量、静态变量
System.out.println(num);
System.out.println(numStatic);
}
// 静态方法
public static void methodStatic(){
System.out.println("这是一个静态方法");
// 静态方法可以访问静态变量
System.out.println(numStatic);
// 静态不能直接访问非静态【重点】
// System.out.println(num); //错误写法!!!
// 静态方法中不能使用this关键字
// System.out.println(this);// 错误写法!!!
}
}
package Static;
/*
* 一旦使用static修饰成员方法,那么这就成为了静态方法。静态方法不属于对象,而是属于类的。
* 如果没有static关键字,那么必须首先创建对象,然后通过对象才能使用它。
* 如果有了static关键字,那么不需要创建对象,直接就能通过类名称来使用它。
*
* 无论是成员变量,还是成员方法。如果有了static,都推荐使用类名称进行调用。
* 静态变量:类名称.静态变量
* 静态方法:类名称.静态方法()
*
* 注意事项:
* 1.静态不能直接访问非静态。
* 原因:因为在内存当中是【先】有的静态内容,【后】有的非静态内容。
* “先人不知道后人,但是后人知道先人”
* 2.静态方法当中不能用this。
* 原因:this代表当前对象,通过谁调用的方法,谁就是当前对象。
* */
public class Demo02StaticMethod {
public static void main(String[] args) {
MyClass obj = new MyClass(); // 首先创建对象
// 然后才能使用没有static关键字内容
obj.method();
// 对于静态方法来说:可以通过对象名进行调用,也可以直接通过类名称来调用。
obj.methodStatic(); // 正确,不推荐。这种写法在编译之后也会被javac编译成为:"类名称.静态方法名"
MyClass.methodStatic(); // 正确,推荐用类名称进行调用
// 对于本类当中的静态方法,可以省略类名称
myMethod();
Demo02StaticMethod.myMethod(); // 完全等效
}
public static void myMethod() {
System.out.println("自己的方法!");
}
}
静态static的内存图
静态代码块
package Static;
public class Person {
static {
System.out.println("静态代码块");
}
public Person() {
System.out.println("动态代码块");
}
}
package Static;
/*
* 静态代码块的格式是:
*
* public class 类名称 {
* static {
* // 静态代码块的内容
* }
* }
*
* 特点:当第一次用到本类时,静态代码块执行唯一的一次。
* 静态内容总是优先于非静态,所以静态代码块比构造方法先执行。
*
* 静态代码块的典型用途:
* 用来一次性地对静态成员变量进行赋值。
* */
public class Demo04StaticPerson {
public static void main(String[] args) {
Person one = new Person();
Person two = new Person();
}
}
数组工具类arrays
package Array;
import java.util.Arrays;
/*
* java.util.Arrays是一个与数组相关的工具类,里面提供了大量静态方法,用来实现
* 数组常见的操作。
*
* public static String toString(数组);将参数数组变成字符串(按照默认格式:[元素1、元素2、元素3、...])
* public static void sort(数组);按照默认升序(从小到大)对数组的元素进行排序。
*
* 注意事项:
* 1.如果是数值,sort默认按照升序从小到大
* 2.如果是字符串,sort默认按照字母升序
* 3.如果是自定义的类型,那么这个自定义的类需要有Comparable或者Comparator接口的支持(今后学习)
*
* * */
public class Demo01Arrays {
public static void main(String[] args) {
int[] intArray = {10,20,30};
// 将int[]数组按照默认格式变成字符串
String intStr = Arrays.toString(intArray);
System.out.println(intStr); // [10, 20, 30]
int[] array1 = {2,1,3,10,6};
Arrays.sort(array1);
System.out.println(Arrays.toString(array1)); // [1, 2, 3, 6, 10]
String[] array2 = {"bbb","ccc","aaa"};
Arrays.sort(array2);
System.out.println(Arrays.toString(array2)); // [aaa, bbb, ccc]
}
}
arrays练习:字符串倒序排列
package Array;
import java.util.Arrays;
/*
* 题目:请使用Arrays相关的API,将一个随机字符串中的所有字符升序排列,并倒序打印。
*
* */
public class ArraysTest {
public static void main(String[] args) {
// 定义随机的字符串
String str = "ysUreadfSRWEJDSFJJ123";
/*
如何进行升序排列:sort 必须是一个数组,才能用Arrays.sort方法
String --> 数组,用toCharArray
*/
char[] chars = str.toCharArray();
// 升序排序
Arrays.sort(chars); // 对字符数组进行升序排列
// 反向遍历打印
for (int i = chars.length - 1; i >= 0; i--) {
System.out.print(chars[i]); // ysrfedaWUSSRJJJFED321
}
}
}
数学工具类Math
package Math;
/*
* java.util.Math类是数学相关的工具类,里面提供了大量的静态方法,完成与数学运算相关的操作。
*
* public static double abs(double num);获取绝对值。有多种重载
* public static double ceil(double num);向上取整
* public static double floor(double num);向下取整
* public static long round(double num);四舍五入
*
* Math.PI代表近似的圆周率常量(double)。
*
* */
public class Demo01Math {
public static void main(String[] args) {
// 获取绝对值
System.out.println(Math.abs(3.14)); // 3.14
System.out.println(Math.abs(-3.14)); // 3.14
System.out.println(Math.abs(0)); // 0
System.out.println("=========");
// 向上取整
System.out.println(Math.ceil(3.9)); // 4.0
System.out.println(Math.ceil(-3.1)); // -3.0
System.out.println(Math.ceil(3.1)); // 4.0
System.out.println(Math.ceil(3.0)); // 3.0
System.out.println("=========");
// 向下取整,抹零
System.out.println(Math.floor(30.1)); // 30.0
System.out.println(Math.floor(-30.9)); // -31.0
System.out.println(Math.floor(31.0)); // 31.0
System.out.println("=========");
// 四舍五入
System.out.println(Math.round(20.4)); // 20
System.out.println(Math.round(10.5)); // 11
System.out.println("=========");
}
}
练习题:小学模考真题
package Math;
/*
* 题目:计算在 -10.8~5.9之间,绝对值大于6或者小于2.1的整数有多少个?
*
* 分析:
* 1.既然已经确定了范围,for循环
* 2.起点位置-10.8应该转换成为-10,两种办法:
* 2.1 可以使用Math.ceil方法,向上(向正方向)取整
* 2.2 强转成为int,自动舍弃所有小数位
* 3.每一个数字都是整数,所以步进表达式应该是num++,这样每次都是+1的。
* 5.一旦发现了一个数字,需要让计数器++进行统计。
*
* 备注:如果使用Math.ceil方法,-10.8可以变成-10.0。
* 注意:double也是可以进行++的。
* */
public class Demo01MathPractise {
public static void main(String[] args) {
int count = 0; // 符合要求的数量
double min = -10.8;
double max = 5.9;
// 【变量i强转成为int】 这样处理,变量i就是区间之内所有的整数
for(int i = (int) min;i < max;i++) {
int abs = Math.abs(i); // 绝对值
if(abs > 6 || abs < 2.1) {
System.out.println(i);
count++;
}
}
System.out.println("总共有:" + count); // 9
}
}
继承的概述
继承的格式
创建对象
package Extends;
/*
* 在继承的关系中:"子类就是一个父类"。也就是说:子类可以被当做父类看待。
* 例如:父类是员工,子类是讲师,那么"讲师就是一个员工"。关系:is-a
*
* 定义父类的格式:(一个普通的类定义)
* public class 父类名称 {
* // ...
* }
* 定义子类的格式:
* public class 子类名称 extends 父类名称 {
* // ...
* }
* */
public class Demo01Extends {
public static void main(String[] args) {
// 创建了一个子类对象
Teacher teacher = new Teacher();
// Teacher类当中虽然什么都没写,但是会继承来自父类的method方法。
teacher.method();
// 创建了一个子类助教
Assistant assistant = new Assistant();
// Assistant类当中虽然什么都没写,但是会继承来自父类的method方法。
assistant.method();
}
}
定义一个父类:员工
package Extends;
// 定义一个父类:员工
public class Employee {
// 定义一个方法
public void method() {
System.out.println("方法执行");
}
}
- 定义子类:讲师
package Extends;
/*
* 定义了一个员工的子类:讲师
* */
public class Teacher extends Employee{
}
- 定义子类:助教
package Extends;
// 定义了一个员工的子类:助教
public class Assistant extends Employee {
}
继承中成员变量的访问特点
package Extends.Demo01;
/*
* 在父子类的继承关系当中,如果成员变量重名,则创建子类对象时,访问有两种方式:
*
* 直接通过子类对象访问成员变量:等号左边是谁,就优先用谁,没有则向上找。
* 间接通过成员方法访问成员变量:该方法属于谁,就优先用谁,没有则向上找。
* */
public class Demo01ExtendsField {
public static void main(String[] args) {
Fu fu = new Fu(); // 创建父类对象
System.out.println(fu.numFu); // 20 只能使用父类的东西,没有任何子类的内容
Zi zi = new Zi(); // 创建子类对象
System.out.println(zi.numZi); // 10
System.out.println(zi.numFu); // 20
System.out.println("=============");
// 等号左边是谁,就优先用谁,没有则向上找
System.out.println(zi.num); // 100 优先子类 Zi zi = new Zi();
// System.out.println(zi.abc); // 到处都没有,编译报错!
System.out.println("=============");
// 这个方法是子类的,优先用子类的,没有再向上找
zi.methodZi(); // 100
// 这个方法是在父类当中定义的
zi.methodFu(); // 200
}
}
- 父类
package Extends.Demo01;
public class Fu {
// 成员变量
int numFu = 20;
int num = 200;
// 成员方法
public void methodFu() {
// 使用的是本类当中的,不会向下找子类的
System.out.println(num);
}
}
- 子类
package Extends.Demo01;
public class Zi extends Fu{
// 成员变量
int numZi = 10;
int num = 100;
// 成员方法
public void methodZi() {
// 因为本类当中有num,所以这里用的是本类的num
System.out.println(num);
}
}
区分子类方法中重名的三种变量
package Extends.Demo02;
/*
* 局部变量: 直接写成员变量名
* 本类的成员变量: this.成员变量名
* 父类的成员变量: super.成员变量名
* */
public class Demo01ExtendsField {
public static void main(String[] args) {
Zi zi = new Zi();
zi.method();
}
}
- 父类
package Extends.Demo02;
public class Fu {
int num = 20;
}
- 子类
package Extends.Demo02;
public class Zi extends Fu{
int num = 10;
public void method() {
int num = 30;
System.out.println(num); // 30 局部变量
System.out.println(this.num); // 10 本类的成员变量
System.out.println(super.num); // 20 父类的成员变量
}
}
继承中成员方法的访问特点
package Extends.Demo03;
/*
* 在父子类的继承关系当中,创建子类对象,访问成员方法的规则:
* 创建的对象是谁,就优先用谁,如果没有则向上找。
*
* 注意事项:
* 无论是成员方法还是成员变量,如果没有都是向上找父类,绝对不会向下找子类的。
* */
public class Demo01ExtendsMethod {
public static void main(String[] args) {
Zi zi = new Zi();
zi.methodFu(); // 父类方法执行
zi.methodZi(); // 子类方法执行
// 创建的是new了子类对象,所以优先用子类方法
zi.method(); // 子类重名方法执行
}
}
- 父类
package Extends.Demo03;
public class Fu {
public void methodFu(){
System.out.println("父类方法执行");
}
public void method(){
System.out.println("父类重名方法执行");
}
}
- 子类
package Extends.Demo03;
public class Zi extends Fu{
public void methodZi(){
System.out.println("子类方法执行");
}
public void method(){
System.out.println("子类重名方法执行");
}
}
继承中方法的覆盖重写:概念与特点
package Extends.Demo03;
/*
* 在父子类的继承关系当中,创建子类对象,访问成员方法的规则:
* 创建的对象是谁,就优先用谁,如果没有则向上找。
*
* 注意事项:
* 无论是成员方法还是成员变量,如果没有都是向上找父类,绝对不会向下找子类的。
* 重写(Override)
* 概念:在继承关系当中,方法的名称一样,参数列表也一样。
*
* 重写(Override):方法的名称一样,参数列表【也一样】。覆盖、覆写。
* 重载(Overload):方法的名称一样,参数列表【不一样】。
*
* 方法的覆盖重写特点:创建的是子类对象,则优先用子类方法。
* */
public class Demo01ExtendsMethod {
public static void main(String[] args) {
Zi zi = new Zi();
zi.methodFu(); // 父类方法执行
zi.methodZi(); // 子类方法执行
// 创建的是new了子类对象,所以优先用子类方法
zi.method(); // 子类重名方法执行
}
}
- 父类
package Extends.Demo03;
public class Fu {
public void methodFu(){
System.out.println("父类方法执行");
}
public void method(){
System.out.println("父类重名方法执行");
}
}
- 子类
package Extends.Demo03;
public class Zi extends Fu{
public void methodZi(){
System.out.println("子类方法执行");
}
public void method(){
System.out.println("子类重名方法执行");
}
}
继承中方法的覆盖重写:注意事项
package Extends.Demo04;
/*
* 方法覆盖重写的注意事项:
*
* 1.必须保证父子类之间方法的名称相同,参数列表也相同
* @Override:写在方法前面,用来检测是不是有效的正确覆盖重写。
* 这个注解就算不写,只要满足要求,也是正确的方法覆盖重写。
*
* 2.子类方法的返回值必须【小于等于】父类方法的返回值范围
* 小扩展提示:java.lang.Object类是所有类的公共最高父类(祖宗类),java.lang.String就是Object的子类。
*
* 3.子类方法的权限必须【大于等于】父类方法的权限修饰符。
* 小扩展提示:public > protected > (default) > private
* 备注:(default)不是关键字default,而是什么都不写,留空。
* */
public class Demo04Override {
public static void main(String[] args) {
}
}
- 父类
package Extends.Demo04;
public class Fu {
public Object method() {
return null;
}
}
- 子类
package Extends.Demo04;
public class Zi extends Fu{
@Override
public Object method() {
return null;
}
}
继承中方法的覆盖重写:应用场景
package Extends.Demo05;
public class Demo01Phone {
public static void main(String[] args) {
Phone phone = new Phone();
phone.call(); // 打电话
phone.send(); // 发短信
phone.show(); // 显示号码
System.out.println("==========");
newPhone newPhone = new newPhone();
newPhone.call(); // 打电话
newPhone.send(); // 发短信
newPhone.show(); // 显示号码 显示姓名 显示头像
}
}
- 父类
package Extends.Demo05;
// 本来的老款手机
public class Phone {
public void call() {
System.out.println("打电话");
}
public void send() {
System.out.println("发短信");
}
public void show() {
System.out.println("显示号码");
}
}
- 子类
package Extends.Demo05;
// 定义一个新手机,使用老手机作为父类
public class newPhone extends Phone{
@Override
public void show(){
super.show(); // 把父类的show方法拿过来重复利用
// 自己子类再来添加更多内容
System.out.println("显示姓名");
System.out.println("显示头像");
}
}
继承中构造方法的访问特点
package Extends.Demo06;
/*
* 继承关系中,父子类构造方法的访问特点:
* 1.子类构造方法当中有一个默认隐含的"super()"调用,所以一定是先调用的父类构造,后执行的子类构造
* 2.子类构造可以通过super关键字,调用父类重载构造
* 3.super的父类构造调用,必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
*
* 总结:
* 1.子类必须调用父类构造方法:不写则赠送super();
* 写了则用写的指定的super调用,super只能有一个,还必须是第一个
* */
public class Demo06Constructor {
public static void main(String[] args) {
// 创建子类对象
Zi zi = new Zi();
}
}
- 父类
package Extends.Demo06;
public class Fu {
// 有参构造
public Fu(int num){
System.out.println("父类有参构造方法");
}
// 无参构造
public Fu(){
System.out.println("父类无参构造方法");
}
}
- 子类
package Extends.Demo06;
public class Zi extends Fu{
// 无参构造
public Zi(){
// super(); // 在调用父类无参构造方法
super(20); // 调用父类重载的构造方法
System.out.println("子类构造方法");
}
// public void method() {
// super(); // 错误写法! 只有子类构造方法,才能调用父类构造方法。
// }
}
super关键字的三种用法
package Extends.Demo07;
public class Demo07Super {
public static void main(String[] args) {
Zi zi = new Zi();
zi.method();
zi.methodZi();
}
}
- 父类
package Extends.Demo07;
public class Fu {
int num = 30;
public void method() {
System.out.println("父类方法");
}
}
- 子类
package Extends.Demo07;
/*
* super关键字的用法有三种:
* 1.在子类的成员方法中,访问父类的成员变量。
* 2.在子类的成员方法中,访问父类的成员方法。
* 3.在子类的构造方法中,访问父类的构造方法。
* */
public class Zi extends Fu{
int num = 20;
public Zi() {
super();
}
public void methodZi() {
System.out.println(num); // 20
System.out.println(super.num); // 父类中的30
}
public void method() {
super.method(); // 访问父类中的method
System.out.println("子类方法");
}
}
this关键字的三种用法
package Extends.Demo08;
public class Fu {
int num = 30;
}
package Extends.Demo08;
/*
* super关键字用来访问父类内容,而this关键字用来访问本类内容。用法也有三种。
* 1.在本类的成员方法中,访问本类的成员变量。
* 2.在本类的成员方法中,访问本类的另一个成员方法。
* 3.在本类的构造方法中,访问本类的另一个构造方法。
* 注意事项:
* 1.this(...) 调用也必须是构造方法的第一个语句。【唯一一个】
* 2.super和this两种构造调用,不能同时使用
* */
public class Zi extends Fu{
int num = 20;
// 无参构造
public Zi() {
// super(); // 这一行不再赠送
this(123); // 本类的无参构造,调用本类的有参构造
// this(12,13); // 错误写法【注意事项1】
}
// 有参构造
public Zi(int n) {
this(1,2); // 一个参数,可以调用多个参数
}
// 有参构造
public Zi(int n,int m) {
// this(6); // 多个参数不能调用一个参数
}
public void showNum() {
int num = 10;
System.out.println(num); // 局部变量
System.out.println(this.num); // 本类中的成员变量
System.out.println(super.num); // 父类中的成员变量
}
public void methodA() {
System.out.println("AAA");
}
public void methodB() {
this.methodA(); // 在本类的成员方法中,访问本类的另一个成员方法
System.out.println("BBB");
}
}
super与this关键字图解
Java继承的三个特点
抽象的概念:
抽象方法和抽象类的格式
package Extends.Demo10;
/*
* 抽象方法:就是加上abstract关键字,然后去掉大括号,直接分号结算。
* 抽象类:抽象方法所在的类,必须是抽象类才行。在class之前写上abstract即可。
* */
public abstract class Animal {
// 这是一个抽象方法,代表吃东西,但是具体吃什么(大括号的内容)不确定
public abstract void eat();
// 这是普通的成员方法
public void normalMethod() {
}
}
抽象方法和抽象类的使用
package Extends.Demo10;
public class Demo01Main {
public static void main(String[] args) {
// Animal animal = new Animal(); // 错误写法:第一步:不能直接创建new抽象类对象
// 第四步:创建子类对象进行使用
Cat cat = new Cat();
cat.eat();
}
}
- 父类
package Extends.Demo10;
/*
* 抽象方法:就是加上abstract关键字,然后去掉大括号,直接分号结算。
* 抽象类:抽象方法所在的类,必须是抽象类才行。在class之前写上abstract即可。
*
* 如何使用抽象类和抽象方法:
* 1.不能直接创建new抽象类对象。
* 2.必须用一个子类来继承抽象父类。
* 3.子类必须覆盖重写抽象父类当中所有的抽象方法。
* 覆盖重写(实现),子类去掉抽象方法的 abstract 关键字,然后补上方法体大括号
* 4.创建子类对象进行使用。
* */
public abstract class Animal {
// 这是一个抽象方法,代表吃东西,但是具体吃什么(大括号的内容)不确定
public abstract void eat();
// 这是普通的成员方法
public void normalMethod() {
}
}
- 子类
package Extends.Demo10;
// 第二步:用一个子类来继承抽象父类
public class Cat extends Animal{
/*
* 第三步:子类必须覆盖重写抽象父类当中所有的抽象方法。
* 覆盖重写(实现),子类去掉抽象方法的 abstract 关键字,然后补上方法体大括号
* */
@Override
public void eat() {
System.out.println("猫吃鱼");
};
}
抽象方法和抽象类的注意事项:
关于抽象类的使用,以下为语法上要注意的细节
-
抽象类【不能创建对象】。如果创建,编译无法通过而报错。只能创建其非抽象子类的对象。
理解:假设创建了抽象类的对象,调用抽象的方法,而抽象方法没有具体的方法体,没有意义。
-
抽象类中,可以有构造方法,是供子类创建对象时,初始化父类成员使用的。
理解:子类的构造方法中,有默认的super(),需要访问父类构造方法
package Extends.Demo11; public class DemoMain { public static void main(String[] args) { Zi zi = new Zi(); zi.eat(); } }
- 父类
package Extends.Demo11; // 抽象父类 public abstract class Fu { public Fu() { System.out.println("抽象父类构造方法执行"); } public abstract void eat(); }
- 子类
package Extends.Demo11; public class Zi extends Fu{ public Zi() { // super(); // 通过赠送的super();运行父类中的 Fu 构造方法 System.out.println("子类构造方法执行"); } @Override public void eat() { System.out.println("吃饭饭"); } }
-
抽象类中,不一定包含抽象方法,但是有抽象方法的类必定是抽象类。
【抽象方法所在的类,必须是抽象类才行。在class之前写上abstract即可】
理解:未包含抽象方法的抽象类,目的就是不想让调用者创建该类对象,通常用于某些特殊的类结构设计。
package Extends.Demo11; /* * 一个抽象类不一定含有抽象方法, * 只要保证抽象方法所在的类是抽象类,即可。 * * 这样没有抽象方法的抽象类,也不能直接创建对象,在一些特殊场景下有用途。 * */ public abstract class MyAbstract { }
-
抽象类的子类,必须重写抽象父类中所有的抽象方法,否则,编译无法通过而报错。除非该子类也是抽象类。
理解:假设不重写所有抽象方法,则类中可能包含抽象方法。那么创建对象后,调用抽象的方法,没有意义。
发红包案例-分析
发红包案例-实现
package SendMoney;
import java.util.ArrayList;
public class MainPacket {
public static void main(String[] args) {
// 群主对象
Manager manager = new Manager("群主",100);
Member one = new Member("成员A",0);
Member two = new Member("成员B",0);
Member three = new Member("成员B",0);
manager.show();
one.show();
two.show();
three.show();
System.out.println("============");
// 群主总共发20块钱,分成3个红包
ArrayList<Integer> redList = manager.send(20,3);
// 三个普通成员收红包
one.receive(redList);
two.receive(redList);
three.receive(redList);
manager.show(); // 100-20=80
// 6,6,8 随机分给三个人
one.show();
two.show();
three.show();
}
}
- 群主
package SendMoney;
import java.util.ArrayList;
// 群主的类
public class Manager extends User{
public Manager() {
}
// 快捷键:Alt + insert
public Manager(String name, int money) {
super(name, money);
}
public ArrayList<Integer> send(int totalMoney,int count) {
// 首先需要一个集合,用来存储若干个红包的金额
ArrayList<Integer> redList = new ArrayList();
// 首先看一下群主自己有多少钱
int leftMoney = super.getMoney(); // 群主当前余额
if(totalMoney > leftMoney) {
System.out.println("余额不足");
return redList; // 返回空集合
}
// 扣钱,其实就是重新设置余额
super.setMoney(leftMoney - totalMoney);
// 发红包需要平均拆分成为count份
int avg = totalMoney / count;
int mod = totalMoney % count; // 余数,也就是甩下的零头
// 除不开的零头,包在最后一个红包当中
// 下面把红包一个一个放到集合当中
for (int i = 0; i < count; i++) {
redList.add(avg);
}
// 最后一个红包
int last = avg + mod;
redList.add(last);
return redList;
}
}
- 用户类
package SendMoney;
public class User {
private String name; // 姓名
private int money; // 余额,也就是当前用户拥有的钱数
// 无参构造
public User() {
}
// 有参构造
public User(String name, int money) {
this.name = name;
this.money = money;
}
// 展示一下当前用户有多少钱
public void show() {
System.out.println("我叫:" + name + ",我有多少钱:" + money);
}
// Getter/Setter方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
- 成员
package SendMoney;
import java.util.ArrayList;
import java.util.Random;
// 普通成员
public class Member extends User{
public Member() {
}
public Member(String name,int money) {
super(name, money);
}
public void receive(ArrayList<Integer> list) {
// 从多个红包当中随便抽取一个,给我自己
// 随机获取一个集合当中的索引编号
int index = new Random().nextInt(list.size());
// 根据索引,从集合当中删除,并且得到被删除的红包,给我自己
Integer delta = list.remove(index);
// 当前成员自己本来有多少钱
int money = super.getMoney();
// 加法,并且重新设置回去
super.setMoney(money + delta);
}
}
接口的定义
接口的定义基本格式
package Demo33;
/*
* 接口就是多个类的公共规范。
* 接口是一种引用数据类型,最重要的内容就是其中的:抽象方法。
*
* 如何定义一个接口的格式:
* public interface 接口名称 {
* // 接口内容
* }
*
* 备注:换成了关键字 interface 之后,编译生成的字节码文件仍然是:.java --> .class
*
* 如果是 Java 7,那么接口中可以包含的内容有:
* 1.常量
* 2.抽象方法
*
* 如果是Java 8,还可以额外包含有:
* 3.默认方法
* 4.静态方法
*
* 如果是Java 9,还可以额外包含有:
* 5.私有方法
*
* */
public class Interface {
}
接口的抽象方法定义和使用
package Demo33;
/*
* 在任何版本的java中,接口都能定义抽象方法:
* 格式:public abstract 返回值类型 方法名称(参数列表);
*
* 注意事项:
* 1.接口当中的抽象方法:修饰符必须是两个固定的关键字:public abstract
* 2.这两个关键字修饰符,可以选择性地省略。(今天刚学,所以不推荐)
* 3.方法的三要素,可以随意定义。
* */
public interface MyInterfaceAbstract {
// 这是一个抽象方法
public abstract void methodAbs1();
// 这也是抽象方法
abstract void methodAbs2();
// 这是一个抽象方法
public void methodAbs3();
// 这也是抽象方法
void methodAbs4();
}
- 使用
package Demo33;
/*
* 接口就是多个类的公共规范。
* 接口是一种引用数据类型,最重要的内容就是其中的:抽象方法。
*
* 如何定义一个接口的格式:
* public interface 接口名称 {
* // 接口内容
* }
*
* 备注:换成了关键字 interface 之后,编译生成的字节码文件仍然是:.java --> .class
*
* 如果是 Java 7,那么接口中可以包含的内容有:
* 1.常量
* 2.抽象方法
*
* 如果是Java 8,还可以额外包含有:
* 3.默认方法
* 4.静态方法
*
* 如果是Java 9,还可以额外包含有:
* 5.私有方法
*
* 接口使用步骤:
* 1.接口不能直接使用,必须有一个"实现类" 来 "实现" 该接口。
* 格式:
* public class 实现类名称 implements 接口名称 {
* // ...
* }
* 2.接口的实现类必须覆盖重写(【实现】)接口中所有的抽象方法。
* 【实现】:去掉abstract关键字,加上方法体大括号。
* 3.创建实现类的对象,进行使用。
*
* 注意事项:
* 如果实现类并没有覆盖重写接口中所有的抽象方法,那么这个实现类自己就必须是抽象类。
* */
public class Interface {
public static void main(String[] args) {
// 错误写法:不能直接new接口对象使用。
// MyInterfaceAbstract inter = new MyInterfaceAbstract();
// 创建实现类的对象使用:
MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
impl.methodAbs1();
impl.methodAbs2();
}
}
接口的默认方法定义和使用
package Demo33;
/*
接口的默认方法:
* 解决接口升级的问题
* 拼接函数模型
* 1.接口的默认方法:可以通过接口实现类对象,直接调用。
* 2.接口的默认方法,也可以被接口实现类进行覆盖重写。
* */
public class Demo02Interface {
public static void main(String[] args) {
// 创建了实现类对象
MyInterfaceDefaultA a = new MyInterfaceDefaultA();
a.methodAbs(); // 调用抽象方法,实际运行的是右侧实现类。
// 调用默认方法:如果实现类当中没有,会向上找接口
a.methodDefault(); // 这是新添加的默认方法
System.out.println("========");
MyInterfaceDefaultB b = new MyInterfaceDefaultB();
b.methodAbs();
b.methodDefault(); // 实现类B覆盖重写了接口的默认方法
}
}
- 抽象方法
package Demo33;
/*
* 从Java 8开始,接口里允许定义默认方法。
* 格式:
* public default 返回值类型 方法名称(参数列表) {方法体}
*
* 备注:接口当中的默认方法,可以解决接口升级的问题。
* */
public interface MyInterfaceDefault {
// 抽象方法
public abstract void methodAbs();
// 新添加了一个抽象方法,原来的方法会受影响。解决方法:改成默认方法
// public abstract void methodAbs2();
// 新添加的方法,改为默认方法
public default void methodDefault() {
System.out.println("这是新添加的默认方法");
}
}
- 抽象方法A
package Demo33;
public class MyInterfaceDefaultA implements MyInterfaceDefault{
@Override
public void methodAbs() {
System.out.println("实现了抽象方法,AAA");
}
}
- 抽象方法B
package Demo33;
public class MyInterfaceDefaultB implements MyInterfaceDefault{
@Override
public void methodAbs() {
System.out.println("实现了抽象方法,BBB");
}
@Override
public void methodDefault() {
System.out.println("实现类B覆盖重写了接口的默认方法");
}
}
接口的静态方法定义和使用
package Static.MyInter;
/*
* 注意事项:不能通过接口实现类的对象来调用接口当中的静态方法。
* 正确用法:通过接口名称,直接调用其中的静态方法。
* 格式: 接口名称.静态方法名(参数);
* */
public class Demo01Interface {
public static void main(String[] args) {
// 错误写法。因为:【不能通过接口实现类的对象来调用接口当中的静态方法】
// MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl(); // 创建了实现类对象
// impl.methodStatic();
// 直接通过接口名称调用静态方法 静态和对象没关系(【上面的做法为啥new一个对象呢?所以上面的做法错误且没有必要】),但是和类有关系。
MyInterfaceStatic.methodStatic();
}
}
- 接口的静态方法
package Static.MyInter;
/*
* 从Java 8开始,接口当中允许定义静态方法:
* 格式:
* public static 返回值类型 方法名称(参数列表) { 方法体 }
*
* 提示:就是将 abstract 或者 default 换成 static 即可,带上方法体。
* */
public interface MyInterfaceStatic {
public static void methodStatic(){
System.out.println("这是接口的静态方法");
}
}
- 是一个类实现一个接口用的关键字:
implements
package Static.MyInter;
public class MyInterfaceStaticImpl implements MyInterfaceStatic{
}
接口的私有方法定义和使用
package Static.privateA;
/*
* 问题描述:
* 我们需要抽取一个共有方法,用来解决两个默认方法之间重复代码的问题。
* 但是这个共有方法不应该让实现类使用,应该是私有化的。
*
* 解决方案:
* 从Java 9开始,接口当中允许定义私有方法。
* 1.普通私有方法,解决多个默认方法之间重复代码问题
* 格式:private 返回值类型 方法名称(参数列表) { 方法体 }
* 2.静态私有方法,解决多个静态方法之间重复代码问题
* 格式:private static 返回值类型 方法名称(参数列表) { 方法体 }
*
* */
public interface MyInterfacePrivateA {
public default void methodDefault1() {
System.out.println("默认方法1");
// methodCommon();
}
public default void methodDefault2() {
System.out.println("默认方法2");
// methodCommon();
}
// private void methodCommon() {
// System.out.println("AAA");
// System.out.println("BBB");
// System.out.println("CCC");
// }
}
- MyInterfacePrivateA页面
package Static.privateA;
public class MyInterfacePrivateAImpl implements MyInterfacePrivateA {
public void methodAnother() {
// 直接访问到了接口中的默认方法,这样是错误的
// methodCommon();
}
}
- MyInterfacePrivateB页面
package Static.privateA;
public interface MyInterfacePrivateB {
public static void methodStatic1() {
System.out.println("静态方法1");
// methodStaticCommon();
}
public static void methodStatic2() {
System.out.println("静态方法2");
// methodStaticCommon();
}
// private static void methodStaticCommon() {
// System.out.println("AAA");
// System.out.println("BBB");
// System.out.println("CCC");
// }
}
- Demo01Interface页面
package Static.privateA;
public class Demo01Interface {
public static void main(String[] args) {
MyInterfacePrivateB.methodStatic1();
MyInterfacePrivateB.methodStatic2();
// 错误写法:
// MyInterfacePrivateB.methodStaticCommon();
}
}
接口的常量定义和使用
package Const;
public class Demo01Interface {
public static void main(String[] args) {
// 访问接口当中的常量
System.out.println(MyInterfaceConst.NUM_OF_MY_CLASS);
}
}
package Const;
/*
* 接口当中也可以定义"成员变量",但是必须使用 public static final 三个关键字进行修饰。
* 从效果上看,这其实就是接口的【常量】
* 格式: public static final 数据类型 常量名称 = 数据值;
*
* 备注:一旦使用 final 关键字进行修饰,说明不可改变。
*
* 注意事项:
* 1.接口当中的常量,可以省略 public static final,注意:不写也照样是这样。
* 2.接口当中的常量,必须进行赋值;不能不赋值。
* 3.接口中常量的名称,使用完全大写的字母,用下划线进行分隔。(推荐命名规则)
*
* */
public interface MyInterfaceConst {
// 这其实就是一个常量,一旦赋值,不可以修饰
public static final int NUM_OF_MY_CLASS = 10;
}
接口的内容小结
继承父类并实现多个接口
package Demo01;
/*
* 使用接口的时候,需要注意:
* 1.接口是没有静态代码块或者构造方法的。
* 2.一个类的直接父类是唯一的,但是一个类可以同时实现多个接口。
* 3.如果实现类所实现的多个接口当中,存在重复的抽象方法,那么只需要覆盖重写一次即可。
* 4.如果实现类没有覆盖重写所有接口当中的所有抽象方法,那么实现类就必须是一个抽象类。
* 5.如果实现类所实现的多个接口当中,存在重复的默认方法,那么实现类一定要对冲突的默认方法进行覆盖重写。
* 6.一个类如果直接父类当中的方法,和接口当中的默认方法产生了冲突,优先用父类当中的方法。
*
* 格式:
* public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB { // 覆盖重写所有抽象方法 }
* */
public class Demo01Interface {
public static void main(String[] args) {
Zi zi = new Zi();
zi.method(); // 父类方法
}
}
- 实现类
package Demo01;
// 如果实现类没有覆盖重写所有接口当中的所有抽象方法,那么实现类就必须是一个抽象类。 【添加关键字 abstract】
public abstract class MyInterfaceAbstract implements MyInterfaceA,MyInterfaceB{
@Override
public void methodA() {
}
@Override
public void methodAbs() {
}
@Override
public void methodDefault() {
}
// 假设没有覆盖重写这个接口
// @Override
// public void methodB() {
//
// }
}
- 接口
package Demo01;
public interface MyInterface {
public default void method() {
System.out.println("接口的默认方法");
}
}
- MyInterfaceImpl类
package Demo01;
// 一个类的直接父类是唯一的,但是一个类可以同时实现多个接口
public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB{
@Override
public void methodA() {
System.out.println("覆盖重写了A方法");
}
@Override
public void methodAbs() {
System.out.println("覆盖重写了AB接口都有的抽象方法");
}
@Override
public void methodB() {
System.out.println("覆盖重写了B方法");
}
@Override
public void methodDefault() {
System.out.println("对多个接口当中冲突的默认方法进行了覆盖重写");
}
}
- 接口A
package Demo01;
public interface MyInterfaceA {
// 错误写法:接口不能有静态代码块
// static {}
// 错误写法:接口不能有构造方法
// public MyInterface{}
public abstract void methodA();
public abstract void methodAbs();
public default void methodDefault() {
System.out.println("默认方法AAA");
}
}
- 接口B
package Demo01;
public interface MyInterfaceB {
// 错误写法:接口不能有静态代码块
// static {}
// 错误写法:接口不能有构造方法
// public MyInterface{}
public abstract void methodB();
public abstract void methodAbs();
public default void methodDefault() {
System.out.println("默认方法BBB");
}
}
- 父类
package Demo01;
public class Fu {
public void method() {
System.out.println("父类方法");
}
}
- 子类
package Demo01;
public class Zi extends Fu implements MyInterface{
}
接口之间的多继承
package Demo01.study;
/*
* 1.类与类之间是单继承的,直接父类只有一个;
* 2.类与接口之间是多实现的。一个类可以实现多个接口
* 3.接口与接口之间是多继承的。
*
* 注意事项:
* 1.多个父接口当中的抽象方法如果重复,没关系。
* 2.多个父接口当中的默认方法如果重复,那么子接口必须进行默认方法的覆盖重写。【而且带着default关键字】
* */
public class Demo01Relations {
}
package Demo01.study;
public class MyInterfaceImpl implements MyInterface{
@Override
public void method() {
}
@Override
public void methodA() {
}
@Override
public void methodB() {
}
@Override
public void methodCommon() {
}
}
- 子接口
package Demo01.study;
// 接口:含有接口A和接口B的内容,另外还有自己的内容。
/*
* 这个子接口当中有几个方法?答:4个
* methodA 来源于接口A
* methodB 来源于接口B
* methodCommon 来源于接口A和B
* method 来源于我自己
* */
public interface MyInterface extends MyInterfaceA,MyInterfaceB{
// 自己的抽象方法
public abstract void method();
@Override
default void methodDefault() {
}
}
- 接口A
package Demo01.study;
// 接口A
public interface MyInterfaceA {
// 抽象方法
public abstract void methodA();
public abstract void methodCommon();
public default void methodDefault() {
System.out.println("AAA");
}
}
- 接口B
package Demo01.study;
// 接口B
public interface MyInterfaceB {
// 抽象方法
public abstract void methodB();
public abstract void methodCommon();
public default void methodDefault() {
System.out.println("BBB");
}
}
多态的概述
多态的格式与使用
package Multi;
/*
* 代码当中体现多态性,其实就是一句话:父类引用指向子类对象。
* 格式:父类名称 对象名 = new 子类名称(); 或者 接口名称 对象名 = new 实现类名称();
*
* */
public class Demo01Multi {
public static void main(String[] args) {
// 使用多态的写法
// 左侧父类的引用,指向了右侧子类的对象
Fu obj = new Zi();
obj.method(); // 子类方法
obj.methodFu(); // 父类特有方法
}
}
- 父类
package Multi;
public class Fu {
// 成员方法
public void method() {
System.out.println("父类方法");
}
public void methodFu() {
System.out.println("父类特有方法");
}
}
- 子类
package Multi;
public class Zi extends Fu{
// 成员方法
@Override
public void method() {
System.out.println("子类方法");
}
}
多态中成员变量和成员方法的使用特点
- 运行代码
package Multi.Demo02;
/*
* 在多态的代码当中,成员方法的访问规则是:
* 看new的是谁,就优先用谁,没有则向上找。
*
* 口诀:编译看左边,运行看右边。
*
* 对比一下:
* 成员变量:编译看左边,运行还看左边。
* 成员方法:编译看左边,运行看右边。
*
* */
public class MultiMethod {
public static void main(String[] args) {
Fu obj = new Zi(); // 多态
/*
* 编译看左边:左边是 Fu obj
* 1. obj.method(); Fu 当中有method方法 => 运行看右边:但是因为 new Zi() 优先用子类的方法
* 2. obj.methodFu(); Fu 当中有method方法 => 运行看右边:但是因为 new Zi() 优先用子类的方法,子类没有,父类有。向上找到父类
* */
// 父子都有这个方法,但是因为 new Zi() 优先用子类的方法
obj.method(); // 打印结果:子类方法
// 子类没有,父类有。向上找到父类
obj.methodFu(); // 父类特有方法
// 编译看左边,左边是 Fu obj,Fu当中没有methodZi方法,所以编译报错。
// obj.methodZi(); // 错误写法!
}
}
- 成员变量不能进行覆盖重写,只有成员方法可以覆盖重写
package Multi.Demo02;
/*
* 访问成员变量的两种方式:
*
* 1.直接通过对象名称访问成员变量:看等号左边是谁,优先用谁,没有则向上找
* 2.间接通过成员方法访问成员变量:看该方法属于谁,优先用谁,没有则向上找
* */
public class MultiField {
public static void main(String[] args) {
// 使用多态的写法,父类引用指向子类对象
Fu obj = new Zi();
System.out.println(obj.num); // 父类 10
System.out.println("==========");
// 子类没有覆盖重写,就是父类 10
// 子类如果覆盖重写,就是子类 20
obj.showNum();
}
}
- 父类
package Multi.Demo02;
public class Fu {
int num = 10;
public void showNum() {
System.out.println(num);
}
public void method() {
System.out.println("父类方法");
}
public void methodFu() {
System.out.println("父类特有方法");
}
}
- 子类
package Multi.Demo02;
public class Zi extends Fu{
int num = 20;
// 子类覆盖重写
@Override
public void showNum() {
System.out.println(num);
}
@Override
public void method() {
System.out.println("子类方法");
}
public void methodZi() {
System.out.println("子类特有方法");
}
}
使用多态的好处
对象的向上、向下转型(instanceof类型判断)
- 代码运行
package obj.Animal.demo01.demo1.animal;
/*
* 向上转型一定是安全的,没有问题的,正确的。但是也有一个弊端:
* 对象一旦向上转型为父类,那么就无法调用子类原本特有的内容。
* */
public class Demo01Main {
public static void main(String[] args) {
// 对象的向上转型,就是:父类引用指向子类对象。
Animal animal = new Cat();
animal.eat(); // 猫吃鱼
// 错误写法 【对象一旦向上转型为父类,那么就无法调用子类原本特有的内容】
// animal.catchMouse();
// 向下转型,进行 "还原" 动作
Cat cat = (Cat) animal;
cat.catchMouse(); // 猫抓老鼠
/*
* 下面是错误的向下转型
* 本来new的时候是一只猫,现在非要当做狗
* 错误写法! 编译不会报错,但是运行会出现异常:java.lang.ClassCastException 类转换异常
* */
// Dog dog = (Dog) animal;
}
}
- 动物类
package obj.Animal.demo01.demo1.animal;
// 抽象方法所在的类,一定是抽象类
public abstract class Animal {
public abstract void eat();
}
- 猫类
package obj.Animal.demo01.demo1.animal;
// 猫类
public class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫吃鱼");
}
// 子类特有方法
public void catchMouse() {
System.out.println("猫抓老鼠");
}
}
- 狗类
package obj.Animal.demo01.demo1.animal;
// 狗类
public class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗吃骨头");
}
public void watchHouse() {
System.out.println("狗看家");
}
}
- 用instanceof关键字进行类型判断
package obj.Animal.demo01.demo1.animal;
/*
* 如何才能知道一个父类引用的对象,本来是什么子类?
* 格式: 对象 instanceof 类名称
* 这将会得到一个boolean值结果,也就是判断前面的对象能不能当做后面类型的实例
*
* */
public class Demo02Instanceof {
public static void main(String[] args) {
Animal animal = new Cat(); // 本来是一只猫
animal.eat(); // 猫吃鱼
/*
* 如果希望调用子类特有方法,需要向下转型
* 判断一下父类引用 animal 本来是不是Dog
* */
if (animal instanceof Dog) {
Dog dog = (Dog) animal;
dog.watchHouse();
}
// 判断一下 animal 本来是不是Cat
if (animal instanceof Cat) {
Cat cat = (Cat) animal;
cat.catchMouse(); // 猫抓老鼠
}
// 给我一个动物
giveMeAPet(new Dog());
}
public static void giveMeAPet(Animal animal) {
if (animal instanceof Dog) {
Dog dog = (Dog) animal;
dog.watchHouse(); // 狗看家
}
if (animal instanceof Cat) {
Cat cat = (Cat) animal;
cat.catchMouse();
}
}
}
多态综合案例:笔记本电脑接口
接口的基本使用–对象的上下转型–使用接口作为方法的参数
package obj.Animal.demo01.demo1.USB;
public class DemoMain {
public static void main(String[] args) {
// 首先创建一个笔记本电脑
Computer computer = new Computer();
computer.powerOn();
// 准备一个鼠标,供电脑使用:首先进行向上转型
USB usbMouse = new Mouse();
// 参数是USB类型,我正好传递进去的就是USB鼠标
computer.useDevice(usbMouse);
// 创建一个USB键盘
Keyboard keyboard = new Keyboard(); // 没有使用多态写法
// 方法参数是USB类型,传递进去的是实现类对象
computer.useDevice(keyboard); // 正确写法,发生了向上转型
// 使用子类对象,匿名对象,也可以
computer.useDevice(new Keyboard()); // 正确写法
computer.powerOff();
System.out.println("============");
method(10.0); // 正确写法:double ---> double
method(20); // 正确写法:int ---> double
int a = 30;
method(a); // 正确写法:int ---> double
computer.powerOff();
}
public static void method(double num) {
System.out.println(num);
}
}
- 电脑
package obj.Animal.demo01.demo1.USB;
// 电脑
public class Computer {
public void powerOn() {
System.out.println("笔记本电脑开机");
}
public void powerOff() {
System.out.println("笔记本电脑关机");
}
// 使用USB设备的方法,使用接口作为方法的参数
public void useDevice(USB usb) {
usb.open(); // 打开设备
if (usb instanceof Mouse) { // 一定要先判断
Mouse mouse = (Mouse) usb; // 向下转型
mouse.click();
} else if (usb instanceof Keyboard) { // 先判断
Keyboard keyboard = (Keyboard) usb; // 向下转型
keyboard.type();
}
usb.close(); // 关闭设备
}
}
- usb 抽象类
package obj.Animal.demo01.demo1.USB;
// usb 抽象类
public abstract class USB {
public abstract void open(); // 打开设备
public abstract void close(); // 关闭设备
}
- 鼠标
package obj.Animal.demo01.demo1.USB;
// 鼠标就是一个USB设备
public class Mouse extends USB {
@Override
public void open() {
System.out.println("打开鼠标");
}
@Override
public void close() {
System.out.println("关闭鼠标");
}
public void click() {
System.out.println("鼠标点击");
}
}
- 键盘
package obj.Animal.demo01.demo1.USB;
// 键盘就是一个USB设备
public class Keyboard extends USB {
@Override
public void open() {
System.out.println("打开键盘");
}
@Override
public void close() {
System.out.println("关闭键盘");
}
public void type() {
System.out.println("键盘输入");
}
}
final关键字
- final关键字-修饰类
package obj.Animal.demo01.demo1.Final;
/*
* 当final关键字用来修饰一个类的时候,格式:
* public final class 类名称 { 方法体 }
*
* 含义:当前这个类不能有任何的子类。(太监类)
* 注意:一个类如果是final的,那么其中所有的成员方法都无法进行覆盖重写(因为没儿子)
* */
public final class MyClass {
public void method() {
System.out.println("方法执行");
}
}
- 父类:final关键字-修饰成员方法
package obj.Animal.demo01.demo1.Final;
/*
* 当final关键字用来修饰一个方法的时候,这个方法就是最终方法,也就是不能被覆盖重写。
* 格式: 修饰符 final 返回值类型 方法名称(参数列表) { 方法体 }
*
* 注意事项:
* 1.对于类、方法来说,abstract关键字和final关键字不能同时使用,因为矛盾。
* */
public abstract class Fu {
public final void method() {
System.out.println("父类方法执行");
}
public abstract /*final*/ void methodAbs();
}
- 子类
package obj.Animal.demo01.demo1.Final;
public class Zi extends Fu{
@Override
public void methodAbs() {
}
// 错误写法:不能覆盖重写父类当中final的方法
// @Override
// public void method() {
// System.out.println("子类覆盖重写父类的方法");
// }
}
- final关键字-修饰局部变量
package obj.Animal.demo01.demo1.Final;
/*
* final关键字代表最终、不可改变的。
*
* 常见四种用法:
* 1.可以用来修饰一个类
* 2.可以用来修饰一个方法
* 3.还可以用来修饰一个局部变量
* 4.还可以用来修饰一个成员变量
* */
public class Demo01Final {
public static void main(String[] args) {
int num1 = 10;
System.out.println(num1); // 10
num1 = 20;
System.out.println(num1); // 20
/*
* 一旦使用final用来修饰局部变量,那么这个变量就不能进行更改。
* 一次赋值,终生不变
* */
final int num2 = 200;
System.out.println(num2); // 200
// num2 = 250; // 错误写法:不能改变
// num2 = 200; // 错误写法:即使赋值为原值200,也不可以!!!
// 正确写法:只要保证有唯一一次赋值即可
final int num3;
num3 = 30;
/*
* 对于基本类型来说,不可变说的是变量当中的数据不可改变。
* 对于引用类型来说,不可变说的是变量当中的地址值不可改变。
* */
Student stu1 = new Student("赵丽颖");
System.out.println(stu1); // obj.Animal.demo01.demo1.Final.Student@1540e19d
System.out.println(stu1.getName()); // 赵丽颖
stu1 = new Student("霍建华");
System.out.println(stu1); // obj.Animal.demo01.demo1.Final.Student@677327b6
System.out.println(stu1.getName()); // 霍建华
System.out.println("=======================");
final Student stu2 = new Student("刘诗诗");
// stu2 = new Student("吴奇隆"); // 错误写法! final的引用类型变量,其中的地址不可改变
System.out.println(stu2.getName()); // 刘诗诗
stu2.setName("诗爷");
System.out.println(stu2.getName()); // 诗爷
}
}
- Person类:final关键字-修饰成员变量
package obj.Animal.demo01.demo1.Final;
/*
* 对于成员变量来说,如果使用final关键字修饰,那么这个变量也照样是不可变。
* 1.由于成员变量具有默认值,所以用了final之后必须手动赋值,不会再给默认值了。
* 2.对于final的成员变量,要么使用直接赋值,要么通过构造方法赋值。二者选其一
* 3.必须保证类当中所有重载的构造方法,都最终会对final的成员变量进行赋值。
* */
public class Person {
private final String name;
// 无参构造
public Person() {
name = "刘诗诗";
}
// 有参构造
public Person(String name) {
this.name = name;
}
// Getter/Setter方法
public String getName() {
return name;
}
// public void setName(String name) {
// this.name = name;
// }
}
- 学生类
package obj.Animal.demo01.demo1.Final;
// 学生类
public class Student {
private String name;
// 无参构造
public Student() {
}
// 有参构造
public Student(String name) {
this.name = name;
}
// Getter/Setter方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
四种权限修饰符
Java中有四种权限修饰符: (权限:从大到小)
public > protected > (default) > private
注意:(default) 并不是关键字"default",而是根本不写。
- | public | protected | (default) | private |
---|---|---|---|---|
同一个类(我自己) | √ | √ | √ | √ |
同一个包(我邻居) | √ | √ | √ | × |
不同包子类(我儿子) | √ | √ | × | × |
不同包非子类(陌生人) | √ | × | × | × |
成员内部类的定义和使用
package wd01.demo01;
/*
* 如果一个事物的内部包含另一个事物,那么这就是一个类内部包含另一个类。
* 例如:汽车和发动机的关系。
*
* 分类:
* 1.成员内部类
* 2.局部内部类(包含匿名内部类)
*
* 成员内部类的定义格式:
* 修饰符 class 外部类名称 {
* 修饰符 class 内部类名称 {
* // ...
* }
* // ...
* }
*
* 注意:内用外,随意访问;外用内,需要内部类对象。
* =====================
* 如何使用成员内部类?有两种方式:
* 1.间接方式:在外部类的方法当中,使用内部类;然后main只是调用外部类的方法。
* 2.直接方式:
* 类名称 对象名 = new 类名称();
* 外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
* */
public class Demo01InnerClass {
public static void main(String[] args) {
Body body = new Body(); // 外部类的对象
// 通过外部类的对象,调用外部类的方法,里面间接在使用内部类Heart
body.methodBody();
System.out.println("========");
// 按照公式写:
Body.Heart heart = new Body().new Heart();
heart.beat();
}
}
package wd01.demo01;
public class Body {
// 外部类的成员变量
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public class Heart {
// 内部类的方法
public void beat() {
System.out.println("心脏跳动");
System.out.println("我叫:" + name); // 正确写法
}
}
// 外部类的方法
public void methodBody() {
System.out.println("外部类的方法");
// 在外部类的方法里面,创建内部类对象
Heart heart = new Heart();
heart.beat();
}
}
内部类的同名变量访问
package wd01.demo01;
public class Demo02InnerClass {
public static void main(String[] args) {
// 外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
Outer.Inner obj = new Outer().new Inner();
obj.methodInner();
}
}
package wd01.demo01;
// 如果出现了重名现象,那么格式是:外部类名称.this.外部类成员变量名
public class Outer {
int num = 10; // 外部类的成员变量
public class Inner {
int num = 20; // 内部类的成员变量
public void methodInner() {
int num = 30; // 内部类方法的局部变量
System.out.println(num); // 局部变量,就近原则 30
System.out.println(this.num); // 内部类的成员变量 20
System.out.println(Outer.this.num); // 外部类的成员变量 10
}
}
}
局部内部类的final问题
package wd01.demo01.Outes;
/*
* 局部内部类:如果希望访问所在方法的局部变量,那么这个局部变量必须是【有效final的】
*
* 备注:从Java 8+开始,只要局部变量事实不变,那么final关键字可以省略。
*
* 原因:
* 1.new出来的对象在堆内存当中。
* 2.局部变量是跟着方法走的,在栈内存当中。
* 3.方法运行结束之后,立刻出栈,局部变量就会立刻消失。
* 4.但是new出来的对象会在堆当中持续存在,直到垃圾回收消失。
* */
public class MyOuter {
public void methodOuter() {
final int num = 10; // 所在方法的局部变量
class MyInner {
public void methodInner() {
System.out.println(num);
}
}
}
}
匿名内部类【重点】
package wd01.demo01.niName;
/*
* 如果接口的实现类(或者是父类的子类)只需要使用唯一的一次。
* 那么这种情况下就可以省略掉该类的定义,而改为使用【匿名内部类】
*
* 匿名内部类的定义格式:
* 接口名称 对象名 = new 接口名称() {
* // 覆盖重写所有抽象方法
* }
*
* 对格式 "new 接口名称() { ... }"进行解析:
* 1.new 代表创建对象的动作
* 2.接口名称就是匿名内部类需要实现哪个接口
* 3.{ ... }这才是匿名内部类的内容
*
* 另外还有注意几点问题:
* 1.匿名内部类,在创建对象的时候,只能使用唯一一次。
* 如果希望多次创建对象,而且类的内容一样的话,那么就必须使用单独定义的实现类了。
* 2.匿名对象,在【调用方法】的时候,只能调用唯一一次。
* 如果希望同一个对象,调用多次方法,那么必须给对象起个名字。
* 3.匿名内部类是省略了【实现类/子类名称】,但是匿名对象是省略了【对象名称】
* 强调:匿名内部类和匿名对象不是一回事儿!!!
* */
public class DemoMain {
public static void main(String[] args) {
// MyInterfaceImpl impl = new MyInterfaceImpl();
// impl.method();
// 使用匿名内部类
MyInterface objA = new MyInterface() {
@Override
public void method() {
System.out.println("匿名内部类实现了方法");
}
};
objA.method();
System.out.println("===========");
// 使用了匿名内部类,而且省略了对象名称,也是匿名对象
new MyInterface() {
@Override
public void method() {
System.out.println("匿名内部类实现了方法");
}
}.method();
}
}
package wd01.demo01.niName;
public interface MyInterface {
public abstract void method(); // 抽象方法
}
类作为成员变量类型
package wd01.demo01.Heros;
public class DemoMain {
public static void main(String[] args) {
// 创建一个英雄角色
Hero hero = new Hero();
// 为英雄起一个名字,并且设置年龄
hero.setName("盖伦");
hero.setAge(20);
// 创建一个武器对象
Weapon weapon = new Weapon("圣剑");
// 为英雄配备武器
hero.setWeapon(weapon);
// 攻击
hero.attack();
}
}
- 英雄
package wd01.demo01.Heros;
/*
* 游戏当中的英雄角色类
* */
public class Hero {
private String name; // 英雄名字
private int age; // 英雄的年龄
private Weapon weapon; // 英雄的武器
public Hero() {
}
public Hero(String name, int age, Weapon weapon) {
this.name = name;
this.age = age;
this.weapon = weapon;
}
// 攻击敌人
public void attack() {
System.out.println("年龄为" + age + "的" + name + "用" + weapon.getCode() + "攻击敌方");
}
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 Weapon getWeapon() {
return weapon;
}
public void setWeapon(Weapon weapon) {
this.weapon = weapon;
}
}
- 武器
package wd01.demo01.Heros;
public class Weapon {
private String code; // 武器的代号
public Weapon() {
}
public Weapon(String code) {
this.code = code;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
}
接口作为成员变量类型
package wd01.demo01.implement;
public class DemoGame {
public static void main(String[] args) {
Hero hero = new Hero();
hero.setName("艾希"); // 设置英雄的名称
// 设置英雄技能--使用单独定义的实现类
hero.setSkill(new SkillImpl());
// 还可以改成使用匿名内部类
Skill skill = new Skill() {
@Override
public void use() {
System.out.println("呯呯呯");
}
};
hero.setSkill(skill);
// 进一步简化,同时使用匿名内部类和匿名对象
hero.setSkill(new Skill() {
@Override
public void use() {
System.out.println("喵喵喵~");
}
});
// 攻击敌人
hero.attack();
}
}
package wd01.demo01.implement;
public class Hero {
private String name; // 英雄的名称
private Skill skill; // 英雄的技能
public Hero() {
}
public Hero(String name, Skill skill) {
this.name = name;
this.skill = skill;
}
public void attack() {
System.out.println("我叫" + name + "开始释放技能");
skill.use(); // 调用接口中的抽象方法
System.out.println("释放技能完成");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Skill getSkill() {
return skill;
}
public void setSkill(Skill skill) {
this.skill = skill;
}
}
package wd01.demo01.implement;
public class SkillImpl implements Skill{
@Override
public void use() {
System.out.println("咚咚咚~");
}
}
package wd01.demo01.implement;
public interface Skill {
void use(); // 释放技能的抽象方法
}
接口作为方法的参数和返回值
package wd01.demo01.implement;
import java.util.ArrayList;
import java.util.List;
/*
* java.util.list 正是ArrayList所实现的接口
* */
public class DemoInterface {
public static void main(String[] args) {
// 左边是接口名称,右边是实现类名称,这就是多态写法
List<String> list = new ArrayList<>();
List<String> result = addNames(list);
for (int i = 0; i < result.size(); i++) {
System.out.println(result.get(i));
}
}
public static List<String> addNames(List<String> list) {
list.add("迪丽热巴");
list.add("古力娜扎");
list.add("马尔扎哈");
list.add("沙扬娜拉");
return list;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Weapon getWeapon() {
return weapon;
}
public void setWeapon(Weapon weapon) {
this.weapon = weapon;
}
}
- 武器
package wd01.demo01.Heros;
public class Weapon {
private String code; // 武器的代号
public Weapon() {
}
public Weapon(String code) {
this.code = code;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
}
接口作为成员变量类型
package wd01.demo01.implement;
public class DemoGame {
public static void main(String[] args) {
Hero hero = new Hero();
hero.setName("艾希"); // 设置英雄的名称
// 设置英雄技能--使用单独定义的实现类
hero.setSkill(new SkillImpl());
// 还可以改成使用匿名内部类
Skill skill = new Skill() {
@Override
public void use() {
System.out.println("呯呯呯");
}
};
hero.setSkill(skill);
// 进一步简化,同时使用匿名内部类和匿名对象
hero.setSkill(new Skill() {
@Override
public void use() {
System.out.println("喵喵喵~");
}
});
// 攻击敌人
hero.attack();
}
}
package wd01.demo01.implement;
public class Hero {
private String name; // 英雄的名称
private Skill skill; // 英雄的技能
public Hero() {
}
public Hero(String name, Skill skill) {
this.name = name;
this.skill = skill;
}
public void attack() {
System.out.println("我叫" + name + "开始释放技能");
skill.use(); // 调用接口中的抽象方法
System.out.println("释放技能完成");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Skill getSkill() {
return skill;
}
public void setSkill(Skill skill) {
this.skill = skill;
}
}
package wd01.demo01.implement;
public class SkillImpl implements Skill{
@Override
public void use() {
System.out.println("咚咚咚~");
}
}
package wd01.demo01.implement;
public interface Skill {
void use(); // 释放技能的抽象方法
}
接口作为方法的参数和返回值
package wd01.demo01.implement;
import java.util.ArrayList;
import java.util.List;
/*
* java.util.list 正是ArrayList所实现的接口
* */
public class DemoInterface {
public static void main(String[] args) {
// 左边是接口名称,右边是实现类名称,这就是多态写法
List<String> list = new ArrayList<>();
List<String> result = addNames(list);
for (int i = 0; i < result.size(); i++) {
System.out.println(result.get(i));
}
}
public static List<String> addNames(List<String> list) {
list.add("迪丽热巴");
list.add("古力娜扎");
list.add("马尔扎哈");
list.add("沙扬娜拉");
return list;
}
}