• 
• 1 answer

C# and Java have many similaries. If you learn one, you won't have much of a problem learning the other.

• 
• 1 answer

A flow chart is an aid to getting the logic in a program doing the wright things. A flow chart is useful with any programming language.

• 
• 1 answer

Yes, in some way it's similar.

One difference is that Java Bytecode is typically interpreted by the virtual machine, while MSIL is JIT-compiled to native machine code before executing. However, it is increasingly common for bytecode to be compiled as well.

• 
• 1 answer

My answer may not be the intent of the designer of overloading. But here are my understanding and the best use of it:

If you have a group of methods that are:

1. functioning the same (return the same object type), and

2. they takes different parameters or arugments,

you may overload that that group of methods with the same name.

Please note that the word may. (You have the option, but do not have to)

One example is the overloaded method ToString()

Some of other possible overloading ways are: ToString(string fmt), ToString(int start, int count);

In other computer language, one may have to code as ToFormattedString(), ToSubString(), instead of using the same method name.

• 
• 1 answer

System.String is a class. However, it is somewhat unique in that it is immutable, meaning that it is readonly. So if you change the contents of a string, behind the scenes it creates a new string object and destroys the old one.

• 
• 1 answer

An indexer is a special kind of Property at instance level.

For example:

public class MyBook {

public string this[string stringIndex]

{ get { return null; } set { // }}

public string this[int intIndex] {

{ get { return null; } set { // }}

}

}

MyBook has two indexers, one in the form of string, one in the form of int.

Example continue:

MyBook aBook = new MyBook();

Console.WriteLine(aBook["Whatever"], aBook[100]);

• 
• 1 answer

• 
• 1 answer

• 
• 1 answer

In C, a variable declared as static in a function is initialised once, and retains its value between function calls.

The default initial value of an uninitialized static variable is zero.

If a function or global variable is declared static, it can only be accessed in that file.

• 
• 1 answer

• 
• 1 answer

• 
• 1 answer

Both languages use the same .NET Framework, so the functionality available to you is very similar. They are both OOP languages.

The differences are mostly syntactical. VB tends to be more verbose than C#.

In fact, 3rd party programs exist that will convert C# code to VB.NET or vice-versa. So the choice of which to use is personal preference.

• 
• 1 answer

This issue all goes back to the Constitutional Convention, when there was an issue of big states vs. small states. After a heated debate, the Great Compromise was proposed by Roger Sherman, which created a bicameral legislature. Each states would have equal representation in the Senate (satisfied the small states) and the size of the population of each state would determine the state's representation in the House of Representatives (satisfied the big states). There is also a similar case in the state of Alabama in which the state legislature were apportioned and assigned to districts, based on populations. This supreme court case is known as Reynolds v. Sims.

• 
• 1 answer

In Java, if there is a run-time error then it allows the user to explicitly handle it by catching it in the catch block. If there is any error in the try block of code, automatically the flow control will be transferred to the catch block. Here Exception e indicates any exception. The same is true in both Visual Basic and C#. This is seen in the

try {}

catch (Exception e) {}

blocks. Which then function as the previous poster said.

== == == ==

• 
• 1 answer

http://www.geekpedia.com/tutorial176_Get-and-set-the-wave-sound-volume.html

this site explains it well

• 
• 1 answer

Yes, it is.

• 
• 1 answer

• 
• 1 answer

• 
• 1 answer

Arrays are variables, too.

Accessing array-elements is obviously a bit slower than accessing scalars.

• 
• 1 answer

Formal parameters are the parameters as they are known in the function definition. Actual parameters (also known as arguments) are what are passed by the caller. For example, in the following code, a and b are the formal parameters, and x and y are the actual parameters:

int max(int a, int b) {
if (a > b) return a;
else return b;
}

int m = max(x, y);

• 
• 1 answer

//testing code

//note that a space character should be neither a vowel, nor a consonant

string s = "This is a test";

Console.WriteLine("Source string: {0}", s);

Console.WriteLine("# of Vowels: {0}",

GetCount(s, "aeiou"));

Console.WriteLine("# of Consonants: {0}",

GetCount(s, "bcdfghjklmnpqrstvwxyz"));

// helpers

// get number of characters in source that are in charactersToMatch

public int GetCount(string source, string charactersToMatch)

{

char[] target = charactersToMatch.ToCharArray();

int count = 0;

foreach (char c in source.ToLower()) {

if (IsMatch(c, target)) count++;

}

return count;

}

//returns true if c is one of patterns, false otherwise

public bool IsMatch(char c, char[] patterns)

{

foreach (char p in patterns) {

if (c == p) return true;

}

return false;

}

• 
• 1 answer

The static modifier means that it does not have to be instantiated to use it. Before a program runs there are technically no objects created yet, so the main method, which is the entry point for the application must be labeled static to tell the JVM that the method can be used without having first to create an instance of that class. Otherwise, it is the "Which came first, the chicken or the egg?" phenomenon. Your main method should be declared as follows: public static void main (String[] args) { lots of your java code... } As we know, java is a pure OOP , that means everything should be in the class, main. Aso, because main is itself a function, static member functions should not refer to objects of that class. But we can access static functions through classname itself, as: class TestMain { public static void main(String args[]) { body; } } Now, cmd>javac TestMain.java cmd>java TestMain as we know the static member functions has to call through its class name. That's why the programme name must be same as the class name ,where we wrote the main function. Another important point is : static variables or member functions will load during class. That means before creating any instances(objects), the main function is the first runnable function of any program which we run manually, such as : cmd>java TestMain(run) if , any sharing information.

• 
• 2 answers

The best way to have your carpets cleaned would be to hire a professional. These companies have the proper tools to make sure there isn't any damaged caused.

• 
• 1 answer

A console application will use the console to interact with the user. A window application will use a graphical interface to do so.

• 
• 1 answer

Programs that are loaded into memory typically have several segments associated with them: the Code Segment (CS), the Stack Segment (SS), the Data Segment (DS), sometimes an Extended Segment (ES), and almost always a Block Started by Symbol (BSS) segment. This question requires that we focus only on the Code Segment (CS). The CS is a segment of memory that contains some of the instructions that are required for the program to execute. If this segment is not large enough to contain the whole program then the program can be loaded into different segments. Such a segment may be 64Kb in size (although the size may differ). Instructions located in these segments are referred to by their offset from the start of the segment, and not by their absolute location in memory. Thus, in order to locate a certain instruction, we need the segment's starting address, and the offset of the instruction in that segment. Whenever a branch (jump, goto) takes place which refers to an instruction that is located in another segment, it is known as a far jump, conversely whenever a jump refers to an instruction that is located in the same segment, it is known as a near jump. The difference referring to the modication of the CS register which contains the address of the current Code Segment for the current running program.