static关键字，抽象类，接口和内部类

最新推荐文章于 2022-08-21 18:14:06 发布

aty111111

最新推荐文章于 2022-08-21 18:14:06 发布

阅读量107

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/aty111111/article/details/118962717

版权

Java 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

1.static关键字详解

1.static 修饰变量（或方法）表示静态变量（方法），随类一起加载，可直接被类调用
无static修饰，表示普通变量（方法），创建对象时被一起创建，不能被类调用

package com.oop.demo08;

//static 从属于当前类，随类一起加载

public class Student {

    private static int age;  //静态的变量
    private double score;  //非静态的变量


    public static void main(String[] args) {
        Student s1 = new Student();

        System.out.println(Student.age);
        //System.out.println(Student.score);   //非静态变量只能通过对象去调用
        System.out.println(s1.age);
        System.out.println(s1.score);
        go();
        s1.run();

    }
    public void run(){

    }

    public static void go(){

    }
}

2.静态代码块，匿名代码块，构造器执行顺序
ps：静态代码块创建不同对象时只执行一次，从属于类

package com.oop.demo08;


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 person1 = new Person();
        System.out.println("==================");
        Person person2 = new Person();
    }
}

3.使用static静态导入包

package com.oop.demo08;

//static修饰  静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
import java.lang.Math;


public class Test extends Person{
    public static void main(String[] args) {
        System.out.println(Math.random());
    }
}

4.final修饰类之后，该类无法再被继承（final之后，断子绝孙）、、

2.抽象类 abstratct

1.abstract来修饰提供约束，有人来帮我们实现
2.abstract修饰抽象方法 : 只有方法名字，没有方法的实现
3.抽象类的所有方法，继承了它的子类，都必须要实现它的方法，除非子类也是抽象类，由子子类实现
4.抽象类通过extends来实现，只能单继承，接口可以实现多继承

5.特点

  	* 1.不能new这个抽象类，只能靠子类去实现它：约束
  	* 2.抽象类中可以写普通的方法
  	* 3.抽象方法必须在抽象类中

6.代码

package com.oop.demo08;

//abstract  抽象类
public abstract class A {

    //约束 有人帮我们实现
    //abstract 抽象方法 只有方法名字，没有方法的实现
    public abstract void dosomething();
}

package com.oop.demo08;

//抽象类的所有方法，继承了它的子类，都必须要实现它的方法，除非子类也是抽象类，由子子类实现
//抽象类 通过extends来实现，只能单继承，    接口可以实现多继承
public class B extends A{
    @Override
    public void dosomething() {

    }
    //1.不能new这个抽象类，只能靠子类去实现它：约束
    //2.抽象类中可以写普通的方法
    //3.抽象方法必须在抽象类中
    //抽象的抽象  约束

    //思考题  ？   不能new，抽象类存在构造器吗？
            //存在的意义   抽象出来  提高开发效率


}

3.接口

1.普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范！自己无法写方法只有专业的约束！约束和实现分离：面向接口编程
2.接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想
3.接口的本质是契约，就像我们人间的法律一样，制定好后大家都遵守
4.面向对象的精髓，是对对象的抽象，最能体现这一点的就是接口
5.声明类的关键字是class，声明接口的关键字是interface
6.通过interface去定义，implements去实现

7.ps

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

7.代码

package com.oop.demo08;

//interface  定义的关键字
public interface UserService {
    //接口中的所有定义起始都是抽象的public abstract

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


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

package com.oop.demo08;

//抽象类 extends
//类 可以实现接口  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) {

    }


}

4.内部类

1.内部类就是在一个类的内部再定义一个类。比如，A类中定义一个B类，那么B类相对于A类来说就称为内部类，而A类相对B类来说就是外部类了
2 成员内部类

package com.oop.demo09;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

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.demo09;

public class Applycation {
    public static void main(String[] args) {
        //new
        Outer outer = new Outer();

        //通过外部类来实例化内部类
        Outer.inner inner = outer.new inner();
        inner.getID();

    }
}

3 静态内部类

package com.oop.demo09;

public class Outer2 {
    private int id = 10;

    public void out() {
        System.out.println("这是外部类的方法");
    }

    public static class inner {
        public void in() {
            System.out.println("这是内部类的方法");
        }

    }
}
//内部类用static修饰，无法访问外部类非静态属性

4 局部内部类
- 引入：

package com.oop.demo09;

public class Outer3 {
    
}

//一个JAVA类中可以有多个class类，但只能有一个public class
class A{
    
}

同理：

package com.oop.demo09;

public class Outer4 {
   
   //局部内部类
   public void method(){
       
       class Inner{
           
       }
   }
}

5.匿名内部类

package com.oop.demo09;

public class Outer5 {

    public static void main(String[] args) {

        //没有名字初始化类，将实例保存到变量中
       new Apple().eat();
       new UserService(){
           @Override
           public void hello() {
               
           }
       };

    }
}

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

interface UserService{
    void hello();
}