java学习-day06-对象（3）

八、static关键字详解

1.静态属性

package classstudy.demo07;
​
public class Student extends Person{
​
    private static int age;//静态变量 多线程
    private double score;//非静态变量
    public static void main(){
        Student s1=new Student();
        System.out.println(Student.age);//静态属性可以直接使用
        //System.out.println(Student.score);非静态不可以使用
        System.out.println(s1.age);
        System.out.println(s1.score);
​
    }  
}

2.静态方法

package classstudy.demo07;
​
public class Student extends Person{
    private static int age;//静态变量 多线程
    private double score;//非静态变量
    public void run(){
        go();//非静态方法可以直接访问类里的静态方法
    }
    public static void go(){
​
    }
    public static void main(){
        new Student().run();
        Student.go();
        go();//静态方法可以直接调用
        //run();会报错，非静态方法不可以直接调用
    }
}

3.静态代码块、匿名代码块、构造方法比较

如果有静态代码块，只在第一次执行，后面就不会了

package classstudy.demo07;
​
public 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();
​
    }
}

 

4.静态导入包

package classstudy.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(random());//正常情况下应该写Math.random();
        System.out.println(PI);
        
    }
}

5.final用法

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

九、抽象类

abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。

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

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

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

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

package classstudy.demo08;
//abstract 抽象类
public abstract class Action {
    //约束~ 有人帮我们实现~
    //abstract，抽象方法 只有方法的名字，没有方法的实现
    public abstract void doSomeing();
    //1.不能new 这个抽象类，只能靠子去实现他；约束！
    //2.抽象类里可以写普通方法，但抽象方法必须在抽象类中
    //3.抽象的抽象：约束~
​
    //思考题？ 抽象类不能new 对象 那存在构造器吗？
    //存在的意义是什么？ 抽象出来~节省代码的开发，提高开法效率，后期方便维护
}

package classstudy.demo08;
//抽象类的所有方法，继承了他的所有子类，都必须实现他的方法~ 除非 子类也是抽象类，那样就需要子类的子类去实现
//类 单继承 接口 多继承
public class A extends Action
{
​
}

十、接口的定义与实现

普通类：只要具体实现

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

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

接口就是规范，定义的是一组规则，体现了现实生活中”如果你是...则必须能...“的思想。

接口的本质是契约，制定好之后大家都要遵守。

OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象对象能力的语言（比如c++、java、c#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。

声明类的关键字是class，声明接口的关键字是interface

package classstudy.demo09;
​
//抽象思维
//interface定义关键字，接口都需要有实现类
public interface UserService {
    //常量~ public static final
    int AGE=90;
    //接口中的所有定义都是抽象的public abstract
    //public abstract void run();//可以不写 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
    //只有定义 没有具体的实现
​
}

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

package classstudy.demo09;
​
//抽象类：extends~
//一个类可以实现接口，通过implements 接口 实现
//实现了接口的类，就需要重写接口中的方法
//利用接口实现了 多继承
public class UserServiceImp1 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 classstudy.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);
        }
    }
}

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

 

一个java类文件中 可以用多个class文件，但只能有一个public class文件

进步内部类

package classstudy.demo10;
​
public  class Outer
{
    //局部内部类
    public void method(){
        class Inner{
            public void in(){
                
            }; 
        }
    }
}