에르의 생각발전소♫

package com.access.string;

/*

 * 자바에서 String이란,  문자값들의 연속을 나타내는 객체이다.

 * 문자의 배열도 String과 똑같이 작동한다.

 * 

 *  compare(),concat(),equals(),split(),

 *  length(),replace(),compareTo(),intern(),substring()... 등 다양한 메소드를 지원한다.

 *  

 *  게다가 String은 아래의 3개 메소드를 구현하고있다.

 *  - Serializable

 *  - Comparable

 *  - CharSequence 

 *  

 *   

 */

public class StringTest {

public static void main(String[] args) {

//test1( );

//test2();

test3();

}

public void test() {

char[] ch = { 'j', 'a', 'v', 'a', 't', 'p', 'o', 'i', 'n', 't' };

String s = new String(ch);

System.out.println(s);

}

/*

* CharSequence Interface 는 문자의 연속을 나타내기위해 사용하는 인터페이스인데, 

* String, StringBuffer,StringBuilder 클래스들이 구현하고있다.

* 

* String 객체를 만드는 2가지 방법이 있다. 

* 1. string literal 2. new keyword

* 

* 1.쌍따옴표를 사용해서 객체를 생성한다. 

* String s = "welcome"; 과 같이 ""로 감싸서 String임을 JVM한테 알려준다. 

* 매번 String 문자를 만들때마다 JVM은 string contant pool을 체크한다.

*  만약 pool에 해당 string이

* 이미 존재한다면 pooling 인스턴스를 참조하여 리턴한다.

* 

* 

*/

public static void test2() {

String s1 = "Welcome";

String s2 = "Weclome"; // 새로운 인스턴스를 만들지않음.

/*

* 1번 방법으로 String 객체를 만들어봅시다.

*  먼저, "Welcome"이란 값을 가진 String객체를 string constant pool에서 JVM은 찾지않습니다. 

* s1 객체가 생성되면 그 다음 pool에서 "Welcome"이라는 값을 가진 string을 찾기

* 시작할겁니다.

* 그리고 pool에서 "Welcome"을 찾으면 새로 인스턴스를 생성하지않고 참조하고있는 인스턴스를 리턴하죠.

* 

* 한마디로 이미 생성된 string에 대해서는 중복 인스턴스를 허용하지않고

*  효율적으로 같은 값을 가진 동일한 인스턴스를 리턴하게됩니다. 

*  (게다가, String object는 string constant pool이라는 특별한 메모리에 저장됩니다.)

* 

* 그럼 자바는 왜 string literal 개념을 사용하는가? 

* 메모리를 효율적으로 관리하기위해서 위 개념을 사용하고있습니다. 

* 중복은 숙적이니까요.

* 

* 

*/

}

public static void test3() {

String s1 = "java";

char[] ch = { 's', 't', 'r', 'i', 'n', 'g', 's' };

String s2 = new String(ch); // new keyword로 string 객체를 생성.

String s3 = new String("example");

System.out.println(s1);

System.out.println(s2);

System.out.println(s3);

}

}

// String 객체의 메소드들은 나중에 한번에 정리해서 올리겠습니다~

package com.access.array;

/*

 *  오브젝트와 클래스의 차이점

 *  Object

 *  1) 클래스의 인스턴스이다.

 *  2) 현실 존이다(펜, 렙탑, 모바일 등등)

 *  3) 물리적 존재이다

 *  4) 오브젝트는 new 키워드로 만들어진다.

 *  5) 매번 요구시 만들어진다.

 *  6) 오브젝트는 만들어질때 메모리에 할당된다.

 *  7) new 키워드,newInstance() method 등등 다양한 방법으로 오브젝트를 만들 수 있다.

 *  

 *  

 *  Class

 *  1) 오브젝트를 만들때 참조하는 도안 혹은 청사진이다.

 *  2) 유사한 객체의 그룹이다.

 *  3) 논리적 존재이다.

 *  4) class 키워드로 선언된다.

 *  5) 한번 선언된다.

 *  6) 클래스는 만들어질때 메모리에 할당되지않는다.

 *  7) class키워드로만 클래스를 정의할 수 있다.

 */

public class object {

}

package com.command;

/*

 *  Java Command Line Argument

 *  자바프로그램을 실행할 때, 커맨드 라인에 인수를 넣어주는 것을 의미한다.

 *  콘솔에서 입력되어 프로그램에 전달되는데 입력으로 사용될 수 있다.

 *  그래서 프로그램이 작동할 때 다양한 값을 넣어 어떻게 반응하는지 테스트할때 편리하게 사용될 수 있고

 *  명렁창에서 n개의 인수를 줄 수 있다.

 *  

 *  

 *  예제를 보자. 

 */

public class CommandLineExample {

public static void main(String[] args) {

System.out.println("First argument is " + args[0]);

// 필자는 Run Configuraion에서 argument로 java 라고 줬다.

}

}

result = First argument is java

package com.strict;

/*

 * 우리가 부동 소수점 변수를 연산 수행하였을 떄, 

 * 어떠한 플렛폼에서든 동일한 결과를 얻을수있도 지켜주는 고마운 키워드가

 * 바로, 이번 시간에 다뤄볼  Java Strictfp Keyword이다.!

 * 

 * (구)플렛폼에서 (신)플렛폼으로 옴겨서 실행할 경우 정확성이 차이가날 수 가 있다.

 *  그 말인 즉슨, 큰 값을 계산할수록 오차범위가 커진다는것이다.

 *  게다가 오차범위가 크다는것은 혼란과 재앙을 야기하는데 충분한 요소인데 특히 

 *  건축, 의료 분야에서는 진짜로 Catastrophe!가 될 수가 있고 이는 

 *  충분히 인명사고로 이어질 수 있으며 금융에서는 인플레, 디플레, 등등 인류에게 영향을 

 *  미칠 수도 있다.( 물론 그럴일은 없겠지만)

 *  그래서 자바는 strictfp키워드를 지원함으로서 플렛폼마다 차이가 날 수 있는 오차범위를

 *  잡고자 꾀했다. 부동소수점의 고질적 문제가 해결된것이다.

 *  

 */

public class strict {

public strictfp class A { // 클래스에 사용가능하고,

private strictfp void A_Method() {

}// 메소드에 사용이가능하며,

}

protected strictfp interface B { // 인터페이스에도 사용할 수 있다.

}

}

class B {

// strictfp abstract void m(){ } 추상메소드에 사용이 불가하며,

// strictfp int da = 10; 변수에 붙을 수 없고

// strictfp B(){} 생성자에 붙을 수 읍당.

}

package com.example.recursive;

/*

 * 재귀(귀납) - Recursive

 * 메소드가 자기 스스로를 끊임없이 호출하는 과정을 의미한다.

 * 그것을 재귀메소드라 칭한다.

 * 

 * syntax

 * 

 * returntype methodname(){

 * methodname();

 *  

 */

public class RecursiveExample {

static void p() {

System.out.println("P has called");

p();

}

public static void main(String[] args) {

p();

}

}  

몇번돌다가 에러를 뱉을겁니다.. 재귀하면 떠오르는 StackOverFlow!!

///////////////////////////////////////////////////////////////

package com.access.array;

/*

 * 일반적으로 배열은 연속된 메모리 위치를 가진 비슷한 타입을 가진 요소의 집합(Collection)을 의미한다.

 * 자바에서의 배열은 유사한 데이터타입의 요소를 가지고있는 객체라 얘기한다.

 * 배열을 초기화할때 정해진 범위를 늘이거나 줄일 수 없다.

 * 한마디로 한번 생성되면 고정된 크기를 가진다.

 * 

 * 배열은 인덱스를 기초로 0번부터 시작한다. 물론 갯수를 셀 떄는 1번부터 시작한다.

 * 

 * 배열의 이점:

 * -코드의 간소화, 어떤 인덱스 위치에 있는 어떤 데이타든 접근이 가능하다.

 * 

 * 배열의 단점:

 * - 제한된 크기: 위에서도 언급했다싶이 한번 초기화할때 정해진 크기를 가지며 수정은 불가하다.

 * 이 문제를 해결하기위해서 Collection FrameWork가 사용되었다.

 *

 *  -1차원 배열, 다차원 배열으로 2가지 타입의 배열이있다.

 *  

 *  1차원 배열의 구문은 이렇다.

 *  dataType[] arr; (or)  

 *  dataType []arr; (or)  

 *  dataType arr[];  

 *  

 *  초기화는 이렇게한다.

 *  arrayRefVar=new datatype[size];  

 * 

 */

public class TestArray {

public static void main(String args[]) {

int a[] = new int[5];// 배열 선억식.

a[0] = 10;// 각 인덱스에 번호를 직접 지정하여 값을 넣을 수 있다.

a[1] = 20;

a[2] = 70;

a[3] = 40;

a[4] = 50;

// 그럼 이렇게 만든 배열을 출력해보자.

for (int i = 0; i < a.length; i++)// a.lenght는 배열의 길이를 나타낸다 (중요 많이사용함)

System.out.println(a[i]);

int[] b = { 1, 2, 3 };

int c[] = { 3, 2, 1 };

// 하지만 간편하게 이렇게 선언할수도있다.

for (int i = 0; i < b.length; i++) {

System.out.println(b[i]);

System.out.println(c[i]);

}

}

}

//////////////////////////////////////////

package com.access.array;

public class TestArray2 {

static void min(int arr[]) {

// 파리미터로 int타입 배열을 가지고있고,무엇보다 static이다.

int min = arr[0];

// 다른값들과 비교할 값이 필요함으로

// 입력으로 들어올 배열의 0번째 인덱스를 int min값에 집어넣는다.

for (int i = 1; i < arr.length; i++)

if (min > arr[i])

// 만약 min이 arr[1]보다 크면 min을 대신하고 배열의 길이만큼 반복한다.

min = arr[i];// 최종적으로 비교되 제일 낮은값이 min에 저장되게된다.

System.out.println(min);

// 프린트로 찍는다!.

}

public static void main(String args[]) {

int a[] = { 33, 3, 4, 5 };

min(a);// 이 부분 때문에 static을 선언한거라고 볼 수 있는데

// static은 최상위 우위로 로딩되기때문에 메인에서도 접근할 수가 있다.

// int a 배열을 min메소드의 파라미터로 넣는다.

// 그럼 그 값을 5번 라인으로 넘긴다.

}

}

//////////////////////////////////////////

package com.access.array;

/*  다차원 배열.

 * 매트릭스 형태로 컬럼과 로우로 구성된 배열을 일컫는다.

 * 구문은 아래와 같이 사용하여 정의할 수 있다.

 * 

 *  dataType[][] arrayRefVar; (or)  

dataType [][]arrayRefVar; (or)  

dataType arrayRefVar[][]; (or)  

dataType []arrayRefVar[];   

 *  

 *  3개의 로우와 3개의 컬럼을 가진 다차원 배열을 예로 만들어보자

 */

public class TestArray3 {

public static void main(String[] args) {

int[][] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 },{10,11,12}};

for (int i = 0; i < 4; i++) { //칼럼의 갯수만큼 돌려주고,

for (int j = 0; j < 3; j++) { // 로우의 갯수만큼 돌려주

System.out.print(arr[i][j]+" ");

} //arr

System.out.println();

}

}

}

//////////////////////////////////////////

package com.access.array;

/*

 * java array의 클래스 이름은 무엇인가요?

 * 

 * 자바에서 배열은 객체입니다.

 * 

 */

public class TestArray4 {

public static void main(String args[]) {

int arr[] = { 4, 4, 5 };

// 배열을 하나 생성해주고,

Class c = arr.getClass();

// 클래스 타입 변수 c에 .getClass()메소드를 이용해서 리턴값인 클래스를 넣어주고, 

String name = c.getName(); 

// c의 이름을 가져와 스트링 변수에 담아서 출력하면,

System.out.println(arr); 

// 그냥 arr을 찍으면 저장된 주소값이 출력됩니다.

System.out.println(c);

System.out.println(name);

// int arr[]의 클래스이름을 알아낼수있답니다.

}

}

//////////////////////////////////////////

package com.access.array;

/*

 * 배열복사하기.

 * System class의 arraycopy 메소드를 이용해서, 배열을 복사할수있다.!

 * arraycopy메소드의 구문은 아래와 같은데, 

 * 

 * public static void arraycopy(  

Object src, int srcPos,Object dest, int destPos, int length  

)   

꼭 메소드를 통해서만 복사가 가능한걸까?

 */

public class TestArrayCopyDemo {

public static void main(String[] args) {

char[] copyForm = { 'd', 'e', 'c', 'a', 'f', 'f', 'e', 'i', 'n', 'd' };

// 문자열 타입 배열을 만들고 안에 값을 집어넣느다.

char[] copyTo = new char[7];

// 그리고 복제가 될 배열 하나를 만든다.

System.arraycopy(copyForm, 2, copyTo, 0, 7);

// System의 메소드인 arraycopy를 타이핑 후 적절히 파라미터를 준다.

/*

* @param src 소스를 줄 배열

* 

* @param srcPos 소스 배열에서 복제하기 시작할 인덱스 번호

* 

* @param dest 소스를 받게 될 배

* 

* @param destPos 몇번인덱스에서부터 소스를 받을 것인가.

* 

* @param length destPos에서부터 얼마만큼 길이의 데이터를 받을 것인가.

* 

*/

System.out.println(copyTo);

int[] a = { 1, 2, 3 };

int[] b = a;

char[] c = { 'a', 'b', 'c' };

char[] d = c;

for (int e = 0; e < a.length; e++) {

System.out.print(a[e]);

System.out.print(b[e]);

}

System.out.println();

for (int e = 0; e < a.length; e++) {

System.out.print(c[e]);

System.out.print(d[e]);

}

}

}

//////////////////////////////////////////

package com.access.array;

/*

 *  다른 두 배열을 더할 수도 있을까?

 *  복제를 보아하니, 왠지 가능할거같다. 

 *  

 */

class TestArray5 {

public static void main(String args[]) {

// 일단 재료가 될 두 행렬을 생성해주자.

int a[][] = { { 1, 3, 4 }, { 3, 4, 5 } };

int b[][] = { { 1, 3, 4 }, { 3, 4, 5 } };

// 2, 6, 8 6, 8, 10이 되어야한다.

// 두 배열의 합을 저장할 배열을 만들어주자.

int c[][] = new int[2][3];

// 그리고는 반복문을 통해 두 배열을 c로 집어넣어주자.

for (int i = 0; i < 2; i++) {

for (int j = 0; j < 3; j++) {

c[i][j] = a[i][j] + b[i][j];

System.out.print(c[i][j] + " ");

}

System.out.println();// new line

// 딱히 설명할게 없다.

}

}

}

package com.example.call;

/*

 * Call by Value and Call by Reference In Java.

 * 자바 호출에는 값을 호출할 순 있지만 참조객체를 직접 호출할 수는 없다.

 * 이게 무슨말이고하면!

 * 값을 전달하는 메소드를 호출한면, 값호출(Call Of Value)을 수행한것이고,

 * 호출된 메소드에서 변경된 값은 적용되지가않는다.

 * 무슨 말인지 살짝 모호할텐데, 예제를 보자 

 */

public class Operation {

int data = 50; // field

void change(int data) { // method

data = data + 100;

// this.data = data + 100 이 아니다.

// 오해하지말

// 메소드 내부의 변수 값은 변하지않고, 오직 로컬변수의 변경될 수 있다.

// 호출된 메소드의 파라미터인 data를 넘겨받아 그 값에 100을 더하여 초기화하는데

// 지켜볼건 이렇게해서 data가 가지고있는값이 바뀌느냐?

}

public static void main(String args[]) {

Operation op = new Operation();

// 객체를 만들어주자.

System.out.println("before change " + op.data);

// 변경전

op.change(500);

// 파라미터를 통해 필드값 50을 무시하고 값을 집어넣었을

System.out.println("after change " + op.data);

op.data = 99; // 로컬 변수에 직 접근하였을때

System.out.println("aproaching to local var " + op.data);

}

}

before change 50

after change 50

aproaching to local var 99

package com.example.call;

/*

 * 참조호출의 경우에 호출된 메소드를 변경한다면, 원래 값이 변경될 수 있다.

 * 어떤 원시타입 값을 주는대신에 객체를 전달한다면! 원래값이 바뀌게되는데

 * 밑에 예제에서는 값을 대신해 객체를 전달하였다.

 * 

 *

 */

class Operation2 {

int data = 50;

void change(Operation2 op) {

op.data = op.data + 100;

// op의 타입을 보자, 객체 Operation2이 타입으로 선언되있다는 말은

// 원시타입이 아닌 참조타입이라는 얘기이다. 

// 참조호출을 통해 로컬변수로 접근할 수 있게된다.

}

public static void main(String args[]) {

Operation2 op = new Operation2();

System.out.println("before change " + op.data); //50

op.change(op);// 50 + 100

System.out.println("after change " + op.data);

}

}

before change 50

after change 150

/*

 * 1. 자바에서 Encapsulation이란 데이터와 코드를 단일 유닛에 포장하는 과정을 의미한다.

 * 애초에 캡슐 자체 다양한 종류의 약을 위까지 안적하게 이동시키기 위해 만들어졌기때문에 일맥상통한다고 볼 수 있다.

 * 우리는 완벽히 캡슐화된 클래스를 private class를 통해 만들 수 있다.

 * 그리고는 Getter&Setter를 통해 안전히 접근할 수 있다.

 * 

 * 2. 캡슐화의 장점.

 * Getter&Setter를 통해서 클래스를 Read-Only 혹은 Write-Only로 만들 수 있다.

 * 일단 게터와 세터를 통하면 근본 데이터의 오염을 방지할 수 있으며 다형성의 원리에 매우 부합하여

 * 나중에 유지보수성성이 높아진다는 의미이니 생활화하도록하고, 나중에는 프레임워크로 대체할테니

 * 개념과 실습으로 마무리 지어놓자

 */

package com.encapsulation;

public class Student {

private String name;

public String getName() {

return name;

}

public void setName(String name){  

this.name=name ;

}

}

package com.encapsulation;

class Test {

public static void main(String[] args) {

Student s = new Student();

s.setName("vijay");

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

}

}

// vj jay라는 결과값이 나온다. 직접 Student의 필드값에 접근하지않고 setter를 통하여

// 필드의 값을 초기화한 후 getter를 통해 가져왔다. 이 과정은 모두 간접적으로 이루어졌다는걸 명시하자.

// 딱히 더 설명할게 없지만 객체지향프로그맹에서 핵심 이론을 맡고있다.

// 자세한 내용은 추후에 구글링으로 더 덧붙이도록 하겠다.

package com.access.modifier;

class A { 

// private 필드와 메소드를 가진 A라는 클래스가 있고,

private int data = 40;

private void msg() {

System.out.println("Hello java");

}

}

public class Simple {

//메인메소드를 가지고있는 Simple클래스

public static void main(String args[]) {

A obj = new A();

//A 인스턴스를 만들어 A가 가지고있는 필드와 메소드에 접근하고자합니다만.!!

System.out.println(obj.data);// Compile Time Error

obj.msg();// Compile Time Error

}

}

Exception in thread "main" java.lang.Error: Unresolved compilation problems: 

The field A.data is not visible

The method msg() from the type A is not visible

at com.access.modifier.Simple.main(Simple.java:18)

라는 에러를 뱉어주는데요, 다른 방 학생이 옆 방에서 물건을 가지고 갈려는데 비밀번호가 걸려있어서 못들어가는거라고

보시면 되실거같네요.

class A {

private A() {

}// private 생성자

void msg() {

System.out.println("Hello java");

}

}

public class Simple {

public static void main(String args[]) {

A obj = new A();// Compile Time Error

}

}

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 

The constructor A() is not visible

at com.access.modifier.Simple.main(Simple.java:12)

package com.access.modifier;

class A {

void msg() {

System.out.println("Hello");

}

}

=====================================================

package com.access1.modifier;

//save by B.java  

import com.access.*;

class B {

public static void main(String args[]) {

A obj = new A();// Compile Time Error

obj.msg();// Compile Time Error

}

}

class A의 제한자가 default이기때문에 같은 패키지에서만 호출이 가능한데

class B에서 다른 패키지에 있는 A를 호출할려고했기떄문에 자바가 '안되, 돌아가'하며 컴파일 에러를 뱉은 상황입니다.

package com.access.modifier;

public class A{  

protected void msg(){System.out.println("Hello");}  

}  

======================================================

package com.access1.modifier;

import com.access.modifier.*;

class B extends A {

public static void main(String args[]) {

B obj = new B();

obj.msg();

}

}

Hello

비록 A,B의 패키지는 서로 다르지만, B가 A를 상속했기 때문에 A의 method를 호출할 수 있었습니다.

package com.access.modifier;

public class A {

public void msg() {

System.out.println("Hello");

}

}

===================================================

package com.access1.modifier;

import com.access.modifier.*;

class B {

public static void main(String args[]) {

A obj = new A();

obj.msg();

}

}

Hello

..뭐 설명할게 없는 관계로 패스..! 

밑에 정리표를 마지막으로 마무리하겠습니다:)

int data = 30;

class Dog{  

 public static void main(String args[]){  

  Dog d1;//Here d1 is a type of Dog  

 }  

}  

class Animal{}  

class Dog extends Animal{  

 public static void main(String args[]){  

  Dog d1=new Dog();  

 }  

}  

 class Animal{  

 void eat(){System.out.println("animal is eating...");}  

}  

class Dog extends Animal{  

 void eat(){System.out.println("dog is eating...");}  

 public static void main(String args[]){  

  Animal a=new Dog();  

  a.eat();  

 }  

}