c

String vs StringBuffer Java

phamvis — Wed, 08 Dec 2010 23:44:51 +0000

1. String vs StringBuffer:

String class simply stores an array of characters that is immutable.

StringBuffer class is used to represent characters that can be modified.

The significant performance difference between these two classes is that StringBuffer is faster than String when performing simple concatenations.

For example: Create 1 file Stringtest.java.

public class Stringtest
{
public static void main(String arg[])
{
String str = new String (“Stanford “);
str += “Lost!!”;
StringBuffer strb = new StringBuffer(“Buffer”);
strb.append(“String”);
}
}

(assume Stringtest.java in C:\Stringtest.java)

then, Start-> Run ->cmd and turn to folder that contains that java file.

javac Stringtest.java

then:

javap -c Stringtest // show bytecode.

You can see difference between them. In detail:

http://www.javaworld.com/javaworld/jw-03-2000/jw-0324-javaperf.html

in general:

String str = new String (“Stanford “);
str += “Lost!!”;

the first, create String(“Stanford”) object if when called + operator it will wait for garbage collector.

next, str += “Lost!”; create StringBuilder(“Stanford”); and then call append(“Lost!”) on it.

final, create new String object and StringBuilder above call toString() to assign to String object just create.

2. String literal:

if you declare 2 string has the same content and both are not new, this mean that both are reference to string not instance and initial.

String string1 = “String”;

String string2 = “String”;

What happend when you write like this?

if(string1 == string2)

System.out.println(“string1 and string2 are the same address”);

else

System.out.println(“string1 and string2 are the different address”);

result:

string1 == string2 and string1 and string2 are the same address.

Because if 2 string object have the same context but them not instance and initial in fact is only one object string.

Summary:

+ String: immutable and read only, so it is used to if no change.

+ StringBuffer: mutable, synchronize so it’s used to when change and synchronize in many threads.

+ StringBuilder: mutable, unsynchronize.

+ And finally, attention with string literal.

Overloading vs override

phamvis — Wed, 08 Dec 2010 10:36:52 +0000

1.Overload vs override:

Ø Overriding – same method names with same parameters and same return types associated in a class and its subclass.

Ø Overloading – same method name with different parameters may or may not be same return type written in the same class itself.

2. Dynamic binding and static binding:

Ø Dynamic binding or later binding: Dynamic binding refers to the case where compiler is not able to resolve the call and the binding is done at runtime only.

Ø Static binding or early binding: compiler can resolve the binding at the compiler time.

Dynamic binding: all instance method calls are always resolved at runtime.

Static binding: static methods, variable, private methods.

For example:

/* in superclass and baseclass, getName() is override, attention here both have the same property name that is name;*/

class superclass {

String name = “This is a field of super class”;

public String getName(){

return name;

}

class baseclass extends superclass {

String name = “This is field of base class”;

public String getName() {

return name;

}

/* In test class, methodA()is a overload, this mean methodA() has the same name, and different parameter. */

class test {

public void methodA(superclass sup) {

System.out.println(“test.methodA(superclass)”);

}

public void methodA(baseclass base) {

System.out.println(“test.methodA(baseclass)”);

}

public class Main {

/**

* @param args

public static void main(String[] args) {

// TODO Auto-generated method stub

/* this is 2 object variables type superclass.*/

superclass sup;

superclass base;

/* instantiate and initial */

sup = new superclass();

base = new baseclass();

/* override */

System.out.println(sup.getName());

System.out.println(base.getName());

System.out.println(sup.name);

System.out.println(base.name);

/* this is overloading.*/

test te = new test();

te.methodA(sup);

te.methodA(base);

}

Output:

This is a field of super class

This is field of base class

This is a field of super class

This is a field of base class

test.methodA(superclass)

test.methodA(baseclass)

Is this right result? Sure? Infact,

This is a field of super class

This is field of base class

This is a field of super class

test.methodA(superclass)

+ 2 first lines here call dynamic binding, because compiler may not be sure of which version of the getName() to call, based on the actual object type and not on the declared type of the object reference.(Pholimorphism)

+ 2 next lines, this is static binding, because member variable is resolved based on the declared type of the object reference only, which compiler is capable of finding at compiler time.

+ 2 final lines are overloading, because overloading is compiler-binding, when the compiler see the line te.methodA(base), it checks the data type of base, which is declared as superclass, so it look for the method, methodA(superclass) and binds the call to this method and hence the result.

3. Sumary:

Pholymorphism: one name, many forms.

Pholymorphism manifest itself in three distince forms in Java:

+ method overloading.

+ method overriding through inheritance.

+ method overriding through the Java interface.

Dynamic binding:

+ all methods in a class.

+ method overriding.

Static binding:

+ all variable.

+ static methods.

+ private methods.

+ overloading.

References:

http://www.developer.com/java/other/article.php/983081

http://www.techfundu.com/2009081032/java-technology/core-java/what-is-the-difference-between-dynamic-and-static-binding-in-java

http://skeletoncoder.blogspot.com/2006/09/java-tutorials-overloading-is-compile.html

JPA

phamvis — Fri, 26 Nov 2010 17:43:23 +0000

Field Access:

Annotating the fields of the entity will cause the provider to use field access to get and set the state of
the entity. Getter and setter methods might or might not be present, but if they are present, they are
ignored by the provider. All fields must be declared as either protected, package, or private. Public
fields are disallowed because it would open up the state fields to access by any unprotected class in the
VM. Doing so is not just an obviously bad practice but could also defeat the provider implementation.
Of course, the other qualifiers do not prevent classes within the same package or hierarchy from doing
the same thing, but there is an obvious trade-off between what should be constrained and what should
be recommended. Other classes must use the methods of an entity in order to access its persistent
state, and even the entity class itself should only really manipulate the fields directly during
initialization.
The example in Listing 4-1 shows the Employee entity being mapped using field access. The @Id
annotation indicates not only that the id field is the persistent identifier or primary key for the entity
but also that field access should be assumed. The name and salary fields are then defaulted to being
persistent, and they get mapped to columns of the same name.

Property Access
When property access mode is used, the same contract as for JavaBeans applies, and there must be
getter and setter methods for the persistent properties. The type of property is determined by the
return type of the getter method and must be the same as the type of the single parameter passed into
the setter method. Both methods must be either public or protected visibility. The mapping
annotations for a property must be on the getter method.
In Listing 4-2, the Employee class has an @Id annotation on the getId() getter method so the
provider will use property access to get and set the state of the entity. The name and salary properties
will be made persistent by virtue of the getter and setter methods that exist for them, and will be
mapped to NAME and SALARY columns, respectively. Note that the salary property is backed by the wage
field, which does not share the same name. This goes unnoticed by the provider because by specifying
property access, we are telling the provider to ignore the entity fields and use only the getter and
setter methods for naming.

Mixed Access
It is also possible to combine field access with property access within the same entity hierarchy, or
even within the same entity. This will not be a very common occurrence, but can be useful, for
example, when an entity subclass is added to an existing hierarchy that uses a different access type.
Adding an @Access annotation with a specified access mode on the subclass entity will cause the default
access type to be overridden for that entity subclass.

THread

phamvis — Thu, 18 Nov 2010 00:59:35 +0000

Often, a thread enters a critical section, only to discover that it can’t proceed until a
condition is fulfilled. You use a condition object to manage threads that have acquired
a lock but cannot do useful work. In this section, we introduce the implementation
of condition objects in the Java library. (For historical reasons, condition objects are
often called condition variables.)
Let us refine our simulation of the bank. We do not want to transfer money out of an
account that does not have the funds to cover the transfer. Note that we cannot use
code like
if (bank.getBalance(from) >= amount)
bank.transfer(from, to, amount);
It is entirely possible that the current thread will be deactivated between the successful
outcome of the test and the call to transfer.
if (bank.getBalance(from) >= amount)
// thread might be deactivated at this point
bank.transfer(from, to, amount);
java.util.concurrent.locks.Lock 5.0
java.util.concurrent.locks.ReentrantLock 5.0
Chapter 14. Multithreading
746 Chapter 14 ■ Multithreading
By the time the thread is running again, the account balance may have fallen below
the withdrawal amount. You must make sure that no other thread can modify the balance
between the test and the transfer action. You do so by protecting both the test
and the transfer action with a lock:
public void transfer(int from, int to, int amount)
{
bankLock.lock();
try
{
while (accounts[from] < amount)
{
// wait
. . .
}
// transfer funds
. . .
}
finally
{
bankLock.unlock();
}
}
Now, what do we do when there is not enough money in the account? We wait until
some other thread has added funds. But this thread has just gained exclusive access
to the bankLock, so no other thread has a chance to make a deposit. This is where condition
objects come in.
A lock object can have one or more associated condition objects. You obtain a condition
object with the newCondition method. It is customary to give each condition object a name
that evokes the condition that it represents. For example, here we set up a condition
object to represent the “sufficient funds” condition.
class Bank
{
public Bank()
{
. . .
sufficientFunds = bankLock.newCondition();
}
. . .
private Condition sufficientFunds;
}
If the transfer method finds that sufficient funds are not available, it calls
sufficientFunds.await();
The current thread is now deactivated and gives up the lock. This lets in another
thread that can, we hope, increase the account balance.
There is an essential difference between a thread that is waiting to acquire a lock and a
thread that has called await. Once a thread calls the await method, it enters a wait set for that
condition. The thread is not made runnable when the lock is available. Instead, it stays
deactivated until another thread has called the signalAll method on the same condition.
Chapter 14. Multithreading
Synchronization 747
When another thread transfers money, then it should call
sufficientFunds.signalAll();
This call reactivates all threads that are waiting for the condition. When the threads are
removed from the wait set, they are again runnable and the scheduler will eventually
activate them again. At that time, they will attempt to reenter the object. As soon as the
lock is available, one of them will acquire the lock and continue where it left off, returning
from the call to await.
At this time, the thread should test the condition again. There is no guarantee that the
condition is now fulfilled—the signalAll method merely signals to the waiting threads
that it may be fulfilled at this time and that it is worth checking for the condition again.
NOTE: In general, a call to await should be inside a loop of the form
while (!(ok to proceed))
condition.await();
It is crucially important that some other thread calls the signalAll method eventually.
When a thread calls await, it has no way of reactivating itself. It puts its faith in the other
threads. If none of them bother to reactivate the waiting thread, it will never run again.
This can lead to unpleasant deadlock situations. If all other threads are blocked and the
last active thread calls await without unblocking one of the others, then it also blocks. No
thread is left to unblock the others, and the program hangs.
When should you call signalAll? The rule of thumb is to call signalAll whenever the state
of an object changes in a way that might be advantageous to waiting threads. For example,
whenever an account balance changes, the waiting threads should be given another
chance to inspect the balance. In our example, we call signalAll when we have finished
the funds transfer.
public void transfer(int from, int to, int amount)
{
bankLock.lock();
try
{
while (accounts[from] < amount)
sufficientFunds.await();
// transfer funds
. . .
sufficientFunds.signalAll();
}
finally
{
bankLock.unlock();
}
}
Note that the call to signalAll does not immediately activate a waiting thread. It only
unblocks the waiting threads so that they can compete for entry into the object after the
current thread has exited the synchronized method.
Chapter 14. Multithreading
748 Chapter 14 ■ Multithreading
Another method, signal, unblocks only a single thread from the wait set, chosen at random.
That is more efficient than unblocking all threads, but there is a danger. If the randomly
chosen thread finds that it still cannot proceed, then it becomes blocked again. If
no other thread calls signal again, then the system deadlocks.
CAUTION: A thread can only call await, signalAll, or signal on a condition when it owns the
lock of the condition.
If you run the sample program in Listing 14–8, you will notice that nothing ever goes
wrong. The total balance stays at $100,000 forever. No account ever has a negative balance.
(Again, you need to press CTRL+C to terminate the program.) You may also notice
that the program runs a bit slower—this is the price you pay for the added bookkeeping
involved in the synchronization mechanism.
In practice, using conditions correctly can be quite challenging. Before you start implementing
your own condition objects, you should consider using one of the constructs
described in “Synchronizers” on page 785.

My Dream…

phamvis — Mon, 28 Dec 2009 02:41:14 +0000

I want to became EXPERT in C++,C#,SQL…

and i want like this before graduating. and i believe me. i want in the future i do about security database… i want this. i will do this. try to, try hard to go up.

1. time is gold.

2. find myself value.

Database Object SQL SERVER 2005

phamvis — Tue, 22 Dec 2009 07:12:23 +0000

STORED PROCEDURE:

What is the stored procedure?

In the simplest terms, a stored procedure is a collection of compiled T-SQL commands that are directly accessible by SQL Server.

The commands placed within a stored procedure are executed
as one single unit, or batch, of work.

The benefit of this is that network traffic is greatly reduced, as single SQL statements are not forced to travel over the network; hence this reduces network congestion. In addition to SELECT, UPDATE, or DELETE statements, stored procedures are able to call other stored procedures, use statements that control the flow of execution, and perform aggregate functions or other calculations.

phamvis — Mon, 21 Dec 2009 19:40:24 +0000

1. DateTimePicker.

protected override void OnvalueChanged(eventargs) method

Raises the ValueChanged event.

Parameters

eventargs

An EventArgs that contains the event data.

Remarks

The ValueChanged event occurs when the value for the control changes.

DatetimePickerFormat.Custom

this.CustomFormat=

Format String	Description
d	The one- or two-digit day.
dd	The two-digit day. Single digit day values are preceded by a zero.
ddd	The three-character day-of-week abbreviation.
dddd	The full day-of-week name.
h	The one- or two-digit hour in 12-hour format.
hh	The two-digit hour in 12-hour format. Single digit values are preceded by a zero.
H	The one- or two-digit hour in 24-hour format.
HH	The two-digit hour in 24-hour format. Single digit values are preceded by a zero.
m	The one- or two-digit minute.
mm	The two-digit minute. Single digit values are preceded by a zero.
M	The one- or two-digit month number.
MM	The two-digit month number. Single digit values are preceded by a zero.
MMM	The three-character month abbreviation.
MMMM	The full month name.
s	The one- or two- digit seconds.
ss	The two-digit seconds. Single digit values are preceded by a zero.
t	The one-letter AM/PM abbreviation (that is, “AM” is displayed as “A”).
tt	The two-letter AM/PM abbreviation (that is, “AM” is displayed as “AM”).
X	A callback field that gives programmer control over the displayed field (see below.) Multiple X characters can be used in a series to signify unique callback fields.
y	The one-digit year (that is, 1996 is displayed as “6″).
yy	The last two digits of the year (that is, 1996 is displayed as “96″).
yyy	The full year (that is, 1996 is displayed as “1996″).

2.DataGridView:

DataGridView.EditingControl Property

Gets the control hosted by the current cell, if a cell with an editing control is in edit mode.

Namespace: System.Windows.Forms
Assembly: System.Windows.Forms (in System.Windows.Forms.dll)

Syntax

[BrowsableAttribute(false)]
public Control EditingControl { get; }

Property Value

Type: System.Windows.Forms.Control
The Control hosted by the current cell.

Remarks

If the cell is not in edit mode or the cell type does not accommodate an editing control, this property returns null reference

DataGridView.NotifyCurrentCellDirty Method

Notifies the DataGridView that the current cell has uncommitted changes.

Namespace: System.Windows.Forms
Assembly: System.Windows.Forms (in System.Windows.Forms.dll)

Syntax

public virtual void NotifyCurrentCellDirty(
    bool dirty
)

Parameters

dirty: Type: System.Boolean
true to indicate the cell has uncommitted changes; otherwise, false.

Remarks

This method can be used to allow custom cell types to notify the DataGridView when they have uncommitted changes.

3. DatagridViewTextboxCell

DataGridViewTextBoxCell.InitializeEditingControl Method

Attaches and initializes the hosted editing control.

Namespace: System.Windows.Forms

Syntax

public override void InitializeEditingControl(
    int rowIndex,
    Object initialFormattedValue,
    DataGridViewCellStyle dataGridViewCellStyle
)

Parameters

rowIndex: Type: System.Int32
The index of the row being edited.

initialFormattedValue: Type: System.Object
The initial value to be displayed in the control.

dataGridViewCellStyle: Type: System.Windows.Forms.DataGridViewCellStyle
A cell style that is used to determine the appearance of the hosted control.

Remarks

The InitializeEditingControl method initializes the hosted editing control as described in the base DataGridViewCell.InitializeEditingControl method. For every invocation, this method also sets the following visual attributes of the editing control:

The BorderStyle property is set to None.
The Multiline and AcceptsReturn properties are set to true.
The Text property is set to the initialFormattedValue parameter.

18.12.2009

phamvis — Thu, 17 Dec 2009 19:15:35 +0000

ow! gần về gặp lại nàng rồi, không biết nàng có nghĩ tầm bậy ko nữa, nhưng mình không làm gì có lỗi với nàng cả, giờ phải tiếp tục học thôi.

Trigger:

1. what is trigger?

Trigger is special store procedure can execute either on a data modification,
known as a Data Modification Language (DML) trigger, or can execute on a data model action, such as CREATE TABLE, known as a Data Definition Language (DDL) trigger.

DML triggers are pieces of code attached to a specific table that are set to automatically run in response to an INSERT, DELETE, or UPDATE command.
DDL trigger is attached either to an action that occurs within a database or within a server.

2. DML Trigger:

Triggers have many uses. Perhaps the most common for a DML trigger is to enforce a business rule.

For example, when a customer places an order, check that they have sufficient funds or that you have enough stock; if any of these checks fail, you can complete further actions or return error messages and roll back the update.

DML triggers can be used as a form of extra validation,

for example, to perform quite complex checks on data that a constraint could not achieve.

DML trigger is to make changes in another table based on what is about to happen within the original triggered table.

For example, when you add an order, you would create a DML trigger that would reduce the number of that item in stock.

Finally, DML triggers can be used to create an automated audit trail that generates a change history for each record.

3. Notes:

Triggers can update tables within other databases if desired, and it is also possible for triggers to span servers as well, so don’t think the scope of triggers is limited to the current database.

It is possible for a trigger to fire a data modification, which in turn will execute another trigger, which is known as a nested trigger.

4. constraint and trigger:

Constraints also give you better performance than triggers. However, they are limited in what they can achieve and what information
is available to them to complete their job.
Triggers are similar to constraints but more powerful, and they require more system overhead, which can lead to a reduction in performance.
A constraint is only able to validate data that is within the table the constraint is being built for or a specified value entered at design time.
This is in contrast to a trigger, which can span databases, or even servers, and check against any data set at design time or built from data collected from other actions against any table. This can happen if the necessary access rights are given to all objects involved.

referrent:

Apress.Beginning.SQL.Server.2005.for.Developers.From.Novice.to.Professional.Jan.2006.pdf

Crystal report là gì?

phamvis — Thu, 08 Oct 2009 10:44:44 +0000

sau gần 3h đồng hồ tìm kiếm vẫn chưa định nghĩa nó là gì và dùng để làm gì nữa?

chắc là 1 dạng biểu mẫu để lấy cơ sở dữ liệu fill in và có thể export ra word hay excel, chắc là vậy.!

06.10.09

phamvis — Tue, 06 Oct 2009 10:44:07 +0000

Nói vậy mà đến 3 ngày mới viết lại log.

Phần đấu đạt SW:

Các bứoc tiến hành xây dựng phần mềm:

Phân tích yêu cầu người dùng và xác định nhu cầu của hệ thống.
Thiết kế hệ thống.
Thiếy kế thành phần.
Thiết kế chi tiết.
Viết và thực hiện chương trình.
Cài đặt.

Các yêu cầu của Thiết kế thành phần phần mềm:

Các nhóm thành phần đáp ứng yêu cầu chức năng hệ thống.

Kiến thức cần:

kỹ thuật thiết kế phần mềm.
nền tảng dùng được.
thiết kế có cấu trúc.
thiết kế hướng đối tượng.
cấu hình hệ thống.

Năng lực:

hiểu được hệ thống.
thiết kế giao diên giữa các thành phần nhất quán.
thực hiện tiêu chuẩn chất lượng.
tính đến các chức năng mở rộng, độ tin cậy, linh hoạt