java基础篇

IDEA常用快捷键

快捷键功能Alt+Enter自动修正代码Ctrl+Y删除光标所在行Ctrl+D复制光标所在行的内容，插入光标位置下面Ctrl+Alt +L格式化代码Ctrl+/单行注释，再按取消注释Ctrl+Shift+/选中代码注释，多行注释，再按取消注释。Alt+Ins自动生成代码，toString，get，set等方法Alt+Shift+上下箭头移动当前代码行

继承的概述

继承的格式

创建对象

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); } }