java中声明一个类的时候用abstract 和interface同时声明是啥含义?

Posted 2023-05-07

eg：声明的方式： public abstract interface A
//method（）；

到底是抽象类还是接口？？？

同时声明就是 "抽象接口" 的意思。 是接口。

抽象接口 与 普通接口 的区别就是 抽象接口 无法直接被实现， 但它可以被普通接口继承。

abstract interface a
interface b extends a
class C implements b 但 class C 无法implements a;

它存在的意义，就是可以为继承它的接口定义一个或多个一样的方法。 参考技术A 给你举个例子,如果对人类的抽象,最好是abstract,如果是对 会跑的..会跳的 等抽象就要用interface

abstract主要是用来对一类事物抽象

interface是对事物共同特征行为的抽象 参考技术B interface是接口继承接口里面的方法。abstract表示这是一个抽象类。可以定义抽象方法，也不可不定义 参考技术C public class AbstractInterface 
public static void main(String[] args) 
Car car = new Car();
car.show();



abstract interface Rush
public void show();


class Car implements Rush
@Override public void show()  System.out.println("Car"); 

这样是可以的。abstract interface和interface没有区别，只是省略写法而已。

参考技术D abstract抽象类中可以有自己实现的方法 interface中不行

abstract interface 真有这种写法么, 还真不知道....
======================================================

时声明就是 "抽象接口" 的意思。

抽象接口 与 普通接口 的区别就是 抽象接口 无法直接被实现， 但它可以被普通接口继承。

abstract interface a
interface b extends a
class C implements b 但 class C 无法implements a;
=====================================================
我试过了, class C 可以实现接口a ..... 你确定你上面说的是正确的? 为什么我这里能实现接口抽象接口呢追问

确实真的有，以前都没见过

追答

接口就是抽象的吧, 难道还有不是抽象的接口?

=================================
它存在的意义，就是可以为继承它的接口定义一个或多个一样的方法。

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

普通接口的继承不就是为了这个目的么, 为什么非要说成抽象接口的存在意义......

Java中类的声明与对象创建

　　类是一个模板，它描述一类对象的行为和状态；对象是类的一个具体的实例，由类构造对象的过程称为创建类的实例。如：路灯是一个类，每一个路灯就是该类的对象。

1.类声明

　　类声明格式

[public] [abstract|final] class 类名称        //class表明其后声明的是一个类，final表示该类为终结类，不能被继承；abstract为抽象类
[extends 父类名称]                               //表示该类继承的父类
[implements 接口名称列表]{                  //表明该类要实现的接口
       数据成员声明及初始化；
       方法声明及方法体；     
}

例:钟表类实例

public class Clock{
	//变量成员
	int hour;
	int minute;
	int second;
	
	//方法成员
	public void setTime(int newH,int newM,int newS){
		hour = newH;
		minute = newM;
		second = news;
	}
	
	public void showTime(){
		System.out.println(hour + ":" + minute + ":" + second);
	}
}

 

2.对象创建

　　对象在使用前必须声明对象的名称和对象类型，然后使用关键字new创建对象。

　　声明对象语法：类名 引用变量名

　　如：Clock是已经声明的类名，现在要声明引用变量alock，用于存储该类对象的引用：

Clock aclock; //此时并没有生成对象，只是一个空引用

　　创建对象语法：new <类名>()

aclock = new Clock();   //在内存中为Clock类型的对象分配内存空间，返回对象的引用
引用对象可以被赋以空值
aclock = null;

3.数据成员

　　　数据成员表示对象的状态，可以是任意的数据类型。

　　1.数据成员的声明　　

[public|protected|private][static][final][transient][volatile]
数据类型 变量名1[=变量初值]，变量名2[=变量初值],...;

//public、protected、private为访问控制符
//static 指明这是一个静态成员变量（类变量）
//final指明变量的值不能被修改
//transient指明变量是不需要序列化的
//volatile指明变量是一个共享变量

　　2.实例变量--描述对象的属性

　　没有static修饰的变量（数据成员）称为实例变量；

 

　　存储所有实例都需要的属性，不同实例的属性值可能不同。

 

　　访问实例属性的值：<实例名>.<实例变量名>

//圆类保存在文件Circle.java中，测试类保存在文件ShapeTester.java中，两个文件
//放在相同的目录下

public class Circle{
	int radius;
}

public class ShapeTester{
	public static void main(String[] args){
		Circle x;
		x = new Circle();
		System.out.println(x);
		System.out.println("radius = " + x.radius);
	}
}
//运行结果
Circle@26b249
radius = 0

　　3.类变量

　　　　用static修饰，在整个类中只有一个值，在类初始化的同时就被赋值，适用于与类中中所有对象都相同的属性，或者需要经常共享的数据，或者在系统中需要用到的一些常量值。

　　引用格式：<类名|实例名> <类变量名>

public class Circle{
	static double PI = 3.1415926;
	int radius;
}
//当我们生成Circle类的实例时，在每一个实例中并没有存储PI的值，PI的值存储在类中

public class ClassVariableTester{
	public static void main(String[] args){
		Circle x = new Circle();
		System.out.println(x.PI);
		System.out.println(Circle.PI);
		Circle.PI = 3.14;
		System.out.println(x.PI);
		System.out.println(Circle.PI);
	}
}

//运行结果
3.14159265
3.14159265
3.14
3.14

 

4.方法成员

　　1.语法形式

[public|protected|private]
[static][final][abstract][native][synchronized]
返回类型 方法名（[参数列表]）[throw exceptionList]
{
	方法体
}
//public、protected、private控制访问权限
//static指明这是一个静态方法
//final指明这是一个终结方法
//abstract指明这是一个抽象方法
//native用来集成java代码和其他语言的代码
//synchronized用来控制多个并发线程对共享数据的访问

//返回类型：可以是任意的java数据类型，不需返回值时，返回类型为void

//参数类型：可以是简单数据类型，也可以是引用类型（数组、类或接口）；
//参数个数：可以有多个参数，也可以没有参数，方法声明时的参数称之为形式参数

//方法体：为方法的实现，包括局部变量的声明以及所有合法的java语句，作用域为该方法内部

//throw exceptionList:抛出异常列表

　　2.实例方法：表示特定对象的行为，声明前不需要加static修饰

　　　调用：给对象发消息，通过调用对象中的某个方法，使用对象的某个行为/功能。

　　　格式：　　　

<对象名>.<方法名>([参数列表])
<对象名>为消息的接受者

　参数传递

　　1.值传递：参数类型为基本数据类型时，由形参传给实参

　　2.引用传递：参数类型为引用类型时

public class Circle{
	static double PI = 3.14159265;
	int radius;
	public double circumference(){
		return 2*PI*radius;
	}
	public void enlarge(int factor){
		radius = radius *　factor;
	}
	public boolean fitsInside(Rectangle r){
		return (2*radius < r.width)&&(2*radius<r.height);
	}
}

public class InsideTester{
    public static void main(String[] args){
        Circle c1 = new Circle();
        c1.radius = 8;
        Circle c2 = new Circle();
        c2.radius = 15;
        Rectangle r = new Rectangle();
        r.width = 20;
        r.height = 30;
        System.out.println("Circle 1 fits inside Rectangle :" + c1.fitsInside(r));
        System.out.println("Circle 2 fits inside Rectangle :" + c2.fitsInside(r));
    }  
}

//运行结果
Circle 1 fits inside Rectangle:true
Circle 2 fits inside Rectangle:false

 

　　3.类方法：声明前需加static修饰

　　　　类方法不能被声明为抽象的，可以直接通过类名调用，也可以通过类实例调用。　　

　

//将摄氏温度（centigrade）转换成华氏温度（Fahrenheit）

public class Converter{
	public static int centigradeToFahenheit(int cent){
		return (cent*9/5 + 32);
	}
}

//方法调用
Converter.centigradeToFahrenheit(40)

　　当传递的参数为可变长参数时，可用省略号表示，其实质是数组，如String ...s，传递给可变长参数的实际参数可以是0到多个对象。

static double maxArea(Circle c,Rectangle... varRec){
	Rectangle[] rec = varRec;
	for(Rectangle r:rec){
		//...
	}
}

public static void main(String[] args){
	Circle c = new Circle();
	Rectangle r1 = new Rectangle();
	Rectangle r2 = new Rectangle();
	System.out.println("max area of c, r1 and r2 is" + maxArea(c,r1,r2));
	System.out.println("max area c and r1 is " + maxArea(c,r1));
	System.out.println("max area c and r2 is " + maxArea(c,r2));
	System.out.println("max area of only c is " + maxArea(c));
}