java基础篇

IDEA常用快捷键

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

接口的定义

接口的定义基本格式

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"，而是根本不写。 -publicprotected(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; } }