【Java】接口、内部类、面向对象简单项目的实现

接口

【1】接口声明格式：

[访问修饰符]  interface 接口名   [extends  父接口1，父接口2…]  {          常量定义；                 方法定义； }

【2】代码：

1. package com.star.test04;
3. /**
4.  * 1.类是类，接口是接口，它们是同一层次的概念。
5.  * 2.接口中没有构造器
6.  * 3.接口如何声明：interface
7.  * 4.在JDK1.8之前，接口中只有两部分内容：
8.  * （1）常量：固定修饰符：public static final
9.  * （2）抽象方法：固定修饰符：public abstract
10. * 注意：修饰符可以省略不写，IDE会帮你自动补全，但是初学者建议写上，防止遗忘。
11. */
12. public interface TestInterface01 {
13.     //常量：
14.     /*public static final*/ int NUM = 10;
15.     //抽象方法：
16.     /*public abstract*/ void a();
17.     /*public abstract*/ void b(int num);
18.     /*public abstract*/ int c(String name);
19. }
21. interface TestInterface02{
22.     void e();
23.     void f();
24. }
25. /*
26. 5.类和接口的关系是什么？ 实现关系  类实现接口：
27. 6.一旦实现一个接口，那么实现类要重写接口中的全部的抽象方法：
28. 7.如果没有全部重写抽象方法，那么这个类可以变成一个抽象类。
29. 8.java只有单继承，java还有多实现
30. 一个类继承其他类，只能直接继承一个父类
31. 但是实现类实现接口的话，可以实现多个接口
32. 9.写法：先继承 再实现：extends Person implements TestInterface01,TestInterface02
33. */
34. class Student extends Person implements TestInterface01,TestInterface02 {
35.     @Override
36.     public void a() {
37.         System.out.println("---1");
38.     }
40.     @Override
41.     public void b(int num) {
42.         System.out.println("---2");
43.     }
45.     @Override
46.     public int c(String name) {
47.         return 100;
48.     }
50.     @Override
51.     public void e() {
52.         System.out.println("---3");
53.     }
55.     @Override
56.     public void f() {
57.         System.out.println("---4");
58.     }
59. }
62. class Test{
63.     //这是一个main方法，是程序的入口：
64.     public static void main(String[] args) {
65.         //10.接口不能创建对象：
66.         //TestInterface02 t = new TestInterface02();
67.         TestInterface02 t = new Student();//接口指向实现类 ---》多态
69.         //11.接口中常量如何访问：
70.         System.out.println(TestInterface01.NUM);
71.         System.out.println(Student.NUM);
72.         Student s = new Student();
73.         System.out.println(s.NUM);
74.         TestInterface01 t2 = new Student();
75.         System.out.println(t2.NUM);
76.     }
77. }

【3】接口的作用是什么？

定义规则，只是跟抽象类不同地方在哪？它是接口不是类。

接口定义好规则之后，实现类负责实现即可。

【4】

继承：子类对父类的继承

实现：实现类对接口的实现

手机  是不是  照相机  

继承：手机   extends 照相机     “is-a”的关系，手机是一个照相机 

上面的写法 不好：

实现：  手机    implements   拍照功能   “has-a”的关系，手机具备照相的能力

案例：飞机，小鸟，风筝

  定义一个接口： Flyable

【5】多态的应用场合：

（1）父类当做方法的形参，传入具体的子类的对象

（2）父类当做方法的返回值，返回的是具体的子类的对象

（3）接口当做方法的形参，传入具体的实现类的对象

（4）接口当做方法的返回值，返回的是具体的实现类的对象

【6】接口和抽象类的区别：

     JDK1.8以后的接口新增内容

在JDK1.8之前，接口中只有两部分内容：
（1）常量：固定修饰符：public static final
（2）抽象方法：固定修饰符：public abstract 

在JDK1.8之后，新增非抽象方法：

（1）被public default修饰的非抽象方法：

注意1：default修饰符必须要加上，否则出错

注意2：实现类中要是想重写接口中的非抽象方法，那么default修饰符必须不能加，否则出错。

1. public interface TestInterface {
2.     //常量：
3.     public static final int NUM= 10;
4.     //抽象方法：
5.     public abstract void a();
6.     //public default修饰的非抽象方法：
7.     public default void b(){
8.         System.out.println("-------TestInterface---b()-----");
9.     }
10. }
11. class Test implements TestInterface{
12.     public void c(){
13.         //用一下接口中的b方法：
14.         b();//可以
15.         //super.b();不可以
16.         TestInterface.super.b();//可以
17.     }
18.     @Override
19.     public void a() {
20.         System.out.println("重写了a方法");
21.     }
23.     @Override
24.     public void b() {
26.     }
27. }

（2）静态方法：

注意1：static不可以省略不写

注意2：静态方法不能重写

1. public interface TestInterface2 {
2.     //常量：
3.     public static final int NUM = 10;
4.     //抽象方法：
5.     public abstract  void a();
6.     //public default非抽象方法；
7.     public default void b(){
8.         System.out.println("-----TestInterface2---b");
9.     }
10.     //静态方法：
11.     public static void c(){
12.         System.out.println("TestInterface2中的静态方法");
13.     }
14. }
16. class Demo implements TestInterface2{
17.     @Override
18.     public void a() {
19.         System.out.println("重写了a方法");
20.     }
21.     public static void c(){
22.         System.out.println("Demo中的静态方法");
23.     }
24. }
26. class A {
27.     //这是一个main方法，是程序的入口：
28.     public static void main(String[] args) {
29.         Demo d = new Demo();
30.         d.c();
31.         Demo.c();
32.         TestInterface2.c();
33.     }
34. }

疑问：为什么要在接口中加入非抽象方法？？？

如果接口中只能定义抽象方法的话，那么我要是修改接口中的内容，那么对实现类的影响太大了，所有实现类都会受到影响。

现在在接口中加入非抽象方法，对实现类没有影响，想调用就去调用即可。

内部类

成员内部类

1. package com.star.test07;
3. /**
4.  * 1.类的组成：属性，方法，构造器，代码块（普通块，静态块，构造块，同步块），内部类
5.  * 2.一个类TestOuter的内部的类SubTest叫内部类， 内部类 ：SubTest  外部类：TestOuter
6.  * 3.内部类：成员内部类 (静态的，非静态的) 和  局部内部类（位置：方法内，块内，构造器内）
7.  * 4.成员内部类:
8.  *      里面属性，方法，构造器等
9.  *      修饰符：private，default，protect，public，final,abstract
10. */
11. public class TestOuter {
12.     //非静态的成员内部类：
13.     public class D{
14.         int age = 20;
15.         String name;
16.         public void method(){
17.             //5.内部类可以访问外部类的内容
18.             /*System.out.println(age);
19.             a();*/
20.             int age = 30;
22.             //8.内部类和外部类属性重名的时候，如何进行调用：
23.             System.out.println(age);//30
24.             System.out.println(this.age);//20
25.             System.out.println(TestOuter.this.age);//10
26.         }
27.     }
29.     //静态成员内部类：
30.     static class E{
31.         public void method(){
32.             //6.静态内部类中只能访问外部类中被static修饰的内容
33.             /*System.out.println(age);
34.             a();*/
35.         }
36.     }
37.     //属性：
38.     int age = 10;
39.     //方法：
40.     public void a(){
41.         System.out.println("这是a方法");
42.         {
43.             System.out.println("这是一个普通块");
44.             class B{
46.             }
47.         }
48.         class A{
50.         }
51.         //7.外部类想要访问内部类的东西，需要创建内部类的对象然后进行调用
52.         D d = new D();
53.         System.out.println(d.name);
54.         d.method();
56.     }
57.     static{
58.         System.out.println("这是静态块");
59.     }
60.     {
61.         System.out.println("这是构造块");
62.     }
63.     //构造器：
64.     public TestOuter(){
65.         class C{
67.         }
68.     }
70.     public TestOuter(int age) {
71.         this.age = age;
72.     }
73. }
75. class Demo{
76.     //这是一个main方法，是程序的入口：
77.     public static void main(String[] args) {
78.         //创建外部类的对象：
79.         TestOuter to = new TestOuter();
80.         to.a();
82.         //9.创建内部类的对象：
83.         //静态的成员内部类创建对象：
84.         TestOuter.E e = new TestOuter.E();
85.         //非静态的成员内部类创建对象：
86.         //错误：TestOuter.D d = new TestOuter.D();
87.         TestOuter t = new TestOuter();
88.         TestOuter.D d = t.new D();
90.     }
91. }

局部内部类

1. package com.star.test08;
3. /**
4.  * @Auther: Starshine
5.  */
6. public class TestOuter {
7.     //1.在局部内部类中访问到的变量必须是被final修饰的
8.     public void method(){
9.         final int num = 10;
10.         class A{
11.             public void a(){
12.                 //num = 20;
13.                 System.out.println(num);
14.             }
15.         }
16.     }
17.     //2.如果类B在整个项目中只使用一次，那么就没有必要单独创建一个B类，使用内部类就可以了
18.     public Comparable method2(){
19.         class B implements Comparable{
20.             @Override
21.             public int compareTo(Object o) {
22.                 return 100;
23.             }
24.         }
25.         return new B();
26.     }
28.     public Comparable method3(){
29.         //3.匿名内部类
30.         return new Comparable(){
32.             @Override
33.             public int compareTo(Object o) {
34.                 return 200;
35.             }
36.         };
37.     }
39.     public void teat(){
40.         Comparable com = new Comparable(){
42.             @Override
43.             public int compareTo(Object o) {
44.                 return 200;
45.             }
46.         };
48.         System.out.println(com.compareTo("abc"));
49.     }
50. }

面向对象项目

项目需求

项目结构分析

最终代码

匹萨父类：

1. package com.star.test01;
3. /**
4.  * @Auther: Starshine
5.  * 父类：匹萨类
6.  */
7. public class Pizza {
8.     //属性
9.     private String name;//名称
10.     private int size;//大小
11.     private int price;//价格
13.     //方法
15.     public String getName() {
16.         return name;
17.     }
19.     public void setName(String name) {
20.         this.name = name;
21.     }
23.     public int getSize() {
24.         return size;
25.     }
27.     public void setSize(int size) {
28.         this.size = size;
29.     }
31.     public int getPrice() {
32.         return price;
33.     }
35.     public void setPrice(int price) {
36.         this.price = price;
37.     }
39.     //展示匹萨信息：
40.     public String showPizza(){
41.         return "匹萨的名字是："+name+"\n匹萨的大小是："+size+"寸\n匹萨的价格："+price+"元";
42.     }
45.     //构造器
47.     public Pizza() {
48.     }
50.     public Pizza(String name, int size, int price) {
51.         this.name = name;
52.         this.size = size;
53.         this.price = price;
54.     }
55. }

培根匹萨：

1. package com.star.test01;
3. /**
4.  * @Auther: Starshine
5.  */
6. public class BaconPizza extends Pizza {
7.     //属性：
8.     private int weight;
10.     public int getWeight() {
11.         return weight;
12.     }
14.     public void setWeight(int weight) {
15.         this.weight = weight;
16.     }
18.     //构造器：
20.     public BaconPizza() {
21.     }
23.     public BaconPizza(String name, int size, int price, int weight) {
24.         super(name, size, price);
25.         this.weight = weight;
26.     }
28.     //重写父类showPizza方法：
30.     @Override
31.     public String showPizza() {
32.         return super.showPizza()+"\n培根的克数是："+weight+"克";
33.     }
34. }

水果匹萨：

1. package com.star.test01;
3. /**
4.  * @Auther: Starshine
5.  */
6. public class FruitsPizza extends Pizza{
7.     //属性：
8.     private String burdening;
10.     public String getBurdening() {
11.         return burdening;
12.     }
14.     public void setBurdening(String burdening) {
15.         this.burdening = burdening;
16.     }
18.     //构造器：
20.     public FruitsPizza() {
21.     }
23.     public FruitsPizza(String name, int size, int price, String burdening) {
24.         super(name, size, price);
25.         this.burdening = burdening;
26.     }
28.     //重写父类showPizza方法：
30.     @Override
31.     public String showPizza() {
32.         return super.showPizza()+"\n你要加入的水果："+burdening;
33.     }
34. }

测试类：

1. public class Test {
2.     //这是一个main方法，是程序的入口：
3.     public static void main(String[] args) {
4.         //选择购买匹萨：
5.         Scanner sc = new Scanner(System.in);
6.         System.out.println("请选择你想要购买的匹萨（1.培根匹萨 2.水果匹萨）:");
7.         int choice = sc.nextInt();//选择
8.         //通过工厂获取匹萨：
9.         Pizza pizza = PizzaStore.getPizza(choice);
10.         System.out.println(pizza.showPizza());
12.     }
13. }

工厂类：

1. package com.star.test01;
3. import java.util.Scanner;
5. /**
6.  * @Auther: Starshine
7.  */
8. public class PizzaStore {
9.     public static Pizza getPizza(int choice){
10.         Scanner sc = new Scanner(System.in);
11.         Pizza p = null;
12.         switch (choice){
13.             case 1:
14.                 {
15.                     System.out.println("请录入培根的克数：");
16.                     int weight = sc.nextInt();
17.                     System.out.println("请录入匹萨的大小：");
18.                     int size = sc.nextInt();
19.                     System.out.println("请录入匹萨的价格：");
20.                     int price = sc.nextInt();
21.                     //将录入的信息封装为培根匹萨的对象：
22.                     BaconPizza bp = new BaconPizza("培根匹萨",size,price,weight);
23.                     p = bp;
24.                 }
25.                 break;
26.             case 2:
27.                 {
28.                     System.out.println("请录入你想要加入的水果：");
29.                     String burdening = sc.next();
30.                     System.out.println("请录入匹萨的大小：");
31.                     int size = sc.nextInt();
32.                     System.out.println("请录入匹萨的价格：");
33.                     int price = sc.nextInt();
34.                     //将录入的信息封装为水果匹萨的对象：
35.                     FruitsPizza fp = new FruitsPizza("水果匹萨",size,price,burdening);
36.                     p = fp;
37.                 }
38.                 break;
39.         }
40.         return p;
41.     }
42. }