Encapsulation
class Hello{
private int a;
public void setA(int a)
{
this.a=a;
//a=b; //if you write int b then it is appicable
}
public int getA()
{
return a;
}
}
public class Encapsulation //features :
//1.Data Hiding
//2.Flexibility
//3.Reusability
//4.Testing code
{
public static void main(String []args)
{
Hello m = new Hello();
m.setA(10);
System.out.println("Number is : "+m.getA());
}
}
Inheritance
import java.lang.*;
//Inheritance
//1.Super Class:The class whose features are inherited
//2.Sub Class: The class that inherits the other class
//3.Reusability
class Hello{
protected static int num = 0;
public final int num2 = 5;
}
class Inheritance extends Hello {
public void Hi(){
System.out.println(num);
System.out.println(num2);
}
public static void main (String [] args)
{
Inheritance obj = new Inheritance();
obj.Hi();
}
}
//Single Inheritance: one super class,one sub class
//Multilevel Inheritance:One super class will be extended by many sub class
//Hierarchical Inheritance: One super class,Many sub class
//Multiple Inheritance:One class has many super classes
//Hybrid Inheritance: Combination of single and multiple inheritance\\
//Rules:
//Multiple,Cyclic Inheritance is not permitted in java
//Private members do not get inherited
//Constructors can't be Inherited in java
//child can access parent class,parent can't access child class
//Constructors get executed beacause of super() present in the constructor
Polymorphism
/* ---------------Method Overloading-------------------
1.Methods must be same
2.Method name must be same
3.Method parameter must be different
4.Method return type may or may not be same
----------------Method Overriding-----------------
1.Must be inheritance between two classes
2.Method name must be same
3.Method parameter must be same
4.Method return type must be same
--------Constructor Overloading-------------------
1.Constructor must be of same class.
2.Constructor parameter must be different
*/
class {
public void addition(int a, int b)
{
int sum = a+b;
System.out.println(sum);
//return sum;
}
}
class Hey //method overloading
{
public void addition(double a,double b)
{
double result = a*b;
System.out.println(result);
}
}
class Hello extends Hi //method overriding
{
public void addition(int a,int b){
int sum = a-b;
//return sum;
System.out.println(sum);
}
}
public class polymorphism{
public static void main (String [] args)
{
Hello obj = new Hello();
obj.addition(4,5);
Hi scp = new Hi();
scp.addition(5,4);
Hey sc = new Hey();
sc.addition(4.5,6.5);
}
}
Abstraction
/* Rules
1.We can use object reference but we can't
create object of an abstract class.
2.Can't call constructors using new keyword but
super().this() used to call constructors.
3.An abstract class must have child class.
4.At least one regular class will inherit the
abstruct class one way or another.
5.Abstract method should be on abstract class. */
abstract class Hi{
abstract void Start();
}
class Hello extends Hi{
void Start(){
System.out.println("Hello");
}
}
class Hey extends Hello
{
void Start(){
System.out.println("Hey");
}
}
class Abstraction
{
public static void main(String [] args)
{
Hello C = new Hello();
C.Start();
Hey B = new Hey();
B.Start();
}
}
Interface
/* Rules:
1.Can take object reference
2.deafult public
3.No constructors
4.methods by default public and abstract
5.if you want to give body to any method
as interface,declare the method as static */
interface I1
{
void show();
int a= 100;
public static final int a1 =100;
}
class Interface implements I1
{
public void show()
{
System.out.println("Hello");
}
public static void main(String [] args)
{
Interface P = new Interface();
P.show();
}
}
Association
import java.util.*;
class CityClass {
private String cityName;
public String getCityName() {
return cityName;
}
public void setCityName(String cityName) {
this.cityName = cityName;
}
@Override
public String toString() {
return cityName;
}
}
class State {
private String stateName;
List<CityClass> citys;
public String getStateName() {
return stateName;
}
public void setStateName(String stateName) {
this.stateName = stateName;
}
public List<CityClass> getCities() {
return citys;
}
public void setState(List<CityClass> citys) {
this.citys = citys;
}
}
public class AssociationExample {
public static void main(String[] args) {
State state = new State();
state.setStateName("California");
CityClass city = new CityClass();
city.setCityName("Los Angeles");
CityClass city2 = new CityClass();
city2.setCityName("San Diago");
List<CityClass> empList = new ArrayList<CityClass>();
empList.add(city);
empList.add(city2);
state.setState(empList);
/*association */ System.out.println(state.getCities()+" are cities in the state "+
state.getStateName());
}
}
File Read and Write
import java.io.*;
import java.util.Scanner;
public class fileio
{
public static void main (String [] args) throws Exception
{
Scanner sc = new Scanner(System.in);
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader bfr = new BufferedReader(isr);
String s = "";
String temp;
char choice = 'y';
File file = new File("Hello.txt");
file.createNewFile();
FileWriter writer = new FileWriter(file);
System.out.println("Write Something");
while(choice=='y')
{
temp = bfr.readLine();
s = s + temp + "\n";
System.out.println("More? y for yes and n for no ");
choice = sc.next().charAt(0);
}
writer.write(s);
writer.flush();
writer.close();
FileReader reader = new FileReader(file);
BufferedReader bf1 = new BufferedReader(reader);
String a = "";
while((temp=bf1.readLine())!=null)
{
a = a+temp+"\n";
}
System.out.println(a);
reader.close();
}
}
0 comments:
Post a Comment