JavaBasics.tex

\documentclass[11pt]{beamer}

% list of packages used
\usepackage[latin1]{inputenc}
\usepackage{amsmath}
\usepackage{amsfonts}
\usepackage{amssymb}
\usepackage{graphicx}
\usepackage{listings}

% Author details
\author{Vinay @EduTechLabs}
\title{Java Basics}

% configs

%%set theme 
\usetheme{JuanLesPins}

%%configure listings package for java
% Default fixed font does not support bold face
\DeclareFixedFont{\ttb}{T1}{txtt}{bx}{n}{8pt} % for bold
\DeclareFixedFont{\ttm}{T1}{txtt}{m}{n}{8pt}  % for normal

%custom colours
\definecolor{pblue}{rgb}{0.13,0.13,1}
\definecolor{pgreen}{rgb}{0,0.5,0}
\definecolor{pred}{rgb}{0.9,0,0}
\definecolor{pgrey}{rgb}{0.46,0.45,0.48}

\definecolor{javared}{rgb}{0.6,0,0} % for strings
\definecolor{javagreen}{rgb}{0.25,0.5,0.35} % comments
\definecolor{javapurple}{rgb}{0.5,0,0.35} % keywords
\definecolor{javadocblue}{rgb}{0.25,0.35,0.75} % javadoc

%configuring listings package to highlight java syntax
\newcommand\javastyle{\lstset{
language=Java,
basicstyle=\ttfamily,
keywordstyle=\color{javapurple}\bfseries,
stringstyle=\color{javared},
commentstyle=\color{javagreen},
morecomment=[s][\color{javadocblue}]{/**}{*/},
numbers=left,
numberstyle=\tiny\color{black},
stepnumber=1,
tabsize=4,
showspaces=false,
otherkeywords={this, class, enum},             % Add keywords here
%keywordstyle=\ttb\color{deepblue},
emph={MyClass,Pizza,className},          % Custom highlighting
emphstyle=\ttb\color{pred},    % Custom highlighting style
moredelim=[il][\textcolor{pgrey}]{$$}, %$$ %the double dollar to prevent texmaker from going crazy
%moredelim=[is][\textcolor{pgrey}]{\%\%}{\%\%}
%frame=tb,                         % Any extra options here
showstringspaces=false, 
}}

% java environment
\lstnewenvironment{java}[1][]
{
\javastyle
\lstset{#1}
}
{}

% java for external files
\newcommand\javaexternal[2][]{{
\javastyle
\lstinputlisting[#1]{#2}}}

% java for inline
\newcommand\javainline[1]{{\javastyle\lstinline!#1!}}

%%%%%%%%%%%% begin writing the actual document %%%%%%%%%%%%%%%%%
\begin{document}

\section{Welcome!}
%get the title page
\frame{\maketitle}
% welcome page 
\begin{frame}{Welcome to the course}
	\begin{center}
	 Welcome to \emph{\color{pblue}EduTechLab's} basic java Course.
	\end{center}
\end{frame}

%%%%%%%%%%%%%%% about java

\begin{frame}{About Java}
	\begin{enumerate}
	\item Java is this..
	\item Java is that...
	\end{enumerate}
	
	\huge Goto Wikipedia !!\\
	
	\normalsize Not going to happen !!
\end{frame}
%%%%%%%%%%%%%%%%%%%%

%START MAKING SLIDES FROM HERE ON

%%%%%%%%%%%%%%%%%%%%

\section{The Bare Basics}
\begin{frame}[containsverbatim]{Hello World}
\begin{java}
public class MyClass{
/* This will program print 
 * `Hello World' as the output
 */
	public static void main(String[]args){
		System.out.println("Hello World"); 
		// prints Hello World
	}
}
\end{java}
\end{frame}

\begin{frame}[containsverbatim]{Compile and run java program}
	\begin{flushleft}
	
	
		\item{Running a java program} \\
		\begin{java}
		javac HelloWorld.java
		java HelloWorld
		\end{java}
		\item{Note: navigate to java file location through terminal before executing above commands.}
	\end{flushleft}
	
\end{frame}

\begin{frame}[containsverbatim]{Java Comments}
\begin{java}
public class HelloWorld{

public static void main(String[]args){
  // an example of single line comment
  System.out.println("Hello World");
  /* Multi line comments 
   are given like this. */
  }
}
\end{java}
\end{frame}

\section{Classes}
\begin{frame}[containsverbatim]{Java Class Structure}
\begin{java}
public class ClassName{
  String name;      // instance variable
  static int count; // class variable

  public ClassName(String name){ // constructor
    this.name = name;  
  }

  void method1(){
    String address; // local variable
  }  
}
\end{java}

\end{frame}


\begin{frame}[containsverbatim]{Basic Class Syntax}
\begin{java}
public class Dog{
	String breed;
	int age;
	String color;

	void barking(){
	}

	void hungry(){
	}

	void sleeping(){
	}
}
\end{java}
\end{frame}

\subsection{Constructors}
\begin{frame}[containsverbatim]{Constructors}
\begin{java}
public class Person{

	String name;
	
	public Person(){
	}
	
	public Person(String name){
		this.name = name;
	}
}
\end{java}
\end{frame}

\begin{frame}[containsverbatim]{Java Constructor}
\begin{java}
public class Dog{
  String name;  
  
  public Dog(){
  }

  public Dog(String name){
  this.name = name;
  }
}
\end{java}


\begin{java}
Dog Bruno = new Dog();
Dog Bruno = new Dog("Bruno");
\end{java}

\end{frame}

\subsection{Getters and Setters}
\begin{frame}[containsverbatim]{Getters and Setters}
\begin{java}
public class Dog{
  private String name;  
  
  public Dog(){
  }
  public Dog(String name){
    this.name = name;
  }
  
  public String getName(){
    return this.name;  
  }
  public void setName(String name){
    this.name = name;
  }  
}
\end{java}
\end{frame}

\subsection{Classes - things to remember}
\begin{frame}[containsverbatim,allowframebreaks]{Things to remember while creating Classes}

\begin{enumerate}
\item One .java file can have multiple classes.
\item Only one class per .java file can be public.
\item All remaining classes must be non-public.
\item Name of the public class must be the name of .java class.
\item class declared in package must begin with the package identification line
\begin{java}
package com.example;
\end{java}


\item import statements must be written between package declaration and class definition
\begin{java}
package com.example;
import ...
public class Dog{
  ....
}
\end{java}
\end{enumerate}
\end{frame}

\subsection{Inheritance}
\begin{frame}[containsverbatim]{Inheretence -- IS -- A Relation}
\begin{java}
public class Animal{
	.....
}

  public class Mammal extends Animal{
  	.....
  }

    public class Dog extends Mammal{
    		.....
    }

  public class Reptile extends Animal{
  	.....
  }
\end{java}
\end{frame}


\begin{frame}[containsverbatim]{IS -- A vs HAS -- A Relation}
\begin{java}

public class Vehicle{
  ....
}

public class Engine{
  ....
}

public class Car extends Vehicle{//IS-A relation
  private Engine e;  //HAS-A relation
  ....
}
\end{java}
\end{frame}


\subsection{Singleton}
\begin{frame}[containsverbatim]{Singleton Class}
\begin{java}
public class SingletonClass{
private static SingletonClass instance = null;
	
	protected SingletonClass(){
		// Exists only to defeat instantiation.
	}
	public static SingletonClass getInstance(){
		if(instance == null){
			instance = new SingletonClass();
		}
		return instance;
	}
}
\end{java}
\end{frame}

\section{Objects}
\begin{frame}[containsverbatim]{Creating Objects}
\begin{java}
import package.name.Person;

public class PersonTest{

	public static void main(String[]args){
	
		// created the reference which 
		// will point to object
		Person ram;
		
		// assign an object to reference
		ram = new Person("Ram");
	}
}
\end{java}
\end{frame}

\section{Polymorphism}
\begin{frame}[containsverbatim]{Polymorphism}

\end{frame}


\section{Overloading}
\subsection{Method Overloading}
\begin{frame}[containsverbatim,allowframebreaks]{Method Overloading}

\end{frame}


\subsection{Constructor Overloading}
\begin{frame}[containsverbatim,allowframebreaks]{Constructor Overloading}

\end{frame}


\section{Java Collections}
\begin{frame}[containsverbatim,allowframebreaks]{Collections}

\end{frame}



\begin{frame}[containsverbatim,allowframebreaks]{Arraylist}

\end{frame}



\begin{frame}[containsverbatim,allowframebreaks]{Iterator}

\end{frame}

\section{Java Looping}
\begin{frame}[containsverbatim,allowframebreaks]{Loops}

\end{frame}



\begin{frame}[containsverbatim,allowframebreaks]{for loop}

\end{frame}



\begin{frame}[containsverbatim,allowframebreaks]{while loop}

\end{frame}



\begin{frame}[containsverbatim,allowframebreaks]{do while}
\huge \color{javared} Community frowns upon the use of this one !
\end{frame}



\begin{frame}[containsverbatim,allowframebreaks]{for loop iterator}

\end{frame}


\section{Typecasting}
\begin{frame}[containsverbatim,allowframebreaks]{typecasting}

\end{frame}



\begin{frame}[containsverbatim,allowframebreaks]{Access Modifiers -- Default, Public, Private, Protected}

\begin{enumerate}
\item \emph{Default} -- Visible to the package,  No modifiers are needed.
\item \emph{Private} -- Visible to the class only.
\item \emph{Public} -- Visible to the world.
\item \emph{Protected} -- Visible to the package and all subclasses.    
\end{enumerate}
\end{frame}


\section{Primitive Data Types}
\begin{frame}[containsverbatim,allowframebreaks]{Data Types}
\begin{enumerate}
\item Primitive Data Types
\begin{enumerate}
\item byte
\item short
\item int
\item long
\item float
\item double
\item boolean
\item char
\end{enumerate}
\item Object Data Types
\begin{enumerate}
\item Dog
\item Person ...
\end{enumerate}
\end{enumerate}
\end{frame}

\section{Enums}
\begin{frame}[containsverbatim]{Enum Example}
\begin{java}
class Pizza{
	enum PizzaSize{ SMALL, MEDUIM, LARGE }
	PizzaSize size;
}

public class PizzaTest{
	public static void main(String args[]){
		Pizza p =new Pizza();
		p.size =Pizza.PizzaSize.MEDUIM ;
	}
}
\end{java}
\end{frame}



%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% prashant 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{frame}[containsverbatim,allowframebreaks]{static, final, abstract}

\begin{java}

import java.io.*;

public class Employee{
// salary variable is a private static variable
private static double salary;
// DEPARTMENT is a constant
public static final String DEPARTMENT = "Development ";
public static void main(String args[]){
salary = 1000;
System.out.println(DEPARTMENT+"average salary:"+salary);
}
}
\end{java}

\begin{enumerate}
\item \emph{static modifier} -- used to create methods and variables which can be called without creating class object.
\item \emph{final modifier} -- used to finalize the implementations of classes, methods, and variables.
\item \emph{abstract modifier} -- for creating abstract classes and methods.
\item Java provides a number of non-access modifiers to achieve many other functionality.
\item The static modifier for creating class methods and variables 
\item The final modifier for finalizing the implementations of classes, methods, and variables.
\item The abstract modifier for creating abstract classes and methods.
\end{enumerate}

\end{frame}

\begin{frame}[containsverbatim]{try catch finally}
\begin{java}
try{
	....
	//Protected code
}catch(ExceptionName e1){
	....
	// code to handle exception
}finally{
	....
	//clean-up code
}
	
\end{java}
\end{frame}

\begin{frame}[containsverbatim,allowframebreaks]{if else}
\begin{java}
if(condition){
	....
	
}else if(condition){
	....
	
}else{
	....
}
\end{java}
\end{frame}


\begin{frame}[containsverbatim,allowframebreaks]{switch}

\begin{java}

switch(expression){
case value :
//Statements
break;//optional
case value :
//Statements
break;//optional
//You can have any number of case statements.
default://Optional
//Statements
}

\end{java}

\begin{enumerate}
\item The variable used in a switch statement can only be a byte, short, int, or char.
\item The value for a case must be the same data type as the variable in the switch and it must be a constant or a literal.
\item When the variable being switched on is equal to a case, the statements following that case will execute until a break statement is reached.
\item Not every case needs to contain a break. If no break appears, the flow of control will fall throughto subsequent cases until a break is reached.
\item The default
case can be used for performing a task when none of the cases is true. No break is needed in the default
case.
\end{enumerate}
\end{frame}


\begin{frame}[containsverbatim,allowframebreaks]{Interfaces}
\begin{java}
class InterfaceExampleTwo implements interfaceTwo {
 
    @Override
    public void methhod() {
        System.out.println(var);
    }
 }
 
interface interfaceTwo {
    public final int var = 9;
 
    public abstract void methhod();
}
\end{java}
\begin{enumerate}
\item All Interface methods are implicitly public and abstract.
\item Interfaces can declare only Constant. Instance variables are not allowed. It means all variables inside Interface must be public, static, final. 
\item Variables inside interface are implicitly public static final.
\item Interface methods can not be static, final.
\item Interface can extend one or more other interface. Note: Interface can only extend other interface.


\end{enumerate}

\end{frame}


\begin{frame}[containsverbatim,allowframebreaks]{utility functions -- parseint etc.}
\begin{java}
int i = Integer.parseInt("245");
float f = Float.parseFloat("245");
\end{java}

\end{frame}



\begin{frame}[containsverbatim,allowframebreaks]{threads}

\begin{java}
class MyThread extends Thread{
	public void run(){
		System.out.println("in MyThread");
	}
}
MyThread t = new MyThread();

class MyRunnable implements Runnable{
	Public void run(){
		System.out.println("in MyRunnable");
	}
}
MyRunnable r = new MyRunnable();
Thread t = new Thread(r);
\end{java}
\end{frame}



\begin{frame}[containsverbatim,allowframebreaks]{Inner class}
\begin{java}
class OuterClass {
	private int i = 9;
	public void createInner() {
		InnerClass i1 = new InnerClass();
		i1.getValue();
	}
	 
	// inner class declarataion
	class InnerClass {
		public void getValue(){
		System.out.println("value of i:" + i);
		}
	}
}


\end{java}

\begin{enumerate}
\item Inner classes are class within Class. Inner class instance has special relationship with Outer class.
\item Inner class can be accessed only through live instance of outer class.
\end{enumerate}
\end{frame}


\begin{frame}[containsverbatim,allowframebreaks]{scope}


\end{frame}


\begin{frame}[containsverbatim,allowframebreaks]{packages}

\end{frame}


\begin{frame}[containsverbatim,allowframebreaks]{HashMap}

\end{frame}


\begin{frame}[containsverbatim,allowframebreaks]{stack memory}

\end{frame}


\begin{frame}[containsverbatim,allowframebreaks]{static memory}

\end{frame}


\begin{frame}[containsverbatim,allowframebreaks]{heap memory -- object location}

\end{frame}


\begin{frame}[containsverbatim,allowframebreaks]{Array of Objects}
\begin{java}
//Single Dimensional Array of Primitives
		int[] arr;  //recommended
		int arr[];
		int[][] arr; //Multi Dimensional Array  
		int arr[][];
		int[] arr[];Array Of Objects
//Single Dimensional Array Of Objects
        String[] arr; //recommened
        String arr[];
 		String[][] arr; //Multi Dimensional Array
        String arr[][];
        String[] arr[];
\end{java}
\begin{enumerate}
\item Arrays are a data structure type which is used to store multiple variables of the same type.
\item Once arrays created and space assigned to it next thing would be to add elements in it.Initialization of array is the place where we can do Adding Element in array. 
\item Size of the array means how much element an array can contains.
\item Arrays can hold Primitives as well as Object,array will always be an Object in Heap.
\end{enumerate}
\end{enumerate}
\end{frame}




\end{document}