java学习之旅（day.11）

static详解

static若在类中使用，就是修饰成员变量

static若在方法中使用，就是成员方法？

static加在方法上叫静态方法，加在属性上叫做静态属性

package com.zhang.oop.demo11;

public class Student {

    private static int age;//静态变量
    //这里加了static的叫静态变量，未加static的叫非静态变量
    private double score;//非静态变量
    public void run(){
        go();//run方法可以访问go的方法
    }
public static void go(){

}
    public static void main(String[] args) {
        //要用Student必须取new
        Student student=new Student();
        //通过对象的方法输出
        System.out.println(student.score);
        System.out.println(student.age);
        //通过类的方法输出
        System.out.println(Student.age);
        //System.out.println(Student.score);这种方法不能这样用，假设是静态变量，建议使用类名.变量
       // run();无法直接调用，要用以下代码：
        new Student().run();//对象.方法
        Student.go();//这个可以直接调，去掉Student也可以
         //非静态方法可以直接访问这个类中的静态方法，如run方法可以访问go的
        //静态方法可以调用静态方法的，但不能调用非静态的方法，即go方法不能调用run方法
    go();
    //run();报错
    }
}


====================================================
    package com.zhang.oop.demo11;

public class Person {
    /*{
        //代码块（匿名代码块）    创建person这个对象的时候就自动创建了，在构造器之前
    }
     static {
        //静态代码块    类一加载就直接执行，永远只执行一次
     }
*/
    //测试下上面文本中的执行顺序
    {//第二个被执行
        System.out.println("匿名代码块");
    }
    static{//第一个被执行
        System.out.println("静态代码块");
    }

    public Person() {//第三个被执行
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1=new Person();
        System.out.println("=============");
        Person person2=new Person();
    }
    /*
    程序输出结果：
     静态代码块
     匿名代码块
     构造方法
     =============
     匿名代码块 //因为static代码块只执行一次，所以此处少了静态代码块
     构造方法
     */
}
====================================================
  package com.zhang.oop.demo11;
//静态导入包
import static java.lang.Math.random;//此处若不加static，会报错
public class Test {
    public static void main(String[] args) {
        System.out.println(Math.random());//输出随机数
        System.out.println(random());
        //但是现在想写成System.out.println(random())；要导入包
    }
}
  

抽象类

简单来说，用abstract修饰类，就是抽象类

abstract修饰符可以修饰方法也可以修饰类，如果修饰方法，该方法就是抽象方法，如果修饰类，该方法就是抽象类

抽象类中可以没有抽象方法，但有抽象方法的类一定要声明为抽象类

抽象类不能使用new关键字创建对象，它是用来让子类继承的

抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的

子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类

package com.zhang.oop.demo12;
//在类上使用abstract就变成了抽象类
public abstract class Action {

    //方法中什么也不写，是个约束，有人会帮我们实现
    //abstract用在方法上就是抽象方法，只有方法名字，没有方法的实现
    public abstract void doSomething();
    //dosomething中的{}被删掉了

}
===================================================
    package com.zhang.oop.demo12;
//抽象类的所有方法必须要由子类实现（抽象类地所以方法，继承了它的子类都必须要实现它的方法），除非子类也是abstract类的，那就没必要了
public class A extends Action {//就写这个会报错：必须重写父类的方法
//extends是单继承，无法继承多个类       接口可以实现多继承
    @Override
    public void doSomething() {
//抽象类的特点
        //1.不能new这个抽象类，只能靠子类去实现它，它是一个约束，就像法律一样，我们要去遵守它
        //2.抽象类中可以写普通方法
        //3.抽象方法必须在抽象类中
        //抽象类就是抽象的抽象：即约束

       // 抽象类无法new，那么存在构造器吗？
       // 抽象类存在的意义
    }
}

接口

普通类：只有具体的实现

抽象类：具体的实现和规范（抽象方法）都有，不能new

接口：只有规范，自己无法写方法，只能干约束，实现约束和实现分离。面向接口编程

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

接口的本质是契约，就像法律，制定好后大家都要遵守

声明类的关键字是class，

声明接口的关键字是interface

接口的作用：

1. java的接口其实就是一种约束
2. 定义一些方法，让不同的人实现
3. 接口中默认的方法都是public abstrsct ，默认的常量都是public static final的
4. 接口不能直接被实例化（new），因为接口中没有构造方法
5. 可以通过implements实现多个接口
6. 实现接口必须要重写接口中的方法

package com.zhang.oop.demo13;
//接口定义的关键字是interface，接口都需要有实现类
public interface UserSeverse {
    //public void run(){}接口中无法写方法，去类中写
    //接口中只能写一些简单的方法，如void run()
    //接口中所有定义的方法其实都是抽象的，看不到，是public abstract的
    public abstract void run(String name); //你加上它也会显示灰色的，通常不写
//定义一些方法,其实这里只有定义，没有具体的实现，，还需要一个实现类（写个呗：UserServiceImp）

    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);

    //定义一些常量或变量
    //定义的所有属性默认的是一个常量
    public static final int age=99;  //一定义就是一个静态的常量，public static final是灰色的，默认可不写

}
=================================================
    package com.zhang.oop.demo13;
//implements 实现
//抽象类  通过extends 单继承  但接口可多继承
//类可以通过implements关键字实现接口
//实现了接口的类，就必须重写接口中的方法，不然会报错
//public class UserServiceImp implements UserSeverse{//需要将方法重写，不重写就会报错
public class UserServiceImp implements UserSeverse,TimeService{//这里实现了UserSeverse和TimeService两个接口
//这就实现了多继承（伪多继承），利用接口实现多继承，类中有方法的实现，接口中只有方法的定义

    @Override
    public void run(String name) {

    }

    @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.zhang.oop.demo13;

public interface TimeService {
    //这里写个方法
     void timer();
}

内部类

内部类就是在一个类的内部定义一个类。如：A类中定义一个B类，则类B相对于类A说就是内部类，类A相对于类B说就是外部类

有：成员内部类

​ 静态内部类

​ 局部内部类：定义在方法中的类，此内部类不能加任何修饰符

​ 匿名内部类

package com.zhang.oop.demo14;

public class Outer {
    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    //Outer类里再定义一个inner类
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性,私有方法等
        public void getID(){
            System.out.println(id);

        }
    }
    //内部类可以直接访问外部类的一些东西，内部类可访问外部类的私有变量
}

/*
package com.zhang.oop.demo14;

public class Application {
    public static void main(String[] args) {
       Outer outer=new Outer();//new外部类
        //内部类要通过外部类来实例化
       Outer.Inner inner= outer.new Inner();//new 内部类
        inner.in();
        inner.getID();
    }


}

 */

package com.zhang.oop.demo14;

public class out {
    //局部内部类
    public void method(){
        //类还可以写到方法里
        class Inner{
        }
    }

}
//类还可以写到这个位置，但是类A不能用public，即一个Java文件中只能有一个public class，但是可以有多个class类
class A{//一般当测试类这样写
    public static void main(String[] args) {

    }

}
=============================================
    package com.zhang.oop.demo14;

public class te {
    public static void main(String[] args) {
       // Apple apple=new Apple();正常时这样实例化的
        //但匿名（不要名字）初始化类如下，不用将实例保存到对象中
        new Apple().eat();  //匿名内部类

    }

}
class Apple{
    public void eat(){
        System.out.println("1");
    }
}