JavaSE学习笔记（四）

最新推荐文章于 2024-08-02 10:57:17 发布

愧序深巷

最新推荐文章于 2024-08-02 10:57:17 发布

阅读量210

点赞数 2

文章标签： java 接口

本文链接：https://blog.csdn.net/weixin_45511599/article/details/108670867

版权

静态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 返回值类型方法名称（参数列表）{方法体}

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

愧序深巷

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE学习笔记（四）

静态static关键字描述例子：学生类 { 姓名年龄学号所在教室}根据同一学生类可以创造多个学生对象，但是所在教室相同，所以教室的值初始化在学生类中根据学生类创造出的对象，享受同一数据（教室）=====================静态static关键字修饰成员变量public class StatiC { public static void main(String[] args) { Student one = new Student("郭靖",19)
复制链接

扫一扫