相关疑难解决方法(0)

尝试statemet.executeUpdate()在我的代码中执行时,我收到以下错误:

Local variable statement defined in an enclosing scope must be final or effectively final.

到目前为止这是我的代码:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;.

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;

public class a1 {

    protected Shell shell;
    private Text text;
    private Text text_1;
    private Text text_2;
    private Text text_3;

    /**
     * Launch the application.
     * @param args
     */
    public static void main(String[] args) {
        try { …

我正在学习lambda表达式和功能接口.我们可以通过lambda表达式直接编写接口的实现.所以我认为,它可能是多态性的替代品.

我有一些使用多态的代码,

interface Drawable {
    public void draw();
}


class Shape {

    protected String name;

    public Shape(String name) {
        this.name = name;
    }
}

class Rectangle extends Shape implements Drawable  {

    public Rectangle(String name) {
        super(name);
    }

    @Override
    public void draw() {
        System.out.println("I am "+this.name);
        System.out.println("Drawing rectangle with 2 equal sides.");
    }
}

class Square extends Shape implements Drawable {

    public Square(String name) {
        super(name);
    }

    @Override
    public void draw() {
        System.out.println("I am "+this.name);
        System.out.println("Drawing square with 4 equal sides."); …

我对编程很新,但我已经在我的学校学习了Intro CS课程,所以我理解了大部分基础知识(或者我认为我做过).我试图通过JOGL教自己一些OpenGL,我遇到了几行我无法理解的代码.我错过了什么吗？

frame.addWindowListener(new WindowAdapter() {
  public void windowClosing(WindowEvent e) {
    System.exit(0);
  }
});

• 我检查了Javadoc,WindowAdapter是一个抽象类.那他怎么能实例化呢？

• 或者甚至创建一个实例？

• 它几乎看起来像代码扩展WindowAdapter或覆盖了windowClosing方法,但是如果没有编写新类,这怎么可能呢？

View.OnClickListener()是函数还是接口？当我们尝试在android中设置一个onclicklistener()方法时,我们使用新的View.OnClickListener(),据我所知,它会让我感到烦恼,因为

• 我们不需要初始化包含静态方法的类的对象,以便使用这些方法.为什么我们这样做？
• 当我们使用implements来实现接口时,我们不会调用接口的静态方法.

那么有人可以告诉我为什么这样做:

• 新的View.OnClickListener(),用于使用onclick()方法？
• 如果它是一个接口,为什么我们使用View.OnClickListener？

感谢您的回复..

我最近一直在寻找很多OOP设计模式,我遇到了一些我以前从未见过的奇怪事情:

Button button =  new Button(shell, SWT.PUSH);
button.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
    // Handle the selection event
    System.out.println("Called!");
    }
}); 

具体来说,这是做什么的(例如,"new"关键字在这里做什么)？:

    button.addSelectionListener(new SelectionAdapter() {

第二个问题:

private void notifyListeners(Object object, String property, String oldValue, String newValue) {
   for (PropertyChangeListener name : listener) {
      name.propertyChange(new PropertyChangeEvent(this, "firstName", oldValue, newValue));
   }
}

这是观察者设计模式的片段.根据我的新理解,name.propertyChange(...)创建了一个PropertyChangeEvent对象,并通过Java的观察者模式实现,通过将这个新对象的信息发送给观察者(或者与此非常相似的东西)自动通知观察者.它是否正确？

我知道一个接口不能有构造函数,我们不能创建接口对象.

这是不可能的:

Comparator cmp = new Comparator(); 

我不明白如何使用关键字"new Comparator()"创建一个匿名内部类.此关键字是否不会创建Comparator类型的对象？

这是完整的代码:

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class DemoApp {

    public static void main(String args[]) {

        List<String> animals = new ArrayList<>();
        animals.add("elephant");
        animals.add("snake");
        animals.add("lion");
        animals.add("mangoose");
        animals.add("cat");
        animals.add("tiger");

        Collections.sort(animals, new Comparator<String>() {
            public int compare(String s1, String s2) {
                return -s1.compareTo(s2);
            }
        });
        displayList(animals);
    }

    public static void displayList(List<String> anim) {
        for (String animal : anim) {
            System.out.print(animal + " "); 
        }
        System.out.println();
    }
 }

在我的采访中,面试官问我

我们可以创建没有名字的课吗？

因为,我不确定,是否真的可以创建一个没有名字的类.所以,我说没有.

后来,我尝试使用Google搜索并发现,其他人也在寻找同一问题的答案,但我没有找到明确的答案.

如果有人清楚地解释这个课程,我将不胜感激.我的意思是,这个类技术上知道什么,我们如何实例化这个类？

这是代码:

    timer.schedule(new TimerTask() 
    {
       public void run()
       {
            synchronized(this)
            {
                 try 
                 {   
                   // System.out.println(" ITERATION = ");

                     pachubeCLI.update(78164);  

                 } 
                 catch (PachubeException e)
                 {
                        // If an exception occurs it will print the error message from the
                        // failed HTTP command
                        System.err.println(e.errorMessage);
                 } 
                 catch (IOException e) 
                 {
                        System.err.println(e);
                 } 

             }
        }
    }, 0, 5*1000);

我可以说,代码基本上用于使用Timer类的对象来安排操作.schedule根据eclipse 传递给方法的参数是(TimerTask task,long delay, long period).但是看一下这段代码,整个代码块作为第一个参数而不是对TimerTask类的引用传递.我以前从未见过这样的方法.到底发生了什么？

一些背景:该对象的schedule方法Timer用于定期更新Xively(以前的COSM(以前的pachube))上的Feed.

此外,我不知道哪个标签描述了这里发生的事情.如果你这样做,请添加或发表评论.

将所有类代码保存为单独的.java文件是否很重要？

Outer.java,
Inner.java,
Test.java

或者我可以将一个java文件创建为Test.java.请解释匿名类,如何在java中创建匿名类,与普通类相比有哪些优势/劣势？

class Outer {
    private int data = 50;

    class Inner {
        void msg() {
            System.out.println("Data is: " + data);
        }
    }
}

class Test {
    public static void main(String args[]) {
        Outer obj = new Outer();
        Outer.Inner in = obj.new Inner();
        in.msg();
    }
}

我试图理解Scala中的Anonymous子类.我写了下面的代码:

package com.sudipta.practice.chapter8

class Person(val name: String) {
  def printMyName = println("Name: " + name)
}

class AnonymousSubclass(val name: String) {
    val anonymousSubclass = new Person(name){
      def sayHello = "Hello, " + name
      def sayBye = "Bye, " + name
      override def printMyName = println("My name is: " + name)
    }

}

object testPerson extends App {

  def printAnonDetails (myObject: AnonymousSubclass) = {
    myObject.anonymousSubclass.printMyName
  }

  val personObject = new Person("Sudipta")
  personObject.printMyName

  val anonObject = new AnonymousSubclass("Sudipta")

  printAnonDetails(anonObject)
}

但是我无法理解Scala中Anonymous Subclass的用法/优点是什么.如果您有任何积分,请在此处分享.谢谢. …