一、static关键字

1.static 修饰属性和方法

当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上的对象，只有通过 new 关键字才会产生出对象，这时系统才会分配内存空间给对象，其方法才可以供外部调用。

我们有时候希望无论是否产生了对象或无论产生了多少对象的情况下，某些特定的数据在内存空间里只有一份。

例如所有的中国人都有个国家名称，每一个中国人都共享这个国家名称，不必在每一个中国人的实例对象中都单独分配一个用于代表国家名称的变量。
image.png

  1. /**
  2.  * static关键字的使用
  3.  * 1.static 静态的
  4.  * 2.static 可以用来修饰 属性、方法、代码块、内部类
  5.  * 3.使用 static 修饰属性:静态变量(或类变量)。
  6.  *         3.1 属性:是否使用 static 修饰，又分为:静态属性 VS 非静态属性(实例变量)
  7.  *             实例变量:我们创建了类的多个对象，每个对象都独立的拥有了一套类中的非静态属性。
  8.  *                 当修改其中一个非静态属性时，不会导致其他对象中同样的属性值的修饰。
  9.  *             静态变量:我们创建了类的多个对象，多个对象共享同一个静态变量。当通过静态变量去修改某一个变量时，
  10.  *                 会导致其他对象调用此静态变量时，是修改过的。
  11.  *         3.2 static 修饰属性的其他说明:
  12.  *             ① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用。
  13.  *             ② 静态变量的加载要早于对象的创建。
  14.  *             ③ 由于类只会加载一次，则静态变量在内存中也只会存在一次。存在方法区的静态域中。
  15.  * 4.静态属性举例：System.out、Math.PI
  16.  * 5.使用 static 修饰方法:静态方法
  17.  *         ① 随着类的加载而加载，可以通过"类.静态方法"的方式调用
  18.  *         ②             静态方法        非静态方法
  19.  *             类        yes            no
  20.  *             对象        yes            yes
  21.  *         ③ 静态方法中，只能调用静态的方法或属性
  22.  *           非静态的方法中，可以调用所有的方法或属性
  23.  * 6.static 注意点:
  24.  *      6.1  在静态的方法内，不能使用 this 关键字、super 关键字
  25.  *   6.2 关于静态属性和静态方法的使用，大家从生命周期的角度去理解。
  26.  * 7.开发中，如何确定一个属性是否需要声明 static 的？
  27.  *      > 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
  28.  *      > 类中的常量也常常声明为 static
  29.  *   
  30.  *   开发中，如何确定一个方法是否要声明为 static 的？
  31.  *   > 操作静态属性的方法，通常设置为 static 的
  32.  *   > 工具类中的方法，习惯上声明为 static 的。比如：Math、Arrays、Collections
  33.  */
  35. public class StaticTest{
  36.     public static void main(String[] args) {
  37.         //静态变量加载随着类的加载而加载，早于对象的创建
  38.         Chinese.nation = "中国";//可以提前调用
  39.         //实例化
  40.         Chinese c1 = new Chinese();
  41.         c1.name = "嘉然";
  42.         c1.age = 3;
  43.         Chinese c2 = new Chinese();
  44.         c2.name = "乃琳";
  45.         c2.age = 18;
  46.         //修改c1的nation
  47.         c1.nation = "CHN";//这种方法其实有点问题，正规方法为：Chinese nation = "CHN"; 此处仅为好说明问题
  48.         //输出c2的nation
  49.         System.out.println(c2.nation);//也为CHN，有点全局变量的味儿~
  50.         //非静态方法只能用对象
  51.         c1.eat();
  52.         //静态方法可以用类来调用
  53.         Chinese.show();
  54.     }
  55. }
  57. class Chinese{
  58.     String name;
  59.     int age;
  60.     static String nation;
  61.     //非静态方法
  62.     public void eat(){
  63.         System.out.println("中国人吃中餐");
  64.     }
  65.     //静态方法
  66.     public static void show(){
  67.         System.out.println("我是中国人");
  68.     }
  69. }

2.类变量 vs 实例变量内存解析

image.png

3. 自定义数组工具类的优化

3.二.11的老代码，可以转换成static

  1. /**
  2.  * Test
  3.  */
  4. public class Test {
  5.         public static void main(String[] args) {
  6.             int[] arr = new int[]{1,2,3};
  7.             //ArrayUtil arraytool = new ArrayUtil(); 换成是static没必要new对象了
  8.             arraytool.getReversal(arr);
  9.         }
  11. }
  13. class ArrayUtil{
  14.     public static void getMax(int[] arr){
  15.         // 求数组的最大值
  16.         int max = arr[0];
  17.         for(int i = 1;i < arr.length;i++){
  18.             if(max < arr[i]){
  19.                 max = arr[i];
  20.             }
  21.         }
  22.         System.out.println(max);
  23.     }
  24.     public void static getMin(int[] arr){
  25.         // 求数组的最小值
  26.         int min = arr[0];
  27.         for(int i = 1;i < arr.length;i++){
  28.             if(min > arr[i]){
  29.                 min = arr[i];
  30.             }
  31.         }
  32.         System.out.println(min);
  33.     }
  34.     public void static getSum(int[] arr){
  35.         // 求数组的总和
  36.         int sum = arr[0];
  37.         for(int i = 1;i < arr.length;i++){
  38.             sum += arr[i];
  39.         }
  40.         System.out.println(sum);
  41.     }
  42.     public void static getAver(int[] arr){
  43.         // 求平均值
  44.         int sum = arr[0];
  45.         for(int i = 1;i < arr.length;i++){
  46.             sum += arr[i];
  47.         }
  48.         int aver = sum / arr.length;
  49.         System.out.println(aver);
  50.     }
  51.     public void static getReversal(int[] arr){
  52.         // 反转数组
  53.         for(int i = 0, j = arr.length-1;i < j;i++, j--){
  54.             int temp = arr[i];
  55.             arr[i] = arr[j];
  56.             arr[j] = temp;
  57.         }
  58.         for(int i = 0;i < arr.length;i++){
  59.             System.out.println(arr[i]);
  60.         }
  61.     }
  62.     public int[] static getCopy(int[] arr){
  63.         // 创建备份数组，且长度相等
  64.         int[] beifen = new int[arr.length];
  65.         // 遍历原数组并赋给备份数组
  66.         for(int i = 0;i < arr.length;i++){
  67.             beifen[i] = arr[i];
  68.         }
  69.         // 遍历备份数组
  70.         for(int i = 0;i < beifen.length;i++){
  71.             System.out.print(beifen[i]);
  72.         }
  73.         return beifen;
  74. }
  75.     public void static getOrder(int[] arr){
  76.         // 数组排序
  77.         for(int i = 0;i < arr.length - 1;i++){
  78.             for(int j = 0;j < arr.length - 1 -i;j++){
  79.                 if(arr[j] > arr[j+1]){
  80.                     int temp = arr[j];
  81.                     arr[j] = arr[j+1];
  82.                     arr[j+1] = temp;
  83.                 }
  84.             }
  85.         }
  86.         for(int i = 0;i < arr.length;i++){
  87.             System.out.println(arr[i]);
  88.         }
  89.     }
  90.     public void static getSerch(int[] arr, int desitination){
  91.         // 查找指定元素
  92.         for(int i = 0;i < arr.length;i++){
  93.             if(desitination == arr[i]){
  94.                 System.out.println("找到了索引为" + i);
  95.             }
  97.         }
  98.     }
  99. }

4.static 应用举例

  1. //static 关键字的应用
  2. public class CircleTest {
  3.     public static void main(String[] args) {
  5.         Circle c1 = new Circle();
  7.         Circle c2 = new Circle();
  9.         Circle c3 = new Circle();
  11.         System.out.println("c1 的 ID:" + c1.getId());
  12.         System.out.println("c2 的 ID:" + c2.getId());
  13.         System.out.println("c3 的 ID:" + c3.getId());
  15.         System.out.println("创建圆的个数: " + Circle.getTotal());
  17.     }
  19. }
  21. class Circle{
  23.     private double radius;
  24.     private int id;    //需要自动赋值
  26.     public Circle(){
  27.         id = init++;
  28.         total++;
  29.     }
  31.     public Circle(double radius){
  32.         this();
  33.         //或
  34. //        id = init++;
  35. //        total++;
  36.         this.radius = radius;
  37.     }
  39.     private static int total;//记录创建圆的个数
  40.     private static int init = 1001;//static 声明的属性被所有对象所共享
  42.     public double findArea(){
  43.         return 3.14 * radius * radius;
  44.     }
  46.     public double getRadius() {
  47.         return radius;
  48.     }
  50.     public void setRadius(double radius) {
  51.         this.radius = radius;
  52.     }
  54.     public int getId() {
  55.         return id;
  56.     }
  58.     public static int getTotal() {
  59.         return total;
  60.     }
  62. }

5.设计模式和单例设计模式

暂不入职，，，略

二、main()方法(了解)

1.理解main()方法

  1. /**
  2.  * 1.main()方法作为程序的入口
  3.  * 2.main()方法也是一个普通的静态方法
  4.  * 3.main()方法也可以做为和控制台交互的方式
  5.  *  具体为1.编译：javac demo.java 2.运行：java demo 参数1 参数2 ... 参数n 
  6.  */
  7. public class MainTest {
  8.     public static void main(String[] args) {
  9.         //静态方法可以直接调用
  10.         Main.main(new String[100]);
  12.     }
  13. }
  14. class Main{
  15.     public static void main(String[] args) {
  16.         for(int i = 0;i < 100;i++){
  17.             args[i] = "arg" + i;
  18.             System.out.println(args[i]);
  19.         }
  20.     }
  21. }

三、类的成员之代码块

1.类中代码块结构的使用

  1. /**
  2.  * 类的成员之四：代码块（或初始化块）
  3.  * 1.代码块的作用：初始化类和对象
  4.  * 2.代码块只能使用static修饰（也就分为静态代码块和非静态代码块）
  5.  * 3.静态代码块：
  6.  * >内部可以有输出语句
  7.  * >随着类的加载而执行，而且只执行一次
  8.  * >静态代码块只能调用静态属性 静态方法
  9.  * >作用：初始化类的信息
  10.  * 4.非静态代码块
  11.  * >内部可以有输出语句
  12.  * >每创建一个对象就执行一次
  13.  * >非静态代码块可以调用静态属性 静态方法 非静态属性 非静态方法
  14.  * >作用：在创建对象时可以对对象进行初始化
  15.  * 5.静态代码块始终优先于非静态执行
  16.  */
  17. public class BlockTest {
  18.     public static void main(String[] args) {
  19.         Person p = new Person();//随着对象加载非static代码块执行了
  20.         p.eat();
  21.     }
  22. }
  23. class Person{
  24.     //属性
  25.     String name;
  26.     int age;
  27.     static String description = "我是一个人";
  28.     //构造器
  29.     public Person(){
  31.     }
  32.     public Person(String name,int age){
  33.         this.name = name;
  34.         this.age = age;
  35.     }
  36.     //static代码块
  37.     static{
  38.         System.out.println("你好，夹心糖的静态代码块");
  39.         //只能调用静态的
  40.         description = "我是一个人类";
  41.         Person.info();
  42.     }
  43.     //非static代码块
  44.     {
  45.         System.out.println("你好，夹心糖的非静态代码块");
  46.         description = "我是一个人类";
  47.         Person.info();
  48.         //非静态的属性，方法也能调
  49.         name = "Tom";
  50.         age = 12;
  51.         this.eat();
  52.     }
  53.     //方法
  54.     public void eat(){
  55.         System.out.println("吃饭");
  56.     }
  57.     @Override
  58.     public String toString() {
  59.         return "Person[name=" + name + ",age=" + age + "]";
  60.     }
  61.     //静态方法
  62.     public static void info(){
  63.         System.out.println("我是人类");
  64.     }
  65. }

2.代码块举例

  1. //总结:由父类到子类，静态先行
  2. class Root{
  3.     static{
  4.         System.out.println("Root 的静态初始化块");
  5.     }
  6.     {
  7.         System.out.println("Root 的普通初始化块");
  8.     }
  9.     public Root(){
  10.         System.out.println("Root 的无参数的构造器");
  11.     }
  12. }
  13. class Mid extends Root{
  14.     static{
  15.         System.out.println("Mid 的静态初始化块");
  16.     }
  17.     {
  18.         System.out.println("Mid 的普通初始化块");
  19.     }
  20.     public Mid(){
  21.         System.out.println("Mid 的无参数的构造器");
  22.     }
  23.     public Mid(String msg){
  24.         //通过 this 调用同一类中重载的构造器
  25.         this();
  26.         System.out.println("Mid 的带参数构造器，其参数值："
  27.             + msg);
  28.     }
  29. }
  30. class Leaf extends Mid{
  31.     static{
  32.         System.out.println("Leaf 的静态初始化块");
  33.     }
  34.     {
  35.         System.out.println("Leaf 的普通初始化块");
  36.     }    
  37.     public Leaf(){
  38.         //通过 super 调用父类中有一个字符串参数的构造器
  39.         super("尚硅谷");
  40.         System.out.println("Leaf 的构造器");
  41.     }
  42. }
  43. public class LeafTest{
  44.     public static void main(String[] args){
  45.         new Leaf(); 
  46.         //new Leaf();
  47.     }
  48. }

四、final关键字

1.final关键字的使用及注意

  1. /**
  2.  * 1.final可以修饰 类 变量 方法
  3.  * 2.final修饰类不能被继承。比如：String类、System类、StringBuffer类
  4.  * 3.final修饰方法表示方法不会被重写
  5.  * 4.final修饰变量:此时“变量”变成常量了.显式初始化、代码块中初始化、构造器中初始化
  6.  * 5.final修饰形参的时候也传入值也会变成常量
  7.  * 6.static final ： 修饰一个全局变量
  8.  */
  9. public class FinalTest {
  10.     final int width = 10;
  11.     public void doWidth(){
  12.         //错误的，常量无法被操作
  13.         width+=5;
  14.     }
  15.     public void show(final int num){
  16.         //传入参数用final
  17.         num+=5;
  18.     }
  19.     public static void main(String[] args) {
  20.         int num = 10;
  21.         num = num + 5;
  22.     }
  23. }
  24. //final修饰类后，无法被其他类继承
  25. final class A{
  27. }
  28. //错误的,final修饰类后，无法被其他类继承
  29. class B extends A{
  31. }
  32. class AA{
  33.     //final修饰方法后不能被重写
  34.     public final void show(){
  36.     }
  37. }
  38. class BB extends AA{
  39.     //错误的，final修饰方法后不能被重写
  40.     public void show(){
  42.     }
  43. }

六、抽象类与抽象方法

1.抽象类与抽象方法的使用

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。
image.png

  1. package com.test.java;
  2. /*
  3. * abstract关键字的使用
  4. * 1.abstract：抽象的
  5. * 2.abstract可以修饰类、方法
  6. * 3.abstract修饰类：
  7. * >此类就不能实例化
  8. * >抽象类中一定有构造器，便于子类实例化时调用（涉及:子类对象实例化的全过程)
  9. * >开发中，都会提供抽象类的子类，让子类对象实例化，完成父类相关的操作
  10. * 4.abstract修饰方法：抽象方法
  11. * >抽象方法只有方法的声明，没有方法体
  12. * >包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
  13. * >若子类重写了父类中的所有的抽象方法后，此子类方可实例化
  14. */
  15. public class Hello {
  16.     public static void main(String[] args) {
  17.         //一旦Person类抽象了，就不可实例化
  18.         //        Person p1 = new Person();
  19.         //        p1.eat();
  20.     }
  21. }
  23. abstract class Person{
  24.     String name;
  25.     int age;
  26.     public Person(){
  28.     }
  29.     public Person(String name,int age){
  30.         this.name = name;
  31.         this.age = age;
  32.     }
  33.     //不是抽象方法
  34.     //    public void eat(){
  35.     //        System.out.println("人吃饭");
  36.     //    }
  37.     //抽象方法，分号结尾
  38.     public abstract void eat();
  39.     public void sleep(){
  40.         System.out.println("人睡觉");
  41.     }
  42. }
  44. class Student extends Person{
  45.     public Student(String name,int age){
  46.         super(name, age);
  47.     }
  48.     //子类必须重写父类的抽象方法，才可实例化
  49.     public void eat(){
  50.         System.out.println("学生吃健康的");
  51.     }
  52. }

image.png

  1. /* Java 允许类设计者指定：超类声明一个方法但不提供实现，该方法的实现由子类提  供。这样的方法称为抽象方法。有一个或更多抽象方法的类称为抽象类。
  2.  * Vehicle 是一个抽象类，有两个抽象方法。
  3.  * 注意：抽象类不能实例化 new Vihicle()是非法的
  4.  */
  5. public abstract class Vehicle{
  6.     public abstract double calcFuelEfficiency();//计算燃料效率的抽象方法
  7.     public abstract double calcTripDistance();//计算行驶距离的抽象方法
  8. }
  9. public class Truck extends Vehicle{
  10.     public double calcFuelEfficiency(){ 
  11.         //写出计算卡车的燃料效率的具体方法
  12.     }
  13.     public double calcTripDistance(){ 
  14.         //写出计算卡车行驶距离的具体方法
  15.     }
  16. }
  17. public class RiverBarge extends Vehicle{
  18.     public double calcFuelEfficiency() { 
  19.         //写出计算驳船的燃料效率的具体方法
  20.     }
  21.     public double calcTripDistance( )  {  
  22.         //写出计算驳船行驶距离的具体方法
  23.     }
  24. }

2.练习

  1. package com.test.java;
  2. /*
  3.  * 编写一个 Employee 类，声明为抽象类，
  4.  * 包含如下三个属性：name，id，salary。
  5.  * 提供必要的构造器和抽象方法：work()。
  6.  * 对于 Manager 类来说，他既是员工，还具有奖金(bonus)的属性。
  7.  * 请使用继承的思想，设计 CommonEmployee 类和 Manager 类，
  8.  * 要求类中提供必要的方法进行属性访问。
  9.  */
  10. public abstract class Employee {
  11.     private String name;
  12.     private int id;
  13.     private double salary;
  14.     public Employee(){
  16.     }
  17.     public Employee(String name,int id,double salary){
  18.         this.name = name;
  19.         this.id = id;
  20.         this.salary = salary;
  21.     }
  22.     public abstract void work();
  24. }
  1. /*
  2.  * 对于 Manager 类来说，他既是员工，还具有奖金(bonus)的属性。
  3.  * 
  4.  */
  5. public class Manager extends Employee{
  7.     private double bonus;    //奖金
  9.     public Manager(double bonus) {
  10.         super();
  11.         this.bonus = bonus;
  12.     }
  14.     public Manager(String name, int id, double salary, double bonus) {
  15.         super(name, id, salary);
  16.         this.bonus = bonus;
  17.     }
  20.     @Override
  21.     public void work() {
  22.         System.out.println("管理员工，提高公司运行效率。");        
  23.     }
  24. }
  1. public class CommonEmployee extends Employee {
  3.     @Override
  4.     public void work() {
  5.         System.out.println("员工在一线车间生产产品。");
  6.     }
  7. }
  1. /*
  2.  * 请使用继承的思想，设计 CommonEmployee 类和 Manager 类，
  3.  */
  4. public class EmployeeTest {
  5.     public static void main(String[] args) {
  7.         Employee manager = new Manager("库克",1001,5000,50000);
  9.         manager.work();
  11.         CommonEmployee commonEmployee = new CommonEmployee();
  12.         commonEmployee.work();
  13.     }
  14. }

3.创建抽象类的匿名子类对象

  1. /*
  2.  * 抽象类的匿名子类
  3.  * 
  4.  */
  5. public class PersonTest {
  6.     public static void main(String[] args) {
  8.         method(new Student());    //匿名对象
  10.         Worker worker = new Worker(); 
  11.         method1(worker);    //非匿名的类非匿名的对象
  13.         method1(new Worker());    //非匿名的类匿名的对象
  15.         System.out.println("*********************");
  17.         //创建了一个匿名子类的对象:p
  18.         Person p = new Person(){
  20.             @Override
  21.             public void eat() {
  22.                 System.out.println("吃东西");
  23.             }
  25.             @Override
  26.             public void breath() {
  27.                 System.out.println("呼吸空气");
  28.             }
  30.         };
  31.         method1(p);
  32.         System.out.println("**********************"); 
  33.         //创建匿名子类的匿名对象
  34.         method1(new Person(){
  36.             @Override
  37.             public void eat() {
  38.                 System.out.println("吃零食");
  39.             }
  41.             @Override
  42.             public void breath() {
  43.                 System.out.println("云南的空气");
  44.             }
  46.         });
  47.     }
  49.     public static void method1(Person p){
  50.         p.eat();
  51.         p.walk();
  52.     }
  54.     public static void method(Student s){
  56.     }
  57. }
  58. class Worker extends Person{
  60.     @Override
  61.     public void eat() {
  62.     }
  64.     @Override
  65.     public void breath() {
  66.     }
  67. }

4.模板方法设计模式

  1. /*
  2.  * 抽象类的应用:模板方法的设计模式
  3.  */
  4. public class TemplateTest {
  5.     public static void main(String[] args) {
  7.         SubTemlate t = new SubTemlate();
  9.         t.sendTime();
  10.     }
  11. }
  12. abstract class Template{
  14.     //计算某段代码执行所需花费的时间
  15.     public void sendTime(){
  17.         long start = System.currentTimeMillis();
  19.         code();    //不确定部分，易变的部分
  21.         long end = System.currentTimeMillis();
  23.         System.out.println("花费的时间为:" + (end - start));
  24.     }
  26.     public abstract void code();
  27. }
  29. class SubTemlate extends Template{
  31.     @Override
  32.     public void code() {
  34.         for(int i = 2;i <= 1000;i++){
  35.             boolean isFlag = true;
  36.             for(int j = 2;j <= Math.sqrt(i);j++){
  37.                 if(i % j == 0){
  38.                     isFlag = false;
  39.                     break;
  40.                 }
  41.             }
  42.             if(isFlag){
  43.                 System.out.println(i);
  44.             }
  45.         }
  46.     }
  47. }

七、接口

1.接口的理解

image.png
image.png
image.png

2.接口的定义、使用、多实现、继承

  1. package com.test.java;
  2. /*
  3. * 接口的使用
  4. * 1.接口使用interface来定义
  5. * 2.Java中，接口是和类并列的结构
  6. * 3.JDK7以前：只能定义全局常量和抽象方法
  7. * >全局常量：public static final
  8. * >抽象方法：public abstract
  9. * 4.JDK8增加了静态方法和默认方法
  10. * 5.接口通过让类去实现(implements)的方式来使用
  11. * 6.Java可以实现多个接口
  12. *   格式：class AA extend BB implements CC,DD,EE
  13. */
  14. public class InterfaceTest {
  15.     public static void main(String[] args) {
  16.         System.out.println(Flyable.MAX_SPEED);
  17.         Plane p =  new Plane();
  18.         p.fly();
  19.         p.stop();
  20.         Bullet b = new Bullet();
  21.         b.fly();
  22.         b.stop();
  23.         b.attack();
  24.     }
  25. }    
  26. interface Flyable{
  27.     //全局常量
  28.     public static final int MAX_SPEED = 7900;//第一宇宙速度
  29.     //可以省略public static final
  30.     int MIN_SPEED = 1;
  31.     //抽象方法
  32.     public abstract void fly();
  33.     //省略了public abstract
  34.     void stop();
  35. }
  36. interface Attack{
  37.     void attack();
  38. }
  39. class Plane implements Flyable{
  40.     @Override
  41.     public void fly() {
  42.         System.out.println("引擎起飞");
  43.     }
  45.     @Override
  46.     public void stop() {
  47.         System.out.println("起落架降落");
  48.     }
  49. }
  50. //多个接口
  51. class Bullet implements Flyable,Attack{
  52.     @Override
  53.     public void fly() {
  54.         System.out.println("化学起飞");
  55.     }
  57.     @Override
  58.     public void stop() {
  59.         System.out.println("受阻停止");
  60.     }
  62.     @Override
  63.     public void attack() {
  64.         System.out.println("具有很强的攻击性");
  65.     }
  66. }
  67. //接口多继承
  68. interface AA{
  70. }
  71. interface BB{
  73. }
  74. interface CC extends AA,BB{
  76. }

3.接口是一种规范

  1. package com.test.java;
  3. public class USBTest {
  4.     public static void main(String[] args) {
  5.         PC p = new PC();
  6.         Flash f = new Flash();
  7.         p.transferdata(f);
  8.     }
  9. }
  10. class PC{
  11.     public void transferdata(USB usb){
  12.         usb.start();
  13.         System.out.println("传输的数据");
  14.         usb.stop();
  15.     }
  16. }
  17. interface USB {
  18.     void start();
  19.     void stop();
  20. }
  21. class Flash implements USB{
  22.     @Override
  23.     public void start() {
  24.         System.out.println("U盘开始工作");
  25.     }
  27.     @Override
  28.     public void stop() {
  29.         System.out.println("U盘结束工作");
  30.     }
  31. }
  32. class Printer implements USB{
  33.     @Override
  34.     public void start() {
  35.         System.out.println("打印机开始工作");
  36.     }
  38.     @Override
  39.     public void stop() {
  40.         System.out.println("打印机结束工作");
  41.     }
  42. }

八、内部类

匿名内部类

  1. package com.test.java;
  3. /*
  4.  * 1.匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。
  5.  * 一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
  6.  *
  7.  * 2.格式：
  8.  *         new 父类构造器（实参列表）|实现接口(){
  9.  *                 //匿名内部类的类体部分
  10.  *         }
  11.  *
  12.  * 3.匿名内部类的特点
  13.  *         > 匿名内部类必须继承父类或实现接口
  14.  *         > 匿名内部类只能有一个对象
  15.  *         > 匿名内部类对象只能使用多态形式引用
  16.  */
  17. interface Product{
  18.     public double getPrice();
  19.     public String getName();
  20. }
  21. public class AnonymousTest{
  22.     public void test(Product p){
  23.         System.out.println("购买了一个" + p.getName() + "，花掉了" + p.getPrice());
  24.     }
  25.     public static void main(String[] args) {
  26.         AnonymousTest ta = new AnonymousTest();
  27.         //调用test方法时，需要传入一个Product参数，
  28.         //此处传入其匿名实现类的实例
  29.         ta.test(new Product(){
  30.             public double getPrice(){
  31.                 return 567.8;
  32.             }
  33.             public String getName(){
  34.                 return "AGP显卡";
  35.             }
  36.         });
  37.     }
  38. }