JavaSE Day09

面向对象（3）

 

1. static关键字

小技巧： 输出语句： 变量 . sout

new Student.run（）；加载方法

main也是一个static的

 package com.oop.demo06;
 ​
 public class Student {
 ​
     private static int age = 24;//静态变量    多线程！！
     private double score = 90;//非静态变量
 ​
     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(Student.score);//不行
         System.out.println(s1.score);//对象调用方法
         System.out.println(s1.age);//对象调用方法
 ​
         new Student().run();//调用run需要new
         go();//直接调用
 ​
     }
 }

 

代码块：

 package com.oop.demo06;
 ​
 public class Person {
     {
         //代码块（匿名代码块）
         System.out.println("匿名代码块");//2   赋初始值
     }
 ​
     static {
         //静态代码块（可以加载一些初始化）
         System.out.println("静态代码块");//1  只执行一次
     }
 ​
     public Person() {
         System.out.println("构造方法");//3
     }
 ​
     public static void main(String[] args) {
         Person person1 = new Person();
         System.out.println("=======");
         Person person2 = new Person();
     }
 }

静态代码块

匿名代码块

构造方法

========

匿名代码块

构造方法

 

静态导入包：

Math.random()//输出随机数

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

final 修饰的不能被继承！！

 

2. 抽象类

abstract 修饰符可以用来修饰方法也可以修饰类

public abstract void doSomething();

 package com.oop.demo07;
 ​
 //abstract 抽象类：  extends：单继承   接口可以多继承！！！！
 public abstract class Action {
 ​
     //约束 ，有人帮我们实现
     //abstract  ,抽象方法，只有方法的名字，没有方法的实现
     public abstract void doSomething();
 }
 package com.oop.demo07;
 ​
 //抽象类的所有方法，继承了它的子类，都必须要实现它的方法，除非abstract 套娃
 public class A extends Action {
     @Override
     public void doSomething() {
 ​
     }
 }

父债子还，子不还孙还。

特点：

1. 不能new这个抽象类，只能靠子类去实现它：约束！

2. 抽象类中可以写普通的方法

3. 抽象方法必须在抽象类中

抽象的抽象：约束~

存在的意义：例如游戏中新建一些角色，抽象出来，提高开发效率，扩展性提高

 

3. 接口*

普通类：只有具体实现

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

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

 

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是。。。，则必须能。。。”的思想。如果你是汽车，必须能跑。

接口的本质是契约，就像生活中的法律一样，制定好大家都遵守。

面向对象的精髓就是接口，声明接口的关键字是 interface

 package com.oop.demo08;
 ​
 //interface 定义的的关键字,接口都需要有实现类
 public interface UserService {
     //接口中的所有定义都是抽象的public
     void add(String name);
     void delete(String name);
     void update(String name);
     void query(String name);
 }

 

接口都需要有实现类，后缀都有Impl，通过implements关键字，并且需要重写方法！！！！！

 package com.oop.demo08;
 ​
 //类可以实现接口 通过implements  必须要重写方法
 public class UserServiceImpl implements UserService {
     @Override
     public void add(String name) {
 ​
     }
 ​
     @Override
     public void delete(String name) {
 ​
     }
 ​
     @Override
     public void update(String name) {
 ​
     }
 ​
     @Override
     public void query(String name) {
 ​
     }
 }

 

实现多继承------->>>

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

//类可以实现接口 通过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() {
        
    }
}

接口中的所有定义的:

方法其实都是抽象的 public abstract

常量都是 public static final

 

接口的作用：

1. 约束

2. 定义一些方法，让不同的人实现

3. public astract

4. public static final

5. 接口不能被实例化，接口中没有构造方法

6. implements 可以实现多个接口

7. 必须要重写接口中的方法！

 

4. 内部类

内部类就是在一个类的内部在定义一个类

 package com.oop.demo09;
 ​
 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);
         }
     }
 }

package com.oop;
 ​
 import com.oop.demo09.Outer;
 ​
 public class Application {
     public static void main(String[] args) {
 ​
         Outer outer = new Outer();
         //通过外部类来实例化内部类
         Outer.Inner inner = outer.new Inner();
 ​
         inner.in();
         inner.getID();//内鬼   <----------
     }
 }

通过public static class禁止内部类访问

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

 

局部内部类：

package com.oop.demo09;
 ​
 public class Outer {
 ​
     //局部内部类
     public void method(){  //在方法里
 ​
         class Inner{
         }
     }
 }

 

扩展一下，写安卓好像经常见到：。。。

 package com.oop.demo09;
 ​
 public class Test {
     public static void main(String[] args) {
 ​
         //没有名字初始化类,不用讲实例保存在变量中，节省内存！！！！
         new Apple().eat();
 ​
         //还可以new接口
         UserService userService = new UserService() {
             @Override
             public void hello() {
 ​
             }
         };
     }
 }
 ​
 class Apple {
     public void eat() {
         System.out.println("1");
     }
 }
 ​
 interface UserService {
     void hello();
 ​
 }