第九天

一、static关键字详解

静态属性

 package com.oop.Demo04;
 ​
 public class Student {
     private static int age;
     private double score;
 ​
     public static void main(String[] args) {
         Student s1 = new Student();
         System.out.println(s1.score);
         System.out.println(s1.age);
         System.out.println(Student.age);
         System.out.println(Student.score);//会报错，
     }
 }

静态方法

 package com.oop.Demo04;
 ​
 public class Student {
     private static int age;
     private double score;
 ​
     public void run(){
         say();//非静态方法可以调用静态方法中的东西
     }
     public static void say(){
         //静态方法可以调用静态方法，但是不能调用普通方法
     }
 ​
     public static void main(String[] args) {
         run();//直接调用会报错
         new Student().run();//必须这样进行调用
         say();//这可以直接调用，或者Student.say();
     }
 ​
 }

 package com.oop.Demo04;
 ​
 public class Person {
     //第二个执行
     //可以用来赋初始值
     {
         System.out.println("匿名代码块");
     }
     //第一个执行，和类一起加载，并且只加载一次
     static {
         System.out.println("静态代码块");
     }
     //最后一个执行
     public Person() {
         System.out.println("构造方法");
     }
 ​
     public static void main(String[] args) {
         Person person = new Person();
     }
 }

通过final修饰的类就不能被继承，没有子类

二、抽象类

如果A直接去继承Action，会报错，他必须重写Action中的抽象方法

接口可以多继承

抽象类不能new，只能靠子类去实现

抽象类可以写普通方法，抽象方法必须在抽象类中

三、接口

普通类：只有具体实现

抽象类：具体实现和规范(抽象方法)都有！

接口：只有规范，自己无法写方法~专业的约束，约束和实现分离：面向接口编程

接口就是规范，定义的是一组规则

接口的本质是契约，就像人间的法律，定义好后都要遵循

声明接口的关键字是interface

接口里面的所有定义的方法其实都是抽象的，默认public abstract，所以写方法就可以直接写

 void 方法名(参数类型);

接口里面定义的属性都是默认的常量，默认为public static final， 一般不在接口中定义属性

接口都需要有实现类，实现类命名一般用Impl结尾

 package com.oop.Demo06;
 ​
 //类可以实现接口 implements接口
 //实现了接口的类必须要重写接口中的所有方法
 //接口可以实现多继承
 public class UserServiceImpl implements UserService,TimeService{
     @Override
     public void add(String name) {
 ​
     }
 ​
     @Override
     public void delete(String name) {
 ​
     }
 ​
     @Override
     public void update(String name) {
 ​
     }
 ​
     @Override
     public void query(String name) {
 ​
     }
 ​
     @Override
     public void timer() {
 ​
     }
 }

 package com.oop.Demo06;
 ​
 public interface UserService {
     void add(String name);
     void delete(String name);
     void update(String name);
     void query(String name);
 }

 package com.oop.Demo06;
 ​
 public interface TimeService {
     void timer();
 }

接口和抽象类一样不能被实例化，接口中没有构造方法

四、内部类

内部类就是在一个类的内部再定义一个类，比如在A类中定义一个B类，那么B类相对A类来说就称为内部类，A类相对于B类来说就是外部类

1、成员内部类

 package com.oop;
 ​
 import com.oop.Demo07.Outer;
 ​
 public class Application {
 ​
     public static void main(String[] args) {
         Outer outer = new Outer();
         Outer.Inner inner = outer.new Inner();
         inner.in();//可以输出“这是内部方法”
         inner.getId();
     }
 }

 package com.oop.Demo07;
 ​
 public class Outer {
     private int id = 10;
     public void out(){
         System.out.println("这是外部方法");
     }
     public class Inner{
         public void in(){
             System.out.println("这是内部方法");
         }
         //获得外部类的私有属性
         public void getId(){
             System.out.println(id);
         }
     }
 }

2、静态内部类

3、局部内部类

 package com.oop.Demo07;
 ​
 public class Outer {
 ​
     //局部内部类
     public void method(){
         class inner{
             
         }
     }
 }

4、匿名内部类

 package com.oop.Demo07;
 ​
 public class Test {
     public static void main(String[] args) {
         //没有名字初始化类，不用将实例保存到变量中
         new Apple().eat();
 ​
         TimeService timeService = new TimeService() {
             @Override
             public void hello() {
 ​
             }
         };
     }
 ​
 }
 class Apple{
     public void eat(){
 ​
     }
 }
 interface TimeService{
     void hello();
 }

一个java类中可以有多个class类，但是只能有一个public class类