Java 类和接口

已于 2023-11-24 11:21:30 修改
阅读量1k 收藏 24
点赞数 18
分类专栏： Java学习 文章标签： java
于 2023-11-23 11:30:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mumuhaoshuai/article/details/134573274
版权

记录一些个人的理解，可能不太对

目录

1.类与对象

类：好比String
对象（实例）：eg:String str1 此时的str1就是String类的对象或者实例；
package:可以理解为文件下的路径，比如com.xyz

1.1源文件声明规则

一个源文件中只能有一个public类。
一个源文件可以有多个非public类。
源文件的名称应该和public类的类名保持一致。
每个源文件中，先写package语句，再写import语句，最后定义类。

1.2类的定义

public: 所有对象均可以访问
private: 只有本类内部可以访问
protected：同一个包或者子类中可以访问
不添加修饰符：在同一个包中可以访问

package com.czl;
import java.util.Scanner;
class Student{  //一个源文件中只能有一个public类。//一个源文件可以有多个非public类。
    public int x;
    private int y;
    //public 在class外也能访问
    //private  在class里面能访问，外面访问不了
}
public class Main {
    public static void main(String[] args) throws Exception{
        Student student = new Student();
        student.x=3;  //不报错
        //student.y=4；  //报错
    }
}

静态（带static修饰符）成员变量/函数与普通成员变量/函数的区别：

  • 所有static成员变量/函数在类中只有一份，被所有类的对象共享；
  • 所有普通成员变量/函数在类的每个对象中都有独立的一份；
  • 静态函数中只能调用静态函数/变量；普通函数中既可以调用普通函数/变量，也可以调用静态函数/变量。
//静态变量与普通变量的区别
package com.czl;
import java.util.Scanner;
class Student{  //一个源文件中只能有一个public类。//一个源文件可以有多个非public类。
    public int y=-1;    //public 在class外也能访问
    public static int x=-1;   //static  所以这个类的对象共享的变量
}

public class Main {
    public static void main(String[] args) throws Exception{
        Student student1 = new Student();
        Student student2 = new Student();
        Student student3 = new Student();
        //s1,s2,s3访问一个共同的x(相当于教室里面的黑板),但他们都有一个自己单独的y(相当于每个人手里拿着自己的草稿纸)
        Student.x=2;  //访问静态变量通过类访问
        System.out.printf("%d %d %d\n",student1.x,student2.x,student3.x);  //结果是2 2 2
        student1.y=2;
        System.out.printf("%d %d %d\n",student1.y,student2.y,student3.y);  //结果是 2 -1 -1
    }
}

关系：
在这里插入图片描述

//Point包
/
package com.czl.point;

//类名最好大写
public class Point {
    private int x;
    private int y;
    //下面相当于封装，xy是私有变量，外面函数要访问xy，要么通过set函数赋值，要么通过get函数取值

    //构造函数，初始化对象时候可以传一些参数
    public Point(int x, int y) {
        this.x = x;  //this 访问当前的成员变量
        this.y = y;
    }

    //表示给x赋值
    public void setX(int x) {
        this.x = x;
    }
    //表示给y赋值
    public void setY(int y) {
        this.y = y;
    }
    //返回x
    public int getX() {
        return x;
    }
    //返回y
    public int getY() {
        return y;
    }

    //把当前的点转换成字符串
    public String toString() {
        return String.format("(%d, %d)", x, y);
    }
}



package com.czl;
import com.czl.point.Point;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) throws Exception{
        //Alt+Enter
        Point point = new Point(3,4);
        System.out.println(point.toString());


    }
}
同理：
普通函数：每个对象自己有的
静态（共有）函数：所有对象共有的

上述文件结构：
在这里插入图片描述

1.3继承和多态

每个类只能继承一个类。为什么会有这个东西：好比LOL每个英雄都有血条，一个个定义多累啊，所以继承一个共有的函数
文件结构：
在这里插入图片描述

//ColorPoint
//Point没变化
package com.czl.point;

public class ColorPoint extends Point{   //继承Point类

    public String color;

    //构造函数
    public ColorPoint(int x,int y,String color){
        super(x,y);  //调用父类的构造函数
        this.color = color;
    }
    public void setColor(String color) {
        this.color = color;
    }

    public String toString() {   //子类toString,优先使用
        //多态  同一个类的实例，调用相同的函数，运行结果不同
        return String.format("(%d, %d, %s)", super.getX(), super.getY(), this.color);
    }
}


//Main
package com.czl;
import com.czl.point.ColorPoint;
import com.czl.point.Point;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) throws Exception{
        //Alt+Enter
        Point point1 = new Point(3,4);
        Point point2 = new ColorPoint(3,4,"red");  //子类可以用父类来存

        // 多态，同一个类的实例，调用相同的函数，运行结果不同
        System.out.println(point1.toString());  //(3, 4)
        System.out.println(point2.toString());  //(3, 4, red)

    }
}

2.接口

interface与class类似。主要用来定义类中所需包含的函数。

接口也可以继承其他接口，一个类可以实现多个接口。

2.1接口的定义

public interface Role {
    public void greet();
    public void move();
    public int getSpeed(); //移动速度
}

2.2接口的继承

每个接口可以继承多个接口

public interface Hero extends Role {
    public void attack();
}

2.3接口的实现

每个类可以实现多个接口

class Zeus implements Hero {
    private final String name = "Zeus";
    public void attack() {
        System.out.println(name + ": Attack!");
    }

    public void greet() {
        System.out.println(name + ": Hi!");
    }

    public void move() {
        System.out.println(name + ": Move!");
    }

    public int getSpeed() {
        return 10;
    }
}

2.4接口的多态

多个类实现一个接口

class Athena implements Hero {
    private final String name = "Athena";
    public void attack() {
        System.out.println(name + ": Attack!!!");
    }

    public void greet() {
        System.out.println(name + ": Hi!!!");
    }

    public void move() {
        System.out.println(name + ": Move!!!");
    }

    public int getSpeed() {
        return 10;
    }
}

public class Main {
    public static void main(String[] args) {
        Hero[] heros = {new Zeus(), new Athena()};
        for (Hero hero: heros) {
            hero.greet();
        }
    }
}

3.关于接口的总结：

在这里插入图片描述

//Mian函数
package com.czl;


import com.czl.role.Hero;
import com.czl.role.imply.Athena;
import com.czl.role.imply.Zeus;
//Alt+Enter导入包
public class Main {
    public static void main(String[] args) throws Exception{
        Hero[] heros = {new Zeus(), new Athena()};
        for (Hero hero: heros) {
            hero.greet();
        }

    }
}


//Athena类
package com.czl.role.imply;

import com.czl.role.Hero;


public class Athena implements Hero{
    //Alt+Insert  之后点击实现方法

    private final String name = "Athena";
    public void attack() {
        System.out.println(name + ": Attack!!!");
    }

    public void greet() {
        System.out.println(name + ": Hi!!!");
    }

    public void move() {
        System.out.println(name + ": Move!!!");
    }

    public int getSpeed() {
        return 20;
    }
}


//Zeus类
package com.czl.role.imply;

import com.czl.role.Hero;


public class Zeus implements Hero {   //实现接口里面的操作,继承多哥接口
    private final String name = "Zeus";
    public void attack() {
        System.out.println(name + ": Attack!");
    }

    public void greet() {
        System.out.println(name + ": Hi!");
    }

    public void move() {
        System.out.println(name + ": Move!");
    }

    public int getSpeed() {
        return 10;
    }


}

//Role接口
package com.czl.role;

public interface Role {
    public void greet();
    public void move();
    public int getSpeed(); //移动速度
}


//Hero接口
package com.czl.role;

//继承
public interface Hero extends Role{      //public interface Hero extends Role 继承Role接口

    public void attack();
}

4.参考

AcWing

林林亓
关注
专栏目录
Java类和接口的关系与区别
qq_53009248的博客
02-22 3679
Java类和接口的关系与区别 一，类和类 类和类是继承关系，子类继承父类，既可以单继承又可以多层继承； 单继承一个子类继承一个父类 多层继承建议不超过三次，否则会冗余 //多层继承实现多继承 class A{//父类A类 private int num=10; public int getNum(){ return this.num; } public void fun(){ System.out.println("你今天真好看！");
Java基础：Java的类与接口
weixin_42188778的博客
05-02 1366
这篇文章主要介绍了类与接口详细教程,本文通过图文并茂的形式给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下。放假在家里休息，闲来无事，想巩固巩固自己的基础知识。Java基础这个我会一直更新的，希望大家关注 收藏 点赞。
Java的类和接口
weixin_30797027的博客
03-13 94
最近组里还没分配任务，就把今后要改造的部分代码看了一下。在读前辈的代码的时候，发现一个特点：接口的多继承很多。于是就到网上找了些继承和接口的用法，重温一下，也总结一下下。参考了很多其他网上其他前辈的东西，希望他们不好见怪。 继承 1.Java中的类不支持多继承，即一个子类至多有一个父类。 2.子类继承了父类中的不是私有的成员变量和成员方法。 3.当子类中的成员变量和成员方法和父类中的一致时，那么...
Java面向对象
Alkali!的博客
10-14 840
每个类只能继承一个类。} }接口中不添加修饰符时，默认为public。}
Java基础之接口与类
ww702109k的博客
03-04 489
Java基础之接口与类
Java类和接口
thebigdipperbdx的博客
05-06 334
一个接口可以继承多个接口【接口可以实现多继承】 interface C extends A, B {} 注意：此时，采用关键字extends A，B均是接口 一个类可以实现多个接口 class D implements A,B,C{} 注意：此时，采用关键字implements A，B，C均是接口 但是一个类只能继承一个类,不能继承多个类 ...
Java中的类、抽象类和接口的区别和联系
04-07
Java中的类、抽象类和接口的区别和联系
Java抽象类与接口实验报告
10-19
Java抽象类与接口实验报告
java抽象类与接口实例java抽象类与接口实例
最新发布
06-22
java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例...
java interface的定义变量_【Java关键字-Interface】为什么Interface中的变量只能是 public static final...
weixin_33067503的博客
02-16 1904
三个关键字在接口中的存在原因：public：接口可以被其他接口继承，也可以被类实现，类与接口、接口与接口可能会形成多层级关系，采用public可以满足变量的访问范围；static：如果变量不是static的，那么接口必须实例化才可以访问自己的变量，接口不能被实例化，故非static的变量是无效的；final：如果变量不是final的，而方法是abstract的，因此接口中的方法又不可以修改变量值，...
Java的类与接口
郑某某的博客
11-15 5592
Java的类与接口
java的接口和类
健健
06-15 8883
类：类是具有相同属性和服务的一组对象的集合。为属于该类的所有对象提供了统一的抽象描述，其内部包括属性和服务两个主要部分。在面向对象的编程语言中，类是一个独立的程序单位，应该有一个类名并包括属性说明和服务说明两个主要部分。接口的功能：(1) 通过接口可以实现不相干类的相同行为而不需考虑这些类之间的层次关系。(2) 通过接口可以实现多继承机制。(3) 通过接口可以了解对象的交互界面而不需了解对象所对应...
深入理解Java的接口和抽象类
ifeves的博客
03-28 232
对于面向对象编程来说，抽象是它的一大特征之一。在Java中，可以通过两种形式来体现OOP的抽象：接口和抽象类。这两者有太多相似的地方，又有太多不同的地方。很多人在初学的时...
Java接口和类
Add小兵的博客
12-10 361
接口 接口不可以被实例化 实现类必须实现接口的所有方法 实现类可以实现多个接口 接口中的变量都是静态变量 类只能继承一个父类,但是可以实现多个接口 定义接口的语法 public interface 接口名{ } 子接口也能继承父接口,接口的继承可以使多继承 public interface 接口 extends 父接口1,父接口2,.....{ } 接口和类比较优点有 可以被多继承 设计和实现完全分离 更自然的使用多态 更容易搭建程序框架 更容易更换实现 ...
Java中的类和接口
weixin_34120274的博客
07-30 82
类有两种： 普通类 : 抽象类（abstract）： 抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。 由于抽象类不能实例化对象，所以抽象类必须被继承（extends），才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。 父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。 在Java...
java类与接口
爱学习的小刘芒的博客
05-17 209
Java类与接口
JAVA 类和接口介绍
zt320的专栏
03-25 1548
因为我个人有体会了一些东东也许提出来给大家参考看看(观念是一样的)我在这里再举个例子，或许会比较好了解首先，我将会定义一个interface与一些classinterface 汽车操作接口{    void 油门(){}    void 剎车(){}    void 方向盘(){}}以下是一些车子的class，这些车子都implements汽车操作接口因为每辆车的结构不同，所以
java类和接口用法_JAVA中的类和接口
weixin_27037521的博客
02-13 692
1、类：类是具有相同属性和方法的一组对象的集合，它为属于该类的所有对象提供了统一的抽象描述，其内部包括属性和方法两个主要部分。在面向对象的编程语言中，类是一个独立的程序单位，它应该有一个类名并包括属性和方法两个主要部分。Java中的类实现包括两个部分：类声明和类体。1.1类的声明格式：[pbulic] [abstract/final] class className [extendsParent...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值