面向对象2

 

static关键字详解

final关键词修饰的类，不能被继承

 package com.oop.demo07;
 ​
 //static
 public class Student {
 ​
     private static int age; //静态的变量 多线程！
     private double score;   //非静态的变量
 ​
     public void run(){
 ​
     }
 ​
     public static void go(){
 ​
     }
 ​
     public static void main(String[] args) {
         Student s1 = new Student();
 ​
         System.out.println(Student.age);
         System.out.println(s1.age);
         System.out.println(s1.score);
 ​
         s1.run();
         Student.go();
     }
 }
 ​

 package com.oop.demo07;
 ​
 public final class Person {
 ​
     //2:赋初始值
     {
         //代码块(匿名代码快)
         System.out.println("匿名代码块");
     }
 ​
     //1:只执行一次
     static {
         //静态代码块
         System.out.println("静态代码块");
     }
 ​
     //3
     public Person() {
         System.out.println("构造方法");
     }
 ​
     public static void main(String[] args) {
         Person person = new Person();
         System.out.println("==========================");
         Person person1 = new Person();
 ​
     }
 }
 ​

 package com.oop.demo07;
 ​
 //静态导入包~
 import static java.lang.Math.random;
 import static java.lang.Math.PI;
 ​
 public class Test {
 ​
     public static void main(String[] args) {
         System.out.println(Math.random());
     }
 }
 ​

 

抽象类

用abstract修饰

 package com.oop.demo08;
 ​
 //abstract 抽象类：类 extends: 单继承 （接口可以多继承）
 public abstract class Action {
 ​
     //约束~有人帮我们实现~
     //abstract,抽象方法，只有方法名字，没有方法的实现！
     public abstract void doSomething();
 ​
     //1. 不能new 这个抽象类，只能靠子类去实现它，它只是一个约束。
     //2. 抽象类中可以写普通的方法。
     //3. 抽象方法必须在抽象类中。
     //抽象的抽象：约束！
 ​
     //思考题？ 不能new，它存在构造器吗？ 存在构造器
             // 存在的意义 抽象出来~
 }
 ​

 package com.oop.demo08;
 ​
 //抽象类的所有方法，继承了它的子类，都必须要实现它的方法，除非子类也是abstract类
 public class A extends Action{
     @Override
     public void doSomething() {
 ​
     }
 }
 ​

 package com.oop;
 ​
 import com.oop.demo08.A;
 import com.oop.demo08.Action;
 ​
 ​
 //一个项目应该只存一个main方法
 public class Application {
 ​
     public static void main(String[] args) {
         A a = new A();
         a.doSomething();
 ​
     }
 ​
 }
 ​

 

接口的定义和实现

普通类：只有具体实现

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

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

接口的本质是契约

 package com.oop.demo09;
 ​
 //抽象的思维~ Java 架构师~
 ​
 //interface 定义的关键字，接口都需要有实现类
 public interface UserService {
 ​
     //常量~public static final
     int AGE = 99;
 ​
     //接口中的所有定义的方法其实都是抽象的 public abstract
     void add(String name);
     void delete(String name);
     void update(String name);
     void query(String name);
 ​
 }
 ​

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

 package com.oop.demo09;
 ​
 // 抽象类：extends 但是只能单继承
 // 类 可以实现接口 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() {
 ​
     }
 }
 ​

 作用：
     1. 约束
     2. 定义一些方法，让不同的人实现~ 10--》1
     3. public abstract
     4. public static final
     5. 接口不能被实例化~，接口中没有构造方法~
     6. implements可以实现多个接口
     7. 必须要重写接口中的方法~

 

N种内部类

 package com.oop.demo10;
 ​
 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);
         }
     }
 ​
     //静态内部类
     public static class InnerStatic{
         public void in(){
             System.out.println("这是内部类的方法");
         }
 ​
         //不能获得外部类的私有属性
         /*
         public void getID(){
             System.out.println(id);
         }
 ​
          */
     }
 ​
     //局部内部类
     public void method(){
         class Inner{
 ​
         }
     }
 }
 ​
 //一个java类中可以有多个class类，但是只能有一个public class
 class A{
 ​
 }
 ​

 package com.oop;
 ​
 ​
 import com.oop.demo10.Outer;
 ​
 //一个项目应该只存一个main方法
 public class Application {
 ​
     public static void main(String[] args) {
         //new
         Outer outer = new Outer();
 ​
         //通过这个外部类来实例化内部类！
         Outer.Inner inner = outer.new Inner();
         inner.in();
         inner.getID();
 ​
     }
 ​
 }
 ​

 package com.oop.demo10;
 ​
 //匿名内部类
 public class Test {
     public static void main(String[] args) {
         //没有名字初始化类，不用将实例保存到变量中！
         new Apple().eat();
 ​
         UserService userService = new UserService() {
             @Override
             public void hello() {
 ​
             }
         };
     }
 }
 ​
 class Apple{
     public void eat(){
         System.out.println("1");
     }
 }
 ​
 interface UserService {
     void hello();
 }
 ​