JavaSE学习笔记(四)

静态static关键字描述

例子:学生类 { 姓名 年龄 学号 所在教室}
根据同一学生类可以创造多个学生对象,但是所在教室相同,所以教室的值初始化在学生类中
在这里插入图片描述

 根据学生类创造出的对象,享受同一数据(教室)

=====================
静态static关键字修饰成员变量

public class StatiC {
    public static void main(String[] args) {
        Student one = new Student("郭靖",19);
        Student two = new Student("黄蓉",17);

        one.room="fz305";            //不推荐 这里room是静态的,所以定义一个就同步到了另一个
		Student.room="fz305";        //推荐 直接用类名称.成员变量
		
        System.out.println("姓名:"+one.getName()+",年龄:"+one.getAges()+",教室:"+one.getRoom()+",学号:"+one.getId());
        System.out.println("姓名:"+two.getName()+",年龄:"+two.getAges()+",教室:"+two.getRoom()+",学号:"+two.getId());
		

    }
}




public class Student {
    private  int id;             学号
    private String name;
    private  int ages;
    private static int cont=0;     cont也是静态的,可以保持上次的数据
    static String room;            static 定义变量;

    public Student(){
        this.id=cont++;             每创造一个对象,id就加一
    }
    public Student(String name,int ages){
        this.name=name;
        this.ages=ages;
        this.id=cont++;
    }

    public static int getCont() {
        return cont;
    }

    public static void setCont(int cont) {
        Student.cont = cont;
    }

    public static String getRoom() {
        return room;
    }

    public static void setRoom(String room) {
        Student.room = room;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAges() {
        return ages;
    }

    public void setAges(int ages) {
        this.ages = ages;
    }
}

==============================================
static用来修饰成员方法

一旦使用static修饰成员方法,就成为静态方法,静态方法不属于对象,直接属于类

如果方法没有static关键字,那么必须首先创建对象,然后通过对象访问方法
如果方法有static关键字,那么能通过类名称直接使用此方法

无论是成员变量还是成员方法,一旦使用static修饰,就推荐使用类名称调用
成员变量: 类名称.静态变量
成员方法:类名称.静态方法();

注意:
1.静态不能直接访问非静态
2.静态方法中不能使用this。
原因:This代表当前对象,通过谁调用的方法,谁就是对象 就是对象.fangfa
static 静态方法不用对象。 是类名称.方法。

public class Dem01 {
    public static void main(String[] args) {
	
        Cla cl=new Cla(12);
        Cla.name="fz305";  //静态变量:   类名称.成员变量

        cl.mod2();
        Cla.mod1();       //类名称.静态方法

        Mod();//     实际上是Dem01.Mod();(类名称.方法名)同一类中的方法,可以不用  .

    }

    public static void Mod(){
        System.out.println("本类方法");
    }




public class Cla {

    int ages;
    static String name;   //静态变量

    public Cla(){
        System.out.println("构造午餐方法");

    }
    public Cla(int ages){
        this.ages=ages;
        System.out.println("构造有参函数");

    }

    public static void mod1(){
        System.out.println("静态方法");
      //  System.out.println(ages);     错误,静态方法不能访问非晶态变量

    }

    public void mod2(){
        System.out.println("成员方法");
    }


}

===============================================
静态static内存
在这里插入图片描述

========================
静态代码块

public class 类名称{
static{
静态代码块内容
}
}
当第一次用到本类时,只执行唯一一次 //one 执行。two不执行
静态内容总是优先于构造方法执行

public class Dem01 {
    public static void main(String[] args) {
        Cla one = new Cla();
        Cla two = new Cla();

    }
}



public class Cla {
    static{
        System.out.println("静态代码块执行");
    }

    public Cla(){
        System.out.println("构造方法执行");
    }

}

====================

数组工具类:Ayyays
提供了大量静态方法

1.public static String toString(数组),将参数数组变成字符串 [元素一,元素二]
2.public static void sort(数组),排序;
备注:数值就升序
字符串,字母升序。

 public class Arr {
    public static void main(String[] args) {
        int[] one ={1,2,3,6,2};

        String str = Arrays.toString(one); //转化为字符串
        System.out.println(str);           //打印字符串

        Arrays.sort(one);                  //数组排序
        System.out.println(Arrays.toString(one));//转化成字符串打印,否则要用for来打印数组

    }
}

=============================================

Math类
提供大量静态方法(数学)
1.public static double obs((double num) ;获取绝对值
2.Public static double ceil (double num) ;向上取整
3.public static double floor(double num);向下取整
4.public static long round(double num); 四舍五入

==============================================
继承
继承是多态的前提

定义父类:
public class 父类名称{
}

定义一个子类
public class 子类名称 extends 父类名称{

}

public class Demo {
    public static void main(String[] args) {
        Zi one = new Zi();
        one.fu();

        Zinew two = new Zinew();
        two.fu();
    }
}

public class Fu {
    public void fu(){
        System.out.println("方法");
    }
}
public class Zi extends Fu {
}

public class Zinew extends Fu {
}

==========================================
继承成员变量特点

public class FU {
    int numfu=10;
    int num=100;

    public void modFu(){
        System.out.println(num);
    }
}


public class Zi extends FU {
    int numZi=20;
    int num=200;
    public void modZi(){
        System.out.println(num);
    }
}


public class Dem {
    public static void main(String[] args) {
        FU fu = new FU();
        Zi zi = new Zi();

        System.out.println(fu.num);             //正常调用
        System.out.println(fu.numfu);           //正常调用
        System.out.println("===============================");

        System.out.println(zi.num);          //zi fu 中都有num,左边是谁就优先调用谁的
        System.out.println(zi.numZi);        //这种正常调用
		
		
        System.out.println(zi.numfu);        //可以直接到fu中的东西
		
		
        System.out.println("===============================");

        zi.modZi();          //这种直接调用
        zi.modFu();         //直接到fu中的方法      

    }
}

=========================================================================================================================================

接口

接口是多个类的公共规范

格式:public interface 接口名称{
接口内容
}

接口中可有
java7 1.常量 2.抽象方法
Java8 3.默认方法 4.静态方法
java9 5.私有方法

接口中可以有抽象方法:
public abstract 返回值类型 方法名(参数);
例:
public interface Myinterface{
public abstract void method(); //抽象方法
}

接口使用:
1.接口不能直接使用,必须有一个实现类实现该接口
格式:public class 实现类名称 implements 接口名称{
}
2.接口的实现类必须覆盖重写接口中的所有抽象方法
3.创建实现类的对象,就行使用
注意:如果没有覆盖重写接口中的所有抽象方法,那这个实现类必须是抽象类

例题:

public interface Myinterface {           //接口定义
    public abstract void method1();
    public void method2();
    abstract void  method3();
}


public class MyImpl implements Myinterface {     //定义实现类
    @Override
    public void method1() {
        System.out.println("第一个");
    }
    @Override
    public void method2() {
        System.out.println("第二个");
    }
    @Override
    public void method3() {
        System.out.println("第三个");
    }
}


public class Demo {
    public static void main(String[] args) {
        MyImpl impl = new MyImpl();         new新的实现类对象
        impl.method1();
        impl.method2();
        impl.method3();
    }
}

===================================================
接口默认方法定义
Java8 开始,允许使用默认方法
结构: Public default 返回值类型 方法名称 (参数列表){ }

目的:解决接口升级问题(可以不用在实现类中重写,实现类对象调用此方法)

public interface Myinterface {
    public abstract void method1();
    public default void method2(){     //定义默认方法
        System.out.println("定义默认方法");
    }

}

public class Impl implements Myinterface{
    @Override
    public void method1() {          //只需要重写抽象方法,不用重写默认方法
        System.out.println("抽象方法");
    }

}


public class Demo {
    public static void main(String[] args) {
        Impl obj = new Impl();
        obj.method1();
        obj.method2();          //实现类对象中没有这个方法,就想上接口中找
    }
}

=============================================
接口静态方法定义
public static void method(){
}

注意:不能通过实现类的对象调用,直接接口名称调用静态方法
`

public interface Myinterface {
    public static void method(){           //定义静态方法
        System.out.println("静态方法调用");
    }

}

public class Dem {
    public static void main(String[] args) {
        Myinterface.method();          //直接用接口名称使用静态方法
    }
}

`=========================================
接口中私有化定义
java9开始,接口中允许定义私有方法
抽取一个共有方法,用来解决两个默认方法之间重复代码的问题,但是这个方法不能让实现类使用
1.普通私有方法,解决多个默认方法之间重复代码问题
public 返回值类型 方法名称 (参数列表){ }

public interface Myinterface {
    public default void method1(){
        System.out.println("测试私有化方法一");
        my();
    }
    public default void method2(){
        System.out.println("测试私有化方法二");
        my();
    }

    private void my(){              //定义私有化
        System.out.println("aaaaa");
    }
}

public class Impl implements Myinterface{

}


public class Demo {
    public static void main(String[] args) {
        Impl my = new Impl();
        my.method1(); //通过实现类
        my.method2();
    }
}

2.静态私有化
`

public interface Myinterface {
    public static  void method(){
        System.out.println("静态方法私有化吧");
        my();
    }

    private static void my(){
        System.out.println("aaaa");
    }
}


public class deom {
    public static void main(String[] args) {
        Myinterface.method();        //静态方法的私有化,不用使用实现类
    }
}

`===========================================================
接口常量定义和使用
接口定义“成员变量”必须使用public static final 三个关键字
从效果上看,就是接口中的常量
public static final 数据类型 常量名称=数据值

备注:一旦使用final关键字,说明不可变
注意:1.接口中的常量,可以省略三个关键字
2.接口中的常量必须赋值

public interface Myinterface {
    int num=12;
    public static final int NUM_OF=19;
}


public class Deom {
    public static void main(String[] args) {
        System.out.println(Myinterface.num);    //常量使用,直接接口调用
        System.out.println(Myinterface.NUM_OF); 
    }
}

===================================================================

总结接口:

java9开始,接口中允许定义私有方法
1.成员变量其实是常量
[public] [static] [final] 数据类型 常量名称 = 数据值
注意:常量必须进行赋值,而且一旦赋值不能改变
常量名称完全大写,用下划线进行分割

2.抽象方法
[public] [abstract] 返回值类型 方法名称 (参数列表)

注意:实现类必须覆盖重写接口中的所有抽象方法

3.java8开始 接口允许定义默认方法
[public] default (返回值类型) 方法名称 (参数列表){
方法体}
默认方法也可以覆盖重写

4.java8开始 接口允许定义静态方法

[public] static 返回值类型 方法名称(参数列表){
方法体
}

注意:应该通过接口名称进行调用,不能通过实现类对象调用接口中的静态方法

5.从java9开始 接口允许定义私有方法
普通私有:private 返回值类型 方法名称(参数列表){方法体}
静态私有:private static 返回值类型 方法名称(参数列表){方法体}

只能接口自己调用,不能被实现类和别人使用

©️2020 CSDN 皮肤主题: 深蓝海洋 设计师:CSDN官方博客 返回首页