Java 5일차 Vector 테스트3

/* 회원관리 프로그램 (회원정보 입력, 검색, 수정, 삭제, 프로그램 종료 기능) */

Member.java

public class Member
{
String name;
String sex;
int age;
String phone;
String email;

public Member(String name, String sex, int age, String phone, String email)
{
this.name = name;
this.sex = sex;
this.age = age;
this.phone = phone;
this.email = email;
}

public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public String getSex()
{
return sex;
}
public void setSex(String sex)
{
this.sex = sex;
}
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age = age;
}
public String getPhone()
{
return phone;
}
public void setPhone(String phone)
{
this.phone = phone;
}
public String getEmail()
{
return email;
}
public void setEmail(String email)
{
this.email = email;
}
}


VectorTest3.java

import java.util.Scanner;
import java.util.Vector;

public class VectorTest3
{
public static void main(String args[])
{
Vector<Member> vm = new Vector<>();

while(true)
{
System.out.println("1.입력  2.검색  3.수정  4.삭제  5.종료");
Scanner sc = new Scanner(System.in);
int choice = sc.nextInt();

if(choice==1)
{
System.out.print("name : ");
String name = sc.next();
System.out.print("sex : ");
String sex =  sc.next();
System.out.print("age : ");
int age = sc.nextInt();
System.out.print("phone number : ");
String phone = sc.next();
System.out.print("email : ");
String email = sc.next();

vm.add( new Member(name, sex, age, phone, email) );

for(int i=0; i<vm.size(); i++)
System.out.println("member : "
+vm.get(i).getName()+" "
+vm.get(i).getSex()+" "
+vm.get(i).getAge()+" "
+vm.get(i).getPhone()+" "
+vm.get(i).getEmail());

}

else if(choice==2)
{
System.out.print("name : ");
String name = sc.next();

System.out.println(vm.size());

for(int i=0; i<vm.size(); i++)
{
System.out.println("Searching...");

if(name.equals(vm.get(i).getName()))
{

System.out.println(vm.get(i).getName()+" "
+vm.get(i).getSex()+" "
+vm.get(i).getAge()+" "
+vm.get(i).getPhone()+" "
+vm.get(i).getEmail());
break;
}
else
System.out.println("Not Exist!");
}
}

else if(choice==3)
{
System.out.print("name : ");
String name = sc.next();

for(int i=0; i<vm.size(); i++)
{
if(name.equals(vm.get(i).getName()))
{
int age;
String phone;
System.out.print("age : ");
age = sc.nextInt();
System.out.print("phone : ");
phone = sc.next();

vm.get(i).setAge(age);
vm.get(i).setPhone(phone);
}
else
System.out.println("Not Exist!");
}
}

else if(choice==4)
{
System.out.print("name : ");
String name = sc.next();

for(int i=0; i<vm.size(); i++)
{
if(name.equals(vm.get(i).getName()))
{
System.out.println("Deleting...");
vm.remove(i);
}
}
}

else if(choice==5)
{
System.out.println("Shutdown");
break;
}
}
}
}

Java 5일차 Vector 테스트2

/* Integer Vector 값을 정렬 */

import java.util.Collections;
import java.util.Vector;

public class VectorTest
{
public static void main(String args[])
{
Vector<Integer> v = new Vector<>();

v.add(3);
v.add(4);
v.add(1);
v.add(2);

int tmp;
for(int i=0; i<v.size()-1; i++)
for(int j=1+i; j<v.size(); j++)
if(v.get(i) > v.get(j))
{
tmp = v.get(i);
v.set(i, v.get(j));
v.set(j, tmp);
}

for(int i=0; i<v.size(); i++)
System.out.println(v.get(i));
}
}

Java 5일차 Vector 테스트

/* Vector 값을 Collections.sort 메소드를 이용한 정렬 */

import java.util.Collections;
import java.util.Vector;

public class VectorTest
{
public static void main(String args[])
{
Vector<String> v = new Vector<>();

v.add("Tony");
v.add("Carmen");
v.add("Kim");
v.add("Harumi");

Collections.sort(v);

for(int i=0; i<v.size(); i++)
System.out.println(v.get(i));
}
}

Java 5일차 HashSet 테스트2

/* HashSet을 이용한 로또 랜덤번호 생성 */

import java.util.HashSet;
import java.util.Iterator;

public class HashSetTest
{
public static void main(String args[])
{
HashSet<Integer> h = new HashSet<>();

while(h.size()<6)
{
int i = (int)(Math.random()*45+1);

h.add(i);
}

Iterator<Integer> it = h.iterator();
while(it.hasNext())
System.out.print(it.next()+" ");
}
}

Java 5일차 HashSet 테스트

import java.util.HashSet;
import java.util.Iterator;

public class SetTest
{
public static void main(String args[])
{
HashSet<String> h = new HashSet<>();

h.add("Tony");
h.add("Carmen");
h.add("Roberto");
h.add("Kim");
h.add("Harumi");

Iterator<String> it = h.iterator();

while(it.hasNext())
System.out.println(it.next());
}
}

Java 5일차 HashTable 테스트(+Enumeration)

import java.util.Hashtable;
import java.util.Enumeration;

public class HashTableTest
{
public static void main(String[] args)
{
Hashtable<Integer, String> hash1 = new Hashtable<>();

hash1.put(0, "Tony");
hash1.put(1, "Carmen");
hash1.put(2, "Roberto");
hash1.put(3, "Kim");
hash1.put(4, "Harumi");

Enumeration<String> e = hash1.elements();

for(; e.hasMoreElements();)
System.out.println(e.nextElement());
  // while(e.hasMoreElements())
   // System.out.println(e.nextElement());
}
}

Java 5일차 Hashtable 테스트

import java.util.Hashtable;

public class HashTableTest
{
public static void main(String[] args)
{
Hashtable<Integer, String> hash1 = new Hashtable<>();

hash1.put(0, "Tony");
hash1.put(1, "Carmen");
hash1.put(2, "Roberto");
hash1.put(3, "Kim");
hash1.put(4, "Harumi");

for(int i=0; i<hash1.size(); i++)
System.out.println(hash1.get(i));

Hashtable<String, String> hash2 = new Hashtable<>();
hash2.put("0", "Nick");
hash2.put("1", "Coco");

for(int i=0; i<hash2.size(); i++)
System.out.println(hash2.get(i+""));
}
}

Java 5일차 String 테스트3

/* 정수를 가진 문자열을 정수형으로 바꾸기 */

public class StringTest3
{
public static void main(String args[])
{
String str = "100";

System.out.println(str+50);

int i = Integer.parseInt(str);

System.out.println(i+50);
}
}

Java 5일차 String 테스트2

/* String 클래스 안의 가장 많은 단어와 그 빈도수 세기 */

import java.util.Scanner;

public class StringTest2
{
public static void main(String[] args)
{
String lyrics = "Yellow diamonds in the light"+
"And we're standing side by side"+
"As your shadow crosses mine"+
"What it takes to come alive"+

"It's the way I'm feeling I just can't deny"+
"But I've gotta let it go"+

"We found love in a hopeless place"+
"We found love in a hopeless place"+
"We found love in a hopeless place"+
"We found love in a hopeless place"+

"Shine a light through an open door"+
"Love and life I will divide"+
"Turn away cause I need you more"+
"Feel the heartbeat in my mind"+

"It's the way I'm feeling I just can't deny";

String[] result = lyrics.split(" ");
int count_max=0, word_index=0;

for(int i=0; i<result.length; i++)
{
int count = 0;
for(int j=0; j<result.length; j++)
{
if(result[i].equals(result[j]))
count++;
}
if(count_max < count)
{
count_max = count;
word_index = i;
}
}

System.out.println(result[word_index]+" "+count_max);
}
}

Java #2-3 자바 기본 프로그래밍 - 자바에서 키 입력

System.in

System.in은 키보드 장치와 연결된 로우 레벨 입력 스트림 객체이다. 입력되는 키 값을 바이트 정보로 반환하여 바이트 정보를 문자 정보로 변환해야 어떤 문자가 입력되었는지 판단할 수 있다.

ex)
import java.io.*; // InputSreamReader의 사용을 위한 임포트문

public class InputExample {
public static void main(String args[])
{
InputStreamReader rd = new InputStreamReader(System.in);
try
{
while(true)
{
int a = rd.read();
if(a == -1) // -1은 ctrl+z 를 의미
break;
System.out.print((char)a);
}
}
catch(IOException e)
{
System.out.println("입력 오류");
}
}
}

result)

Scanner

Scanner는 사용자가 입력하는 값을 공백('\t', '\f', '\r', ' ', '\n')으로 구분하고 읽는다.

ex)
import java.util.Scanner;

public class ScannerExam {
public static void main(String args[])
{
Scanner a = new Scanner(System.in);
System.out.println("input age, weight, height.");

System.out.println("age : "+a.nextInt());
System.out.println("weight : "+a.nextDouble()+" kg");
System.out.println("height : "+a.nextDouble()+" cm");
}
}

result)

Java 5일차 String 테스트

import java.util.Scanner;

public class StringTest
{
public static void main(String[] args)
{
String a = "StringTest.java";
String b = "StringTest.java";

String c = new String("SringTest.java"); // heap memory

if(a==b) System.out.println("true");
else System.out.println("false");

if(a.equals(c)) System.out.println("true");
else System.out.println("false");

Scanner d = new Scanner(System.in);
String e = d.next();

if(e.matches(".*@.*")) System.out.println("true");
else System.out.println("false");
}
}

Java 5일차 Java APIs

Java API
자바를 설치하면 자바 개발 도구인 JDK(Java Development Kit)가 설치 되며 이곳에는 오라클에서 제공하는 많은 클래스들을 패키지로 묶어 개발자에게 제공한다. 자바에서 제공하는 기본 패키지를 자바 API라고 한다.


현재 최신 Java APIs (2013-06-28 기준, JAVA SE 7)
http://docs.oracle.com/javase/7/docs/api/


한글 Java APIs
http://xrath.com/javase/ko/6/docs/ko/api/index.html


Java APIs Tutorial
http://www.java2s.com/Tutorial/Java/CatalogJava.htm

Java #2-2 자바 기본 프로그래밍 - 데이터 타입

데이터 타입

기본 타입
boolean (1byte)
char (2byte)
byte (1byte)
short (2byte)
int (4byte)
long (8byte)
float (4byte)
double (8byte)

byte < short/char < int < long < float < double

레퍼런스 타입
배열에 대한 레퍼런스, 클래스(class)에 대한 레퍼런스, 인터페이스(interface에 대한 레퍼런스

자동 타입 변환
한 타입의 데이터를 다른 데이터 타입으로 변환하는 것으로 개발자가 명시적으로 지정하지 않아도 자동적으로 이루어지는 변환이다. 작은 데이터 타입에서 큰 데이터 타입으로 타입 변환을 하면 원본 데이터의 손실 없이 그대로 보존 되기 때문에 자동 타입 변환이 일어난다.

ex)
  long var;
  int n = 32555;
  byte b = 25;
  var = n; // var = 32555
  var = b; // var = 25

강제 타입 변환
데이터 타입을 바꿀 때 데이터의 손실이 발생할 수도 있으므로 자동으로 타입 변환이 일어나지 않으며 개발자가 명시적으로 타입 변환을 지정해야 변환이 이루어진다.

ex)
  short var;
  int n = 855638017;
  var = (short) n; // int 타입에서 short 타입으로 강제 변환, var = 1

  double d = 1.9;
  n = (int) d; // n = 1;

Java #2-1 자바 기본 프로그래밍 - 식별자

식별자(identifier)

클래스, 변수, 상수, 메소드 등에 붙이는 이름

규칙
특수문자(%, *, &, @, ^ 등), 공백(탭, 스페이스 등)은 식별자로 사용할 수 없느나 '_', '$'는 사용할 수 있고 한글 또한 가능하다.
식별자의 첫 문자에 숫자를 사용할 수 없다.
대소문자를 구별하고 길이 제한이 없다.
자바 언어의 키워드는 사용할 수 없다.

자바 키워드
abstract
assert
boolean
break
byte
case
catch
char
class
const
continue
default
do
double
else
enum
extends
final
finally
float
for
goto
if
implements
import
instanceof
int
interface
long
native
new
package
private
protected
public
return
short
static
strictfp
super
switch
synchronized
this
throw
throws
transient
try
void
volatile
while

Java 4일차 Interface

Interface

class와 유사하지만 class는 아니다.

interface를 구현하여 다중 상속과 유사한 효과를 얻는다.

interface의 모든 변수는 public, 모든 메소드는 public abstract로 선언되어야 하고, 별도의 선언이 없다면 자동으로 선언된다.

class처럼 interface도 Reference type으로 사용가능하다.

interface는 자체적으로 객체가 될 수 없다.

interface는 다른 interface를 구현/ 상속 받을 수 있다. 그러나 class는 상속받을 수 없다.

ex) interfaceA extends interfaceB{} - O

 interfaceA extends classA{} - X

 class classA implements interfaceB{} - O

 class classA implements interfaceB, interfaceC, ... {} - O

 class classA extends classB implements interfaceC, ... {} - O

Java 4일차 Interface 테스트

interface InterfaceTest00
{
abstract void interfaceTest00();
}

interface InterfaceTest01 extends InterfaceTest00
{
public int i = 767;
public int k = 999;
public void interfaceTest01(int i, int k);
}

interface InterfaceTest02
{
int j =747;
public int privateInt = 8;
public void interfaceTest02(int j);
}

class SuperClass
{
String superStr = "Super";
String superMethod()
{
System.out.println("SuperClass.SuperMethod()");
return "returnString";
}
}

class SubClassTest01 extends SuperClass implements InterfaceTest01
{
public void interfaceTest00()
{
}

public void interfaceTest01(int i, int k)
{
}

}

abstract class SubClassTest02 extends SuperClass implements InterfaceTest01, InterfaceTest02
{
}

class SubClassTest03 extends SuperClass implements InterfaceTest01, InterfaceTest02
{
public void interfaceTest00()
{

}

public void interfaceTest02(int j)
{
}

public void interfaceTest01(int i, int k)
{

}
}

class SubClassTest04 extends SubClassTest02
{
//여기에 필요한 것들을 추가하여 문제를 해결하세요..
SubClassTest04()
{
System.out.println("subClassTest04() 객체 생성");
System.out.println(" i = "+i);
System.out.println(" j = "+j);
}

SubClassTest04(String s1, String s2)
{
System.out.println(s1+" 타입 "+"subClassTest04("+s2+") 객체 생성");
}

public void printSuperString()
{
// InterfaceTest01 ie01 = new InterfaceTest01();
System.out.println(" superString = "+superStr);
}

public void interfaceTest01(int i, int k)
{
System.out.println("SubClassTest04.interfaceTest00()");
}

public void interfaceTest00()
{
}

public void interfaceTest02(int j)
{
}

}


public class InterfaceTest
{
public static void main(String args[])
 {
SubClassTest02 sub02sub04 = new SubClassTest04("SubClassTest02", "sub02sub04");
SuperClass superSub04 = new SubClassTest04("SuperClassTest", "superSub04");
InterfaceTest01 if01Sub04 = new SubClassTest04("InterfaceTest01", "ifc01Sub04");
SubClassTest04 sub04 = new SubClassTest04();
sub04.interfaceTest00();
sub04.interfaceTest01(1, 7);
sub04.superMethod();
}
}

Java 4일차 static, final, abstract

static

static variable 

하나의 클래스에서 만들어진 모든 객체가 공유하는 변수

public, private 모두 선언 가능

public으로 선언되었을 때는 class의 외부에서 객체 생성없이 접근 가능.

static method

객체를 생성하지 않고 접근 가능.

static method내에서는 this사용 불가.

static method내에서는 static변수만 접근 가능.

final

Modifier(변수, 메소드, 클래스) 앞에 온다.

변수, 메소드, 클래스는 상속된 클래스에서 변경 불가능하다

abstract

선언부만 있고 구현부가 없다.

하위 클래스에서 Overrding을 하기 위해 존재한다.

일반적으로 public으로 선언한다.

abstract class

추상클래스, abstract 키워드로 선언.

abstract class는 객체를 생성할 수 없다.

다른 클래스의 super class가 되기 위해 존재한다.

abstract method를 하나라도 갖는 클래스는 abstract class로 선언해야 한다.

Java 4일차 Abstract 활용 테스트(+final)

final class FinalClass
{
final int i = -999999;
}

abstract class AbstractClass
{
abstract String abstractMethod(int i, String s);
int finalMethod(int i, int j)
{
return i+j;
}
}

class Sample01 extends AbstractClass
{
String abstractMethod(int i, String s)
{
System.out.println("return "+s+i);
return s+i;
}

int finalMethod(int i, int j)
{
return i*j;
}
}

class Sample03 extends AbstractClass
{
String abstractMethod(int i, String s)
{
System.out.println("return "+s+", "+i);
return s+", "+i;
}

void sampleMethod03()
{
System.out.println("void sampleMethod03() 호출 됨");
}
}

public class AbstractTest
{
public static void main(String args[])
{
// AbstractClass ac = new AbstractClass();
FinalClass fc = new FinalClass();
// fc.i = 100000;
Sample01 s01 = new Sample01();
AbstractClass acS01 = new Sample01();
AbstractClass acS03 = new Sample03();

System.out.println(s01.finalMethod(50, 100));

acS01.abstractMethod(700, "999");
acS03.abstractMethod(700, "999");
}
}

Java 4일차 Static 활용 테스트

public class StaticTest
{
int normalNum = 10;
static int staticNum = 20;

public static void main(String[] args)
{
StaticTest st1 = new StaticTest();
StaticTest st2 = new StaticTest();

System.out.println(st1.normalNum);
System.out.println(st1.staticNum);
st1.normalNum = 30;
System.out.println(st1.normalNum);
st2.normalNum = 40;
System.out.println(st2.normalNum);
st1.staticNum = 50;
System.out.println(st2.staticNum);
}
}

Java 4일차 ObjectCasting 테스트2

package car;
//예상결과를 작성하고 Run-time Error!를 수정하세요.

public class ObjectCastingTest{
public static void main(String args []){
Car car = new Car();
System.out.println("car.Carname="+car.carname+"\n");

Jeep j = new Jeep();
System.out.println("j.carname="+j.carname);
Car carTypej = new Jeep();
System.out.println("carTypej.carname="+carTypej.carname);
System.out.println("carTypej intanceof Jeep = "+(carTypej instanceof Jeep));
Jeep JeepFromCarTypeJeep = (Jeep)carTypej;
System.out.println("JeepFromCarTypeJeep.carname="+JeepFromCarTypeJeep.carname+"\n");
System.out.println("JeepFromCarTypeJeep intanceof Jeep="+(JeepFromCarTypeJeep instanceof Jeep));
// Jeep car2j = (Jeep)car;
// System.out.println("car2j instanceof Jeep = "+(car2j instanceof Jeep));

BMW b = new BMW();
System.out.println("b.carName="+b.carname);
Car carTypeBMW = new BMW();
System.out.println("carTypeBMW.carName="+carTypeBMW.carname);
System.out.println("carTypeBMW instanceof BMW = "+(carTypeBMW instanceof BMW));
BMW BMWFromCarTypeBMW = (BMW)carTypeBMW;
System.out.println("BMWFromCarTypeBMW.carname="+BMWFromCarTypeBMW.carname+"\n");
System.out.println("BMWFromCarTypeBMW instanceof BMW = "+(BMWFromCarTypeBMW instanceof BMW));
// BMW car2b = (BMW)car;
// System.out.println("car2b instanceof BMW = "+(car2b instanceof BMW));

Volkswagen v = new Volkswagen();
System.out.println("ca.carname="+v.carname);
Car carTypeVolkswagen = new Volkswagen();
System.out.println("carTypeCanival.carname="+carTypeVolkswagen.carname);
System.out.println("carTypeCanival instanceof Canival = "+(carTypeVolkswagen instanceof Volkswagen));
Volkswagen VolkswagenFromCarTypeVolkswagen=(Volkswagen)carTypeVolkswagen;
System.out.println("canivalFromCarTypeCanival.carname="+VolkswagenFromCarTypeVolkswagen.carname);
System.out.println("canivalFromCarTypeCanival instanceof Volkswagen="+(VolkswagenFromCarTypeVolkswagen instanceof Volkswagen));
// Volkswagen car2ca = (Volkswagen)car;
// System.out.println("car2ca instanceof Canival = "+(car2ca instanceof Volkswagen));
}
}

Java #1 자바 시작

compile

컴퓨터는 기계어를 이해할 수 있다. C나 Java같은 고급 언어로 작성된 프로그램은 컴퓨터가 이해할 수 없으므로 프로그램을 기계어로 변환하는 과정이 필요하다. 이를 컴파일(compile)이라 하고, 그런 과정을 처리하는 소프트웨어를 컴파일러(compiler)라고 한다. 각 언어마다 고유한 컴파일러가 있어, C 컴파일러로는 Java 프로그램을 컴파일할 수 없다.

Java와 C/C++ 실행환경 및 실행과정 차이

Java

링크과정없이 컴파일러가 바로 바이트 코드 생성

바이트 코드는 JVM에서만 실행이 가능

런타임에 필요한 클래스들이 JVM에 의해 링크되며 클래스 로더가 동적으로 필요한 클래스를 로딩

ClassLoader 객체를 이용하여 프로그래머가 직접 클래스를 로딩 가능

C/C++

컴파일러가 중간단계인 오브젝트 코드를 생성한 후 링커가 필요한 라이브러리들을 링크하여 최종 실행이 가능한 실행 파일을 생성

정적 라이브러리의 경우 라이브러리를 실행 파일에 포함시키므로 실행 파일 크기가 커짐

동적 라이브러리의 경우 런타임에 링크

오브젝트 코드 및 실행 파일은 플랫폼에 따라 다르므로 플랫폼이 바뀌면 컴파일 및 링크를 새로 해야함

Java 배포판의 종류

Java SE(Standard Edition) - 자바 표준 배포판, 데스트톱 응용프로그램과 서버 응용프로그램의 개발 플랫 폼이다.

Java ME(Micro Edition) - 모바일용 배포판, SE의 축소판이며 임베디드 및 가전제품을 위한 API가 정의되어 있다.

Java EE(Enterprise Editon) - 기업용 배포판, SE를 기본으로 인터넷 기반의 서버사이드 컴퓨팅 관련 API가 추가 되어있다.

Java의 특징

객체지향

자바는 객체지향 언어로서 클래스 계층구조, 상속성, 다형성, 캘슐화 등을 지원한다. 객체 지향 프로그램은 해결할 과제를 실제 세상의 객체와 객체 간의 상호 관계로 모델링하여 인간의 사고에 가깝게 표현한다.

멀티스레드

자바는 하나의 프로그램에서 운영체제의 도움 없이 다수의 스레드가 동시에 실행할 수 있는 환경을 지원한다.

플랫폼 독립성

자바는 하드웨어, 운영체제 등 플랫폼에 종속되지 않는 독립적인 바이트 코드로 컴파일 되며 자바 가상 기계(JVM)만 있으면 하드웨어나 운영체제를 막론하고 자바 프로그램의 실행이 가능하다.

소스와 클래스 파일

하나의 자바 소스 파일에는 여러 개의 클래스를 작성할 수 있지만, 하나의 클래스 파일(.class)에는 반드시 하나의 컴파일된 자바 클래스만이 포함된다. 하나의 자바 소스 파일에 작성된 클래스 중 오직 한 클래스만 public으로 선언할 수 있다. 파일 내 public으로 선언된 클래스의 이름과 소스 파일의 이름이 동일하게 작성되어야 한다.

실행모듈

자바 응용프로그램은 한 개 이상의 클래스 파일로 구성된다. 다수의 클래스 파일을 jar 파일 형태로 압축하여 배포 및 실행이 가능하다. 실행은 항상 main 메소드에서 시작된다. 하나의 클래스 파일에 하나 이상의 main 메소드는 있을 수 없지만 다수의 클래스 파일이 각각 main 메소드를 갖는 것은 가능하다.

클래스로 캡슐화

클래스 내에 변수나 메소드를 구현함으로써 캡슐화가 가능하다. 클래스에 속하지 않은 변수나 메소드는 있을 수 없다. 클래스 안에 내부 클래스를 만드는 것은 가능하다.

패키지

자바의 독특한 개념으로 서로 관련있는 클래스를 패키지로 묶어 관리한다.

Java 4일차 ObjectCasting 테스트

public class ObjectCastingTest {}

class SubCastingTest extends ObjectCastingTest
{
public void test()
{
SubCastingTest sct = new SubCastingTest();
ObjectCastingTest oct = new SubCastingTest();

sct = (SubCastingTest)oct;
}
}

Java 4일차 Inheritance 테스트(+Polymorphism 개념, +instanceof)

InheritanceTest.java

package car;

class Car
{
public String carname;
public int cost;
}
//Car를 상속받는 3개 클래스 작성
//각 클래스에 인수를 받지않는 생성자 작성
//각 클래스의 생성자의 구현부에서 carname과 cost에 적당한 값 할당

class Jeep extends Car
{
Jeep()
{
carname = "Ranguler";
cost = 5000;
}
}

class BMW extends Car
{
BMW()
{
carname = "X3";
cost = 6000;
}
}

class Volkswagen extends Car
{
Volkswagen()
{
carname = "Tiguan";
cost = 4500;
}
}

public class InheritanceTest
{
//  main에서 각 네개의 객체를 생성
//  각 각체의 carname과 cost 출력
public static void main(String args[])
{
Car c = new Car();
Jeep j = new Jeep();
BMW b = new BMW();
Volkswagen v = new Volkswagen();

System.out.println(c.carname+", "+c.cost+"만원");
System.out.println(j.carname+", "+j.cost+"만원");
System.out.println(b.carname+", "+b.cost+"만원");
System.out.println(v.carname+", "+v.cost+"만원");
}
}

PolymorphismTest.java

package car;

class CarCenter
{
void engineer(Car car)
{
System.out.print("수리, ");
System.out.println("청구비용 "+car.cost/50);
}
}

public class PolymorphismTest
{
public static void main(String args[])
{
CarCenter cc = new CarCenter();

Jeep j = new Jeep();
BMW b = new BMW();
Volkswagen v = new Volkswagen();

cc.engineer(j);
cc.engineer(b);
cc.engineer(v);

Car c = new Car();

if(j instanceof Jeep) System.out.println("true");
else System.out.println("false");

if(j instanceof Car) System.out.println("true");
else System.out.println("false");
}
}

Java 4일차 Inheritance 테스트(+Polymorphism 개념)

InheritanceTest.java

package car;

class Car
{
public String carname;
public int cost;
}
//Car를 상속받는 3개 클래스 작성
//각 클래스에 인수를 받지않는 생성자 작성
//각 클래스의 생성자의 구현부에서 carname과 cost에 적당한 값 할당

class Jeep extends Car
{
Jeep()
{
carname = "Ranguler";
cost = 5000;
}
}

class BMW extends Car
{
BMW()
{
carname = "X3";
cost = 6000;
}
}

class Volkswagen extends Car
{
Volkswagen()
{
carname = "Tiguan";
cost = 4500;
}
}
public class InheritanceTest
{
//  main에서 각 네개의 객체를 생성
//  각 각체의 carname과 cost 출력
public static void main(String args[])
{
Car c = new Car();
Jeep j = new Jeep();
BMW b = new BMW();
Volkswagen v = new Volkswagen();

System.out.println(c.carname+", "+c.cost+"만원");
System.out.println(j.carname+", "+j.cost+"만원");
System.out.println(b.carname+", "+b.cost+"만원");
System.out.println(v.carname+", "+v.cost+"만원");
}
}

PolymorphismTest.java

package car;

class CarCenter
{
void engineer(Car car)
{
System.out.print("수리, ");
System.out.println("청구비용 "+car.cost/50);
}
}

public class PolymorphismTest
{
public static void main(String args[])
{
CarCenter cc = new CarCenter();

Jeep j = new Jeep();
BMW b = new BMW();
Volkswagen v = new Volkswagen();

cc.engineer(j);
cc.engineer(b);
cc.engineer(v);
}

}

Java 4일차 Inheritance 테스트

class Car
{
public String carname;
public int cost;
}
// Car를 상속받는 EfSonata, Excel, Canival 3개 클래스 작성
// 각 클래스에 인수를 받지않는 생성자 작성
// 각 클래스의 생성자의 구현부에서 carname과 cost에 적당한 값 할당

class Jeep extends Car
{
Jeep()
{
carname = "Ranguler";
cost = 5000;
}
}

class BMW extends Car
{
BMW()
{
carname = "X3";
cost = 6000;
}
}

class Volkswagen extends Car
{
Volkswagen()
{
carname = "Tiguan";
cost = 4500;
}
}

public class InheritanceTest
{
// main에서 각 네개의 객체를 생성
// 각 각체의 carname과 cost 출력
public static void main(String args[])
{
Car c = new Car();
Jeep j = new Jeep();
BMW b = new BMW();
Volkswagen v = new Volkswagen();

System.out.println(c.carname+", "+c.cost+"만원");
System.out.println(j.carname+", "+j.cost+"만원");
System.out.println(b.carname+", "+b.cost+"만원");
System.out.println(v.carname+", "+v.cost+"만원");
}
}

Java 4일차 SuperClass 테스트

public class SuperTest
{
String girlName = "Kim";
String boyName = "Nick";

public void girl()
{
System.out.println(girlName);
}

protected void boy1()
{
System.out.println(boyName);
}

private void boy2()
{
System.out.println(boyName);
}
}

class SubTest extends SuperTest
{
public void start()
{
System.out.println(girlName);
this.girl();

this.boy1();
// this.boy2();
}
}

Java 3일차 Constructor 테스트

class Puppy
{
String name;
int age;

//인수가 없는 생성자작성
//타입 전역변수에 "메리" 할당
public Puppy()
{
name = "메리";
}

//String 타입의 인수 1개를 받는 생성자작성
//String 타입 전역변수에 인수 할당
public Puppy(String str)
{
name = str;
}

//String 타입의 인수 2개를 받는 생성자작성
//인수2개를 하나의 String으로 만들어
//String 타입의 인수 1개를 받는 생성자에게 인수로 주며 호출
public Puppy(String str1, String str2)
{
this(str1+str2);
}

//boolean 타입의 인수 1개를 받는 생성자작성
//인수를 "쫑"과 붙여 하나의 String으로 만들어
//String 타입의 인수 1개를 받는 생성자에게 인수로 주며 호출
public Puppy(boolean bl)
{
this("쫑"+bl);
}

//char 타입의 인수 1개를 받는 생성자작성
//인수가 없는 생성자를 호출하고
//인수를 int타입으로 변환하여 전역변수에 할당
public Puppy(char ch)
{
this();
age = (int)ch;
}

//메소드 printMemberVariable
//리턴 없슴
//전역변수를 출력
public void printMemberVariable()
{
System.out.println(name+", "+age);
}
}

public class ConstructorTest{
public static void main(String args[])
{
//Puppy 클래스의 각 생성자를 한번씩 이용해 객체 5개 생성
//각 객체의 printMemberVariable메소드를 한번씩 호출
Puppy p1 = new Puppy();
Puppy p2 = new Puppy("퐁이");
Puppy p3 = new Puppy("아", "들");
Puppy p4 = new Puppy(true);
Puppy p5 = new Puppy(' ');

p1.printMemberVariable();
p2.printMemberVariable();
p3.printMemberVariable();
p4.printMemberVariable();
p5.printMemberVariable();

}
}

Java 3일차 MethodOverloading 테스트

class MethodOverloading{

//정수형 전역변수를 클래스 내부에서만 접근이 가능하도록 선언
private int a;

//메소드 setOverload
//정수형 인수 1개
//리턴 안함.
//전역변수에 인수를 할당
public void setOverload(int val)
{
a = val;
}

//메소드 getOverload
//정수형 인수 1개
//정수형 리턴
//적당한 문자열 출력
//전역변수와 인수를 더한 값을 리턴
public int getOverload(int val)
{
System.out.println("return +");
return a+val;
}

//메소드 getOverload
//실수형 인수 1개
//실수형 리턴
//적당한 문자열 출력
//전역변수와 인수를 곱한 값을 리턴
public float getOverload(float val)
{
System.out.println("return *");
return a*val;
}

//메소드 getOverload
//정수형 인수 1개, 실수형 인수 1개
//리턴 안함.
//인수 두개를 출력
public void getOverload(int val1, float val2)
{
System.out.println(val1+", "+val2);
}
}

public class MethodOverloadingTest{
//메인 메소드에서
//MethodOverloading객체 생성
public static void main(String args[]) {
MethodOverloading mod = new MethodOverloading();

//적당한 정수값 1개를 인수로 주며 MethodOverloading객체의 setOverload메소드 호출
mod.setOverload(10);

//적당한 정수값 1개를 인수로 주며 MethodOverloading객체의 getOverload메소드를 호출하고 리턴하는 값을 정수형 지역변수에 저장
int val1 = mod.getOverload(11);

//적당한 실수값 1개를 인수로 주며 MethodOverloading객체의 getOverload메소드를 호출하고 리턴하는 값을 실수형 지역변수에 저장
float val2 = mod.getOverload(10.5f);

//적당한 정수값 1개와 실수값 1개를 인수로 주며 //MethodOverloading객체의 getOverload메소드를 호출
mod.getOverload(val1, val2);

//정수형 지역변수와 실수형 지역변수를 출력
System.out.println(val1+", "+val2);
}
}

Java 3일차 Method 호출 테스트

class MethodInvoke01
{
//method 이름: method1
//어디서나 누구나 접근 가능
//정수 리턴
//인수로 정수 2개 받음
//인수로 들어온 정수 2개를 곱해서 출력하고 리턴
public int method1(int i, int j)
{
System.out.println(i*j);
return i*j;
}

}

class MethodInvoke02
{
//method 이름: method02
//어디서나 누구나 접근 가능, 객체를 생성하지 않고도 접근가능
//정수 리턴
//인수로 정수 2개 받음
//인수로 들어온 정수 2개를 더해서 출력하고 리턴
public static int method2(int i, int j)
{
System.out.println(i+j);
return i+j;
}
}

public class MethodTest
{
public static void main(String [ ] args) {
MethodInvoke01 invoke01 = new MethodInvoke01();

int i, j;

//여기에서 MethodInvoke01의 method01 호출
i = invoke01.method1(10, 20);
System.out.println("MethodInvoke01의 method01 메소드가 리턴한 값은 "+ i);

//여기에서 MethodInvoke02의 method02 호출
j = MethodInvoke02.method2(10, 20);
System.out.println("MethodInvoke02의 method02 메소드가 리턴한 값은 "+ j);
}
}

Java 3일차 Method 생성 테스트

//아래와 같은 메소드를 작성하세요.

//Method이름 :  method1
//자기자신만 접근가능 x
//ReturnType : 정수 x
//Parameter : 정수 1개
//(구현부에서)하는일:
//인수로받은(들어온) 정수를 출력하고 그 인수에 2를 곱해 Return
private int method1(int val)
{
System.out.println(val);
return val*2;
}

//Method이름 :  method2
//어디서나 아무나 접근가능
//Return 안함
//Parameter : 없슴
//(구현부에서)하는일: 아무거나 출력
public void method2()
{
System.out.println("삼성 SDS Java개발자과정");
}

//Method이름 :  method3
//같은 package에서 아무나 접근 가능
//ReturnType : 리턴안함
//Parameter : 정수 1개
//(구현부에서)하는일:
//인수로받은(들어온) 정수를 출력하고
// 그 수가 짝수 라면 "짝수", 홀수라면 "홀수" 출력
void method3(int val)
{
System.out.print(val);
if(val%2 == 0)
System.out.println(" 짝수");
else
System.out.println(" 홀수");
}

//Method이름 :  method4
//상속관계라면 어디서나 접근 가능
//ReturnType : String 타입
//Parameter : 정수 1개
//(구현부에서)하는일:
//인수로받은(들어온) 정수를 출력하고
// 그 수가 짝수 라면 "짝수", 홀수라면 "홀수" 리턴
protected String method4(int val)
{
String str;

System.out.print(val);
if(val%2 == 0)
str = "짝수";
else
str = "홀수";

return str;
}

Java 2일차 등비수열, 등차수열 판단 알고리즘 테스트(+계차수열, 다음 수 예상)

import java.util.Scanner;

public class SequenceTest {
public static void main(String[] args) {

// 숫자를 저장할 배열
int sequence[] = new int[5];
Scanner sc = new Scanner(System.in);

// 공백(space bar)을 기준으로 각 숫자 입력
for(int i=0; i<sequence.length; i++)
sequence[i] = sc.nextInt();

// 등차수열과 계차수열을 판단할 논리형 변수
boolean arithmetic = true;
boolean geometric = true;

// 계차수열의 패턴을 저장할 배열
int sequenceTemp[] = new int[4];

// 각각의 패턴 저장
for(int i=0; i<sequenceTemp.length; i++)
{
sequenceTemp[i] = sequence[i]-sequence[i+1];
}

// 계차수열을 판단할 논리형 변수
boolean difference = true;

// 배열을 처음부터 끝까지 반복(등차수열 확인)
for(int i=0; i<sequence.length-2; i++)
{
// 등차수열임이 성립하면 논리변수에 true, 하나라도 성립하지 않으면 false 후, break 
if(sequence[i]-sequence[i+1] == sequence[i+1]-sequence[i+2])
arithmetic = true;
else
{
arithmetic = false;
break;
}
}

// 배열을 처음부터 끝까지 반복(등비수열 확인)
for(int i=0; i<sequence.length-2; i++)
{
// 등비수열임이 성립하면 논리변수에 true, 하나라도 성립하지 않으면 false 후, break
if(sequence[i+1]/sequence[i] == sequence[i+2]/sequence[i+1])
geometric = true;
else
{
geometric = false;
break;
}
}

// 계차 수열의 패턴이 들어있는 배열을 처음부터 끝까지 반복
for(int i=0; i<sequenceTemp.length-2; i++)
{
// 계차수열임이 성립하면 논리변수에 true, 하나라도 성립하지 않으면 false 후, break
if(sequenceTemp[i]-sequenceTemp[i+1] == sequenceTemp[i+1]-sequenceTemp[i+2])
difference = true;
else
{
difference = false;
break;
}
}

// 다음 수와 함께 출력
if(arithmetic)
System.out.println("다음 수 : "+(sequence[4]-(sequence[0]-sequence[1]))+", 등차추열");
if(geometric)
System.out.println("다음 수 : "+(sequence[4]*(sequence[0]/sequence[1]))+", 등비수열");
if(difference)
System.out.println("다음 수 : "+(sequence[4]-(sequenceTemp[3]-(sequenceTemp[0]-sequenceTemp[1])))+", 계차수열");
if(arithmetic=geometric=difference=false)
System.out.println("등차, 등비, 계차 수열 아님");

}
}