我有一个抽象类和一个扩展它的类,我在这两个类中都有一个同名的方法.我想在抽象类的另一个方法中调用抽象类中的方法.
Controller.java
public abstract class Controller {
public Result delete(Long id) {
return this.delete(id, true);
}
public Result delete(Long id, boolean useTransaction) {
// do something and return result
}
}
FileGroup.java
public class FileGroup extends Controller {
public Result delete(Long id, boolean central) {
// do something
return super.delete(id);
}
}
super.delete调用Controller.delete但this.delete(id, true)调用delete的FileGroup,而不是调用delete中Controller,这是造成递归无限循环和堆栈溢出.
有没有办法在Swift中列出类的所有变量？
例如:
class foo {
var a:Int? = 1
var b:String? = "John"
}
我想这样列出: [a:1, b:"John"]
过去在JavaScript中创建"类"时,我这样做了:
function Dog(name){
this.name=name;
this.sound = function(){
return "Wuf";
};
}
但是,我只是看到有人这样做:
var Dog = (function () {
function Dog(name) {
this.name = name;
}
Dog.prototype.sound = function () {
return "Wuf";
};
return Dog;
})();
你可以两种方式做到,还是我做错了？在那种情况下,为什么？那两者在我们最终的结果方面究竟有什么区别？在这两种情况下,我们都可以创建一个对象:
var fido = new Dog("Fido");
fido.sound();
我希望有人能开导我.
我正在创建一个使用Frame()作为基类的GUIclass.
在我的GUIclass的init方法中,我想创建一个Frame小部件
现在我有:
class GUIclass(Frame):
def __init__(self, parent):
frame = Frame(self, parent)
但我在其他地方见过第三行:
Frame.__init__(self, parent)
我是编程,python和绝对继承的新手,我想知道我是否正确理解了两者之间的区别.我承诺,我做了大量的研究和阅读,但我找不到任何能让它完全清楚的东西:
在第一种情况下,我没有调用init方法,因为我创建了一个Frame对象(frame),当创建一个对象时,它的init方法被python隐式调用.
在第二个场景中,一个是在类上调用init方法(我认为这是完全合法的？)因为没有创建Frame对象,因此不会自动执行.
是对的吗？
我也看到了:
frame = Frame.__init__(self, parent)
这真的让我失望了.这只是某人做了多余的事情还是有理由这样做？
感谢您的帮助,我想暂时放慢速度并确保我完全理解我编写的任何代码行,而不是编写和运行我理解的整个程序.
装饰类或参数意味着什么？
我的目的是什么,我什么时候会这样做？
欢迎链接到资源和直接答案.
谢谢.
问题:给定任意顺序的一组时间间隔,将所有重叠间隔合并为一,并输出应该只具有互斥间隔的结果.为简单起见,将间隔表示为整数对.例如,让给定的一组区间为{{1,3},{2,4},{5,7},{6,8}}.区间{1,3}和{2,4}彼此重叠,因此它们应合并成{1,4}.类似地,{5,7}和{6,8}应该合并并成为{5,8}
编写一个函数,为给定的一组区间产生一组合并区间.
我的代码:
import java.util.*;
import java.lang.*;
import java.io.*;
class Interval
{
int start;
int end;
Interval() {
start = 0;
end = 0;
}
Interval(int s, int e)
{
start = s;
end = e;
}
}
class Ideone
{
public ArrayList<Interval> merge(ArrayList<Interval> intervals) {
if(intervals.size() == 0)
return intervals;
if(intervals.size() == 1)
return intervals;
Collections.sort(intervals, new IntervalComparator());
Interval first = intervals.get(0);
int start = first.start;
int end = first.end;
ArrayList<Interval> result = new ArrayList<Interval>();
for(int i = 1; …我已经开始准备自己参加OCJP7考试,我发现这一章看起来很复杂.
假设我有这段代码:
class Outer1{
interface InnerInterface{
String x = "test";
}
class InnerClass{
String x = "test";
}
}
class Outer2{
static interface NestedInterface{
String x = "test";
}
static class NestedClass{
String x = "test";
}
}
class Main{
public static void main(String [] args){
String s1 = Outer1.InnerInterface.x;
String s2 = new Outer1().new InnerClass().x;
String s3 = Outer2.NestedInterface.x;
String s4 = new Outer2.NestedClass().x;
}
}
你能告诉我,为什么我们可以访问Outer1.InnerInterface.x,并Outer2.NestedInterface.x以同样的方式？内部接口默认是静态的？我正试图建立一些联系,以使它们更清晰.
我有一个小班,如下:
class Gender(object):
MALE = 'M'
FEMALE = 'F'
我有一个参数变量,只能是M或F.为了确保它只是那个,我做以下事情:
>>> parameter = 'M'
>>> if parameter not in (Gender.MALE, Gender.FEMALE)
... print "Invalid parameter"
...
Invalid parameter
>>>
现在我有一个包含美国所有州的课程如下:
class States(object):
ALABAMA = 'AL'
ALASKA = 'AK'
ARIZONA = 'AZ'
ARKANSAS = 'AR'
CALIFORNIA = 'CA'
COLORADO = 'CO'
CONNECTICUT = 'CT'
DELAWARE = 'DE'
DISTRICTOFCOLUMBIA = 'DC'
....
....
就像上面的例子一样,我的参数现在是AL.但是,由于美国有50个状态,我实际上不能使用像我上面使用的50个变量的元组.有更好的方法吗？我确实读过关于isinstance的内容,但它没有给我预期的结果.
这是一个纯粹的抽象类吗？
class C
{
public:
static const std::string S;
C() {}
virtual ~C() {}
virtual void v() = 0;
}
我认为不是,遵循这个[1]定义.
纯Abstract类只有抽象成员函数,没有数据或具体成员函数.
它不能是纯抽象的,因为它不只有抽象的成员函数.
现在我的老师声称这是一个纯粹的抽象类,因为
纯虚拟类中包含的常量不被视为属性.它们是一个阶级的不可变元素,因此它们不违反其抽象性.这同样适用于静态方法.
[1] https://en.wikibooks.org/wiki/C%2B%2B_Programming/Classes/Abstract_Classes
[2] 如果一个类有一个非纯粹的析构函数,它仍然可以是纯抽象的吗？
[3] http://en.cppreference.com/w/cpp/language/destructor
[4] 抽象方法和纯虚函数是一回事吗？
我能找到的最接近的是在Ruby中,如何检查方法"foo =()"是否已定义？,但只有当方法是公共的时,它才有效,即使在类块内.
我想要的是:
class Foo
private
def bar
"bar"
end
magic_private_method_defined_test_method :bar #=> true
end
我尝试过的:
class Foo
private
def bar
"bar"
end
respond_to? :bar #=> false
#this actually calls respond_to on the class, and so respond_to :superclass gives true
defined? :bar #=> nil
instance_methods.include?(:bar) #=> false
methods.include?(:bar) #=> false
method_defined?(:bar) #=> false
def bar
"redefined!"
end # redefining doesn't cause an error or anything
public
def bar
"redefined publicly!"
end #causes no error, behaves no differently whether …