Java ile Nesne-tabanlı Programlama

Süre: 5 gün

Bu kurs, nesne-tabanlı programlama kavramlarını öğretmek ve katılımcıları Java programlama dili temellerini anlayarak uygulayabilir bilgi düzeyine getirmek üzere tasarlanmış bir kurstur. Yoğun ve hızlı bir tempoda gerçekleşecek kurs,katılımcıların daha önce temel seviyede programlama deneyimine sahip olduklarını, ancak nesne-tabanlı programlama konusundaki deneyimlerinin sınırlı olduğunu veya bulunmadığını varsaymaktadır. Bu nedenle nesne-tabanlı teknolojiler ve Java ile bağlantısı konusunda kapsamlı bir içerik sunulmaktadır. Bu kurs, katılımcıları Java ile tanıştırmak amacıyla değil, orta-seviyede Java programlama becerisine hazırlama hedefi ile tasarlanmıştır. Bu nedenle kursun COBOL, C, C++ ve "mainframe" üzerinde program geliştiren bireylere de yararlı olacağı düşünülmektedir. Bu kursa katılan öğrenciler etkin ve doğru kodlama teknikleri kullanarak Java ile nesne-tabanlı program yazma becerisi kazanmış olarak kursu tamamlayacaklardır. Uygulamalı ve eğitmenle etkileşimli bir şekilde yürütülecek eğitimde katılımcılar:

• Java dilinin (JDK 1.5 ile) yalnızca temellerini değil, önemini, kullanım şekillerini, güçlü ve zayıf yönlerini,
• Java dilinin temellerini ve nesne-tabanlı programlamayla bağlantısını ve Nesne Modelini,
• Java dilinin "exception handling" ve "multi-threading" özelliklerini,
• Sınıf, "inheritance" ve "polymorphism" özelliklerini,
• Veri tabanı erişimi için JDBC API kullanmayı öğrenmiş olacaklar ve,
• AWT ve Swing kullanarak GUI geliştirebileceklerdir.

Kimler katılabilir? Bu kurs nesne-tabanlı programlama konusunda deneyimi olan ve olmayan tüm katılımcılara açık bir kurstur. Kurs, Java programlama dilini öğrenmek ve derhal uygulama seviyesinde beceri edinmek isteyenlerin yararlanacağı bir içerik ve formatta düzenlenmiştir. Katılımcıların algoritma kurma bilgisine sahip ve herhangi bir prosedürel programlama dilini (Pascal, PHP, Basic, C, vb.) temel seviyede kullanabildikleri varsayılmaktadır.

Kurs İçeriği (Trivera kurs kataloğu)

Session 1: Object Oriented Concepts in Java

Lesson: Conventional vs. Object Oriented Programming

• List the two features contained within an object.
• Name the OO component that provides the blueprint for creating object instances.
• Name the OO component that provides behaviors to an object.
• Name the term used to expose the capabilities of an object

• Provide one benefit of encapsulation.
• Name an example of where inheritance cannot be used in place of aggregation, and provide one clear example showing this to fail.
• List two reasons for using inheritance.
• Give one example of a benefit of using polymorphism.

• Understand what Java is
• Understand the role of the JVM
• Understand the development steps
• Which Tools to use
• Understand how to setup your (development) environment

• Use the command line compiler to compile a Java class.
• Use the command line Java interpreter to run a Java application class.
• Correctly set up the CLASSPATH environment variable to allow the compiler and interpreter to run correctly.

• Write a class that does not explicitly extend another class.
• Define instance fields for a class.
• Implement a main method to create an instance of the defined class.

• Write a class with accessor methods to read and write private instance fields.
• Write a constructor to initialize an instance with data.
• Write a constructor that calls other constructors of the class to benefit from code reuse.
• Use the this keyword to distinguish local variables from instance fields.

• List the four arithmetic operators.
• List the three operators to increment and decrement numbers.
• List the six comparison operators.
• List the two logical operators.
• Name the return type of the comparison and logical operators.
• Use one of the increment operators to increment an integer.
• Write a for loop that can iterate a specified number of times.

• Create an instance of the String class.
• Test if two String objects are equal.
• Test if two String objects are the same object.
• Get the length of a String object.
• Parse a String object for its token components.
• Perform a case-insensitive equality test.
• Build up a String object using a StringBuffer object.
• Build up a String object using a StringBuilder object.
• Understand the difference between the StringBuffer and StringBuilder
• Convert between String and StringBuffer/StringBuilder.

• Convert String representations of primitive numbers into their corresponding wrapper.
• Convert String representations of primitive numbers into their primitive types.
• Appreciate auto unboxing a wrapper to its primitive type
• Use the Date class to get the current time and date.
• Use the Date class to determine if one Date is earlier or later than another.

• Declare an array reference.
• Allocate an array.
• Initialize the entries in an array.
• Appreciate the extended for-loop for iterating over an array

• Use the package keyword to define a class within a specific package.
• Explain the effects of the four levels of accessibility.
• Use the import keyword to declare references to classes in a specific package.
• Use the standard type naming conventions when creating packages, classes, and methods.
• Correctly execute a Java application class that is defined in a package.

• Initialize instance fields to default values.
• Distinguish between instance fields and method variables within a method.
• Initialize method variables prior to use.
• Explain the difference between the terms field and variable.
• List the default values for instance fields of type String, int, double, and boolean.
• Name the keyword used to create constants in Java.

• Create static fields in a class.
• Explain one use of static fields.
• Create static methods in a class.
• Explain one benefit of static fields.
• Understand the concept of a static import
• Appreciate enums
• Explain the syntax used to reference static fields and methods.

• Construct a class that extends another class.
• Correctly implement equals and toString.
• Write constructors that pass initialization data to the parent constructor as appropriate.
• Use instanceof to verify the class type of an object reference.
• Override subclass methods and use the super keyword to leverage behaviors in the parent.
• Safely cast references to a more refined type.

• Write a subclass with a method that overrides a method in the superclass.
• Group objects by their common supertype.
• Utilize polymorphism by correctly invoking subclass method implementations through superclass references.
• Safely cast a supertype reference to a valid subtype reference.
• Use the final keyword on methods and classes to prevent overriding through subclassing.

• Define supertype contracts using interfaces.
• Define supertype contracts using abstract classes.
• Implement concrete classes using interfaces.
• Implement concrete classes using abstract classes.
• Explain one advantage of interfaces over abstract classes.
• Explain one advantage of abstract classes over interfaces.

• Understand what generics are
• Understand how te create generic classes
• Understand how te create generic methods
• Understand generic wildcards
• Understand how to use generics

• Define a try/catch block that allows methods that throw exceptions to be called.
• Correctly implement try/catch blocks for methods which throw multiple exceptions.
• Name the exception supertype which is not checked for by the compiler.
• Correctly implement a method which throws exceptions.
• Correctly override a method which throws exceptions.

• Understand how How to throw exceptions.
• Define your own application exceptions.
• Introduce the assert keyword

• Understand the different types of collections in the J2SE
• Understand the difference between collection interfaces and collection implementations
• For each collection type, understand it's usage.
• Use ArrayList to maintain a list of data elements.
• Use Iterator to search elements of a collection.
• Use methods of List to access sublists.
• Appreciate the extended for-loop for iterating over a collections
• Appreciate how generics ease the development of (type-safe) collection
• Sort and shuffle elements in a list.
• Create read-only collections from standard.
• Write a Comparator to provide custom sorting.
• Create your own collection class.

• Create and run a threaded class using both Thread and Runnable
• Explain one advantage of implementing Runnable over subclassing Thread
• Use thread synchronization to guarantee data integrity in a multithreaded application
• Use object synchronization to allow multiple threads to work cooperatively on a shared set of data

• Understand how to document your code
• Understand the different JavaDoc tags
• create HTML-based Java API documentation

• Introduce the different types of jar-files
• Create a jar-file
• Create a Jar-packed application

• Write a Java class that provides encapsulation according to the naming principles of JavaBeansT
• Write a Java class that can register for and receive events
• Write a Java class that can manage event listeners and send events to its listeners

• Create a window frame.
• Nest panels within a frame for better layout control.
• Create and display buttons in a panel.
• List two component attributes that are controlled by a layout manager.
• Set the layout manager for a container.
• Place components in a panel using BorderLayout, GridLayout, and FlowLayout.
• Name one advantage of each of the layout managers.
• Create panels with titles.

• Place text fields, text areas, and buttons in a graphical application
• Handle action events from a button.
• Write code within an event handler to manipulate the content of text fields and text areas.
• Place check boxes, radio buttons, and combo boxes in a graphical application.
• Create a combo box consisting of a list of string elements.
• Create radio buttons in a radio button group.
• Create a menu for a frame containing menu items, sub-menus, check boxes, and radio buttons.

• Use GridBagLayout to create forms with properly aligning and resizing labels, text fields, and text areas.
• Provide scroll bars for components.
• Add multiple components to a container, separated by splitter bars.
• Create tabbed panels that contain other components and containers.

• Read/Write byte data into a buffer
• Read/Write character data to a buffer
• Read/Write objects to a buffer

• Create a file in the file system
• Create a directory in the file system
• List the contents of a directory
• Read and write text to a file

• List two advantages of using resources instead of files
• Write code to use resources

• Connect to a database using JDBC.
• Execute a statement against a database that returns a ResultSet.
• Extract multiple rows of data from a ResultSet, where each column value is represented as a String.