티스토리에서 마크다운이 바로 적용 안되는게 불편해서 벨로그로 이전했습니다
foeverna (나영원) - velog
20200825-TIL TIL 복습진행 ~ Wrapper Class까지Homework - 프리코스 인강 - 내부 클래스 다시듣기PairProgramming 풀기- 블로그 이전TIL 복습진행Enum 복습 및 Enum에 기본 메서드들 추가 작성Generic 복습 및 글 구조
velog.io
벨로그에서 이어서 배운내용들을 포스트하겠습니다
최우영 강사님 강좌
명렁어를 통해 다양한 기능을 수행할 수 있으며 명령어 + 부가명령어로 해당기능을 더 다양하게 사용할 수 있음
TAB을 통해 자동완성 기능을 사용할 수 있음
$ : 사용자 입력 가능하다는표시
ls : 리스트 세그먼트의 약자, 폴더안에 내용물을 보여줌
cd : change directory, cd 폴더명 하여 폴더를 이동가능/ cd .. 상위폴더이동
mkdir 폴더명 : 폴더생성
touch 파일명 : 텍스트기반으로 된 파일을 만들 때 사용 ex) touch README.txt
mv 파일명 폴더명 : 해당 폴더로 파일이동
cp 파일명 위치 : 해당 위치로 파일 복사
mv(move) 기존이름 바꿀이름 : 파일명 바꾸기
rm(remove) 파일명 : 파일삭제
'*', 별아니고 에스터리스크, 와일드카드 역할을 함
rm *.java : 파일명 상관없이 .java는 다지워라
rm bin/ - 실패 왜? 디렉토리라서 -> 디렉토리만 지울수 없고 디렉토리에 있는 모든파일 지우고 폴더도 지워야 함
rm -r bin/ : 폴더 안에 있는 모든 내용지우고 폴더도 지워라
cat 파일명 : 파일에 내용물을 출력해줌
chmod : 파일 권한을 설정해줌
Vim은 shell에서 사용할 수 있는 text editor의 일종
우리는 Vim을 commit message작성에 사용할 예정
vi or viim 파일명 : vim 실행하여 파일 편집 ex) vim readme.txt
노멀모드 : 기본모드로 모든 알바벳키는 명령어로 돌아옴
인서트모드 : 노멀모드에서 i를 누루면 텍스트를 입력할 수 있는 인서트 모드로 전환됨
비주얼모드 : 노멀모드에서 v키를 이용해 전환해서 방향키를 움직이면 블록지정 할 수 있음
커맨드모드 : 노멀모드에서 :입력하면 커맨드 입력가능 w는 저장 q는 나가기(wq동시 입력 가능)
복사 붙여넣기 : 블록설정 이후 y키 누루면 복사 이동한다음에 P하면 붙여넣기
Undo (ctrl + z) : 되돌리기
삭제 : dd하면 삭제이고 그 상태에서 P하면 붙여넣기 됨(삭제랑 잘라내기랑 같은 기능 공유)
사용자의 workspace의 존재하는 소스코드를 add 파일명을 통하여 index로 옮김(스태킹)
=> commit을 통해 index에 있는 소스코드에 레이블을하고 타임스탬프를 찍어서 local repository로 옮김
=> push를 통해 local repositary에 있는 소스코드를 remote repository로 옮김
-초기 설정 (한번만 해주면 됨)
$ git config --global user.name "{github username}" // github 유저네임 등록
$ git config --global user.email "{github email address}" // github 유저메일 등록
$ git config --global core.editor "vim" // git commit 작성시 vim 실행하여 commit message 편집
$ git config --global core.pager "cat" // cat 명령어를 통해
$ git config --list // 설정사항 확인
README.md = 프로젝트가 어떤프로젝트인지 알려주는파일 그래서 프로젝트 루트에는 readme.md가 항상존재해야함
touch README.md = > README.md 파일 생성
git status => untracked file에 업데이트됨
git add README.md => 스태깅에 올리는작업
git commit 하면 vim이 열림(아까 vim으로 기본 편집기 설정됨)
첫줄에는 제목(구나 절) - 어떤작업인지 알려줘야함(커밋옮겨다닐때 도움이됨), PreFix를 활용
ex)docs: Create README.md
Prefix, 한눈에 커밋내용을 알아보기 위한 약자
feat: features
docs: documentations
conf: configurations
test: test
fix: bug-fix
refactor: refactoring
ci: Continuous Integration
build: Build
perf: Performance
제목 이후 자세한 내용은 한줄 띄고 세번째줄에서 쓰면됨 - 문장형으로 쓰면됨
ex) created README.md to describe this repo
commit 다쓰고 :wq하면 저장하고 나가기, 저장안하고 나가면 커밋이 취소됨
git remote add origin 레포주소 하면 내 래포 주소와 workspace 연결됨
내 프로젝트가 어떠한 종류의 소스인지 알려주는 기능
-Git과 Github가 다른 것을 인식해야함
-Git이 소스코드의 버전관리를 위한 도구이고 Github는 저장소 서비스
-Git이 다른 버전관리 도구로 치환될 수 있듯이 Github도 그렇다
ex) gitlab 은 사설서버로 보안이 굉장히 중요한코드
다른사람의 코드도 git clone해올 수 있음, 또한 소스코드가 업데이트 되면 다음에 git pull만하면 바로 업데이트 할 수 있음
UserName.github.io로 repository를 개설하면 홈페이지 처럼 활용할 수 있는 공간이있음
=> index.html을 만들어주어서 홈이될 페이지를 설정해줄 수 있음
이 공간을 static site Genertor의 기능을 활용하여 개인 블로그 처럼 이용 가능
Hexo는 md형식으로 작성한 md파일을 html파일로 변환시켜 바로 github repository에 올릴 수 있게 도와주는 도구
블로그를 통해 TIL을 꾸준히 작성하면 포트폴리오로 활용 가능!!! 그러니 열심히 쓰자!
접근 가능한 범위를 정해, 데이터 은닉/보호(Encpsulation)기능을 추가한다.
접근제어자별 접근 범위(public > protected > default > private)
private 또는 protected 변수에 접근하기 위해 앞에서 배운 getter와 setter 사용한다
접근 제어자는 하나만 사용할 수 있다
코딩 실습1
package s04.s02.p05.subp01;
public class ClassA {
public int x;
protected int y;
int z; // default(= package)
private int w;
public void methodA() {}
protected void methodB() {}
void methodC() {} // default(=package)
private void methodD(){}
public void methodTest(){
System.out.println(x);
System.out.println(y);
System.out.println(z);
System.out.println(w);// 내부라 접근가능
methodA();
methodB();
methodC();
methodD(); // 내부이기에 접근 가능
//private은 특성상 내부 구현을 위해서만 사용됨
}
}
class ClassTest { // 같은 패키지인 경우우
public static void main(String[] args) {
ClassA obj = new ClassA();
System.out.println(obj.x);
System.out.println(obj.y);
System.out.println(obj.z);
//System.out.println(obj.w); // w는 private이라 접근 불가
obj.methodA();
obj.methodB();
obj.methodC();
// obj.methodD(); // 접근 불가 /IDE 빠른완성에 뜨지도 않음
}
}같은 패키지의 같은 클래스의 경우 모든 접근제어자에 접근이 가능함
같은 패키지의 다른 클래스의 경우 private 접근제어외에 다른 접근자에는 접근이 가능함
package s04.s02.p05.subp02;
import s04.s02.p05.subp01.ClassA;
class ClassAA extends ClassA {
public void methodTest(){
System.out.println(x);
System.out.println(y); // 자식이라 다른 패키지에서도 사용 가능
//protected는 private처럼 쓰지만, 상속한 경우 접근이 필요 할 때 사용함(내부적 구현 바꾸어야 할때)
//System.out.println(z); // 접근불가
// System.out.println(w);// 내부라 접근가능
methodA();
methodB();
// methodC(); 접근불가
// methodD(); // 내부이기에 접근 가능
}
}
public class ClassB {
public static void main(String[] args) {
ClassA obj = new ClassA();
System.out.println(obj.x);
// System.out.println(obj.y); //protected는 다른 패키지인 경우 자식만 가능
// System.out.println(obj.z); // default는 다른 패키지면 안됩니다.
//System.out.println(obj.w); // w는 private이라 접근 불가
obj.methodA();
//obj.methodB();
// obj.methodC();
// obj.methodD(); // 접근 불가 /IDE 빠른완성에 뜨지도 않음
}
}다른 패키지에 해당클래스를 상속받은 클래스는 public과 protect만 접근이 가능함
다른 패키지에 상속받지 않는 보통의 클래스의 경우 public으로만 접근이 가능함
위의 예제에서 처럼 접근제어자 키워드 별로 접근이 가능한 범위를 지정해 줄 수 있음
클래스에는 Public과 Default 접근제어자만 사용 가능하다
public과 deafault 접근제어자를 통해 다른 패키지에서 클래스에 접근 할 수 있는지 없는지만 제어한다
private의 경우 클래스로 접근이 다른 클래스의 접근이 불가능하기때문에 객체지향에 의미에 맞지않는다
protected의 경우 다른패키지의 자식클래스가 있다는 것이 전제되어야 되기때문에 public과 다른점이 없다(존재 의미가 없음)
java 파일에는 무조건 하나의 클래스가 있기로 약속을 했고 하나의 클래스명은 파일이름과 같아야 한다는 규칙이있음
해당 public 클래스는 전체 클래스를 대표해서 다른 클래스들에서 불러서 사용할 수 있게 됨
그 외에 전체에 존재하는 다른 클래스는는 내부적으로 대표 클래스를 구성하는 클래스로 인식을하게 됨
class SingletonClass {
private final static SingletoneClass instance = new SingletonClass();
private SingletonClass() {}
public static SingletonClass getInstance() {
return instance;
}
}public class Foo {
final int x = 0; // final variable
final int y; // blank finial variable
public Foo(int y) {
this.y = y; // blank final variable initialization
}
}| [Java] 3_5_패키지와 임포트 (0) | 2020.08.23 |
|---|---|
| [Java] 3_4_1_상속 예제 (0) | 2020.08.18 |
| [Java]3_4_상속(Inheritance) (0) | 2020.08.18 |
| [Java]3_3_JavaDocs(주석) (0) | 2020.08.18 |
| [Java] 3_2_3_클래스 & 메서드 예제 (0) | 2020.08.10 |
패키지이름 규칙 package 소속.프로젝트.용도 (상위계층 하위계층 최하위계층)
- utils/하위 폴더에 .java는 가져오지는 않음 utils폴더 안에 있는 java파일만 가져옴public class Foo{
main{
List list = new Litst();
java.awt.List list2 = new java.awt.List(); => 겹치는 List클래스를 쓸때마다 매번 가져와서 사용해야함public class StaticImport {
public static void main(String args[]) {
out.println(random());
}
}| [Java] 3_6_제어자 (Modifier) (0) | 2020.08.23 |
|---|---|
| [Java] 3_4_1_상속 예제 (0) | 2020.08.18 |
| [Java]3_4_상속(Inheritance) (0) | 2020.08.18 |
| [Java]3_3_JavaDocs(주석) (0) | 2020.08.18 |
| [Java] 3_2_3_클래스 & 메서드 예제 (0) | 2020.08.10 |
import java.util.Arrays;
/**
* 아래 테스트 코드가 정상 동작하도록 클래스들을 완성하시오.
*
* getArea(): 사각형의 넓이를 반환한다.
* getCenterOfMass(): 사각형의 질량중심을 반환한다.
* GetAllPoints(): 사각형의 네 점을 배열로 반환한다.
* rot90(): Pivot을 기준으로 사각형을 90도 회전시킨다.
*/
class Vector2D {
public float x, y;
public Vector2D(float x, float y) {
this.x = x;
this.y = y;
}
public String toString() {
return this.x +","+this.y;
}
}
class RectCore {
protected Vector2D pos;
protected float w, h;
public RectCore(float x, float y, float w, float h) {
this.pos = new Vector2D(x, y);
this.w = w;
this.h = h;
}
public String toString() {
return "RECTCORE("+this.pos+","+w+","+h+")";
}
}
public class Rect extends RectCore {
String rotRec;
public Rect(float x, float y, float w, float h) {
super(x, y, w, h);
rotRec = "";
}
// 위에 객체가져오기위해서 super()해야했음
public float getArea() {
return this.w * this.h;
}
public Vector2D getCenterOfMass() {
return new Vector2D(pos.x + (w /2.0f), pos.y +(h /2.0f));
}
public Vector2D [] getAllPoints() {
return new Vector2D[]{ pos,
new Vector2D(pos.x,(pos.y+h)),
new Vector2D((pos.x+w),pos.y),
new Vector2D((pos.x+w),(pos.y+h))};
}
public void rot90(Vector2D pivot) {
Vector2D[] oldPoints = getAllPoints();
Vector2D[] newPoints = new Vector2D[4];
for (int i = 0; i < oldPoints.length; i++) {
newPoints[i] = new Vector2D(
-(oldPoints[i].y - pivot.y) + pivot.x,
(oldPoints[i].x - pivot.x) + pivot.y);
}
float min_x = newPoints[0].x;
float min_y = newPoints[0].y;
float max_x = newPoints[0].x;
float max_y = newPoints[0].y;
for (Vector2D twoD : newPoints) {
min_x = Math.min(min_x, twoD.x);
min_y = Math.min(min_y, twoD.y);
max_x = Math.max(max_x, twoD.x);
max_y = Math.max(max_y, twoD.y);
}
pos = new Vector2D(min_x, min_y);
w = max_x - min_x;
h = max_y - min_y;
}
@Override
public String toString () {
String s = super.toString();
s += "\n Area: "+getArea();
s += "\n CoM: "+getCenterOfMass();
s += "\n";
return s;
}
}
class RectTest {
public static void main(String[] args) {
Rect rect = new Rect(0.5f, 0.7f, 1.5f, 2.3f);
System.out.println("Area: " + rect.getArea());
System.out.println("CoM: " + rect.getCenterOfMass());
System.out.println("All Points: " + Arrays.toString(rect.getAllPoints()));
rect.rot90(new Vector2D(0.4f, 0.2f));
System.out.println("Rotated rect: " + rect);
// toString 메서드자체가 오버라이드 되면 객체명을 썼을 때 그 출력문을 출력하게 되어있데
}
}| [Java] 3_6_제어자 (Modifier) (0) | 2020.08.23 |
|---|---|
| [Java] 3_5_패키지와 임포트 (0) | 2020.08.23 |
| [Java]3_4_상속(Inheritance) (0) | 2020.08.18 |
| [Java]3_3_JavaDocs(주석) (0) | 2020.08.18 |
| [Java] 3_2_3_클래스 & 메서드 예제 (0) | 2020.08.10 |
class Person{
String name;
public void work(){
System.out.println("일하기");
}
public void sleep(){
System.out.println("잠자기");
}
}
// Person을 상속하는 자식 클래스
//extends 키워드를 이용하여 상속
class Developer extends Person{
String mainLang;//코딩하는 Lang
public void writeCode(){
System.out.println("돈 받은 만큼 코딩하기");
}
}
class Student extends Person{
String major;
public void writeCode(){
System.out.println("밤새 코딩을 합니다.");
}
}
public class Main {
public static void main(String[] args) {
// 클래스를 상속하면, 모든 멤버 변수와 모든 메소드를 상속받는다.(not 복사)
Developer dev = new Developer();
dev.name = "나개발";
System.out.println(dev.name); //나개발 //Developer이지만 Person이기도 하다.
// Developer 'Is-A' Person.// 개발자는 사람이다.
// Developer is a Person.
dev.work(); // 일하기
dev.sleep(); // 잠자기
dev.mainLang = "Java";
dev.writeCode();
Student stud = new Student(); // Student 'IS-A' Person
stud.writeCode();
//부모 클래스로부터 여러 자식 클래스들을 만들 수 있다.
// 자식 클래스는 자기자신의 변수와 메서드 뿐아니라 부모의 것까지 사용할 수 있음
}
}(컴포지션은 구성이라는 뜻, 클래스를 조립해서 클래스를 만들어낸다는 의미)
// MainMachine 'HAS-A' String// String이 클래스기 때문에 우리가 클래스안에 String 변수 만들면 이미 컴포지션하고 있던거임
class MainMachine {
String model;
boolean isBroken = false;
public MainMachine(String model){
this.model = model;
}
}
// Developer 'HAS-A' MainMachine
// Developer 클래스는 MainMachine의 객체 하나를 보유한다.
class Developer {
String name;
MainMachine mainMachine;
public Developer(String name, MainMachine machine){
this.mainMachine = machine;
}
public void writeCode() {
if (mainMachine.isBroken == true){
System.out.println("코딩을 할 수 없습니다.");
}
else {
System.out.println(mainMachine.model + "(으)로 코딩하기");
}
if (Math.random() >0.9){
breakMachine();
System.out.println("machine이 고장났습니다.");
}
}
public void breakMachine() {
mainMachine.isBroken = true;
}
}
// Developer 'HAS-A' MainMachine
// Devleoper 클래스는 MAinMachine의 객체 하나를 보유한다.(Has)//MainMachine에 속성에도 접근가능
public class Main {
public static void main(String[] args) {
MainMachine mac = new MainMachine("MacBook Pro");
Developer dev = new Developer("너개발", mac);
for(int i = 0; i<10; i++){
dev.writeCode();
}
}
} class Foo{
String x = "Foo";
public Foo(String x) {
this.x = x;
}
}
class Bar extends Foo{
// String x = "Bar"; // 멤버 변수명이 부모와 겹치면 재정의 됨 // 그러나 부모 변수에는 영향을 주지 않음
// => 이것도 지우면 Foo Foo Foo 출력, 마지막으로 부모변수로 접근하게됨
// 부모클래스에 기본 생성자를 사용하는 경우에는 super로 호출 안해줘도됨
// 하지만 부모클래스에 생성자가 있으면 자식클래스에서 생성자를 호출 해주어야함
// 부모클래스에 파라미터 생성자가 있으면 호출해 주어야 한다.
public Bar(String x, String x1) {//파라미터가 겹치니까 x, x1으로 다르게해준것
super(x); //부모 클래스의 생성자를 얘기함. this와 마찬가지로 첫줄에 써야 합니다. 부모클래스 생성자 호출
// 부모 객체를 먼저 생성하고, 그 다음에 자식 객체를 생성할때 이 super에서 이루어지는 것..아하
// 그니까 자식 클래스만들때 생성자에 포함시키면 무조건 객체 생성할때마다 부모 클래스를 생성할 수 있겠구나
// 손자 클래스를 만들때는 할아버지 + 부모 객체가 생성됨
this.x = x1;
}
public void method(){
// String x = "method"; // 이렇게 지우면 Bar BAR Foo 실행됨 // 로컬 변수 -> 멤버변수> 부모의 멤버변수 순으로 접근하게됨
System.out.println(x); // 로컬 변수
System.out.println(this.x); // 자기 자신의 객체에 접근 가능
System.out.println(super.x); // 부모 객체에 접근 가능
}
}
//아무것도 상속하지 않은 경우, Object 클래스를 상속하는 것과 같다.
class Jaemi extends Object{
public void method() {
// super. // 해보면 여러가지 메소드 속성 사용할 수 잇음. 사실 super안해도 사용할수잇음. 그래서 모든 클래스는 object의 속성포함함
}
}
public class Main {
public static void main(String[] args) {
Bar bar = new Bar("","");
bar.method(); //method
//Bar
//Foo
//자식 객체 생성을 하면,
//부모 객체를 먼저 생성 하고, 그 다음에 자식 객체를 생성
//foo 인스턴스 생성후 Bar 인스턴스 생성하게됨
//자식 여러명이 있으면 따로따로 부모의 객체를 생성하게됨
//Perosn이라는 타입명으로 만들어도 다 따로따로 인스턴스가 존재할수 있는 이유.
}
}부모클래스의 멤버변수명과 자식클래스의 변수명이 같을 경우 자식클래스에서 자동으로 재정의 됨. 그때 부모멤버 변수에는 영향X
자식 클래스를 생성할때 기본 생성자에 super();가 포함되 부모 클래스를 먼저 생성하고 자식 클래스를 생성하게 됨
를 따로 생성함
모든 클래스의 부모가 되는 클래스는 Objcet 클래스
##참고사항
| [Java] 3_5_패키지와 임포트 (0) | 2020.08.23 |
|---|---|
| [Java] 3_4_1_상속 예제 (0) | 2020.08.18 |
| [Java]3_3_JavaDocs(주석) (0) | 2020.08.18 |
| [Java] 3_2_3_클래스 & 메서드 예제 (0) | 2020.08.10 |
| [Java] 3_2_2_클래스 - 메소드 (0) | 2020.08.09 |
/**
* 클래스에 대한 설명. 이 클래스는 자바독 클래스로 자바독을 공부하기 위해...
* @author Young Na
*/
public class JavaDocs {
/**
* 멤버 변수에 대한 설명을 적을 수 있습니다.
*/
int memberInt;
/**
* 멤버 변수 또 다른 것도 설명을 적을 수 있습니다.
*/
String memberString;
/**
* 생성자에 대한 설명입니다.
* @param memberInt 입력1입니다.
* @param memberString 입력2입니다.
*/
public JavaDocs(int memberInt, String memberString) {
this.memberInt = memberInt;
this.memberString = memberString;
}
/**
* 메소드에 대한 설명을 여기에 적습니다.
* @param string 입력 인자 (파라미터)에 대한 설명을 적습니다.
* @return 리턴값에 대한 설명은 여기에 적습니다.
*/
public int methodA(String string){
return string.length();
}
public static void main(String[] args) {
JavaDocs j = new JavaDocs(1,"string");
//클래스명에 커서 올리면 javadoc적은게 뜸
// int a = j.methodA();
}
}| [Java] 3_4_1_상속 예제 (0) | 2020.08.18 |
|---|---|
| [Java]3_4_상속(Inheritance) (0) | 2020.08.18 |
| [Java] 3_2_3_클래스 & 메서드 예제 (0) | 2020.08.10 |
| [Java] 3_2_2_클래스 - 메소드 (0) | 2020.08.09 |
| [Java] 3_2_1클래스(class) (0) | 2020.08.05 |
| 2020년 8월 14일 TIL (0) | 2020.08.17 |
|---|---|
| 2020년 8월 13일 TIL (0) | 2020.08.17 |
| 2020년 8월 12일 TIL (0) | 2020.08.17 |
| 2020년 8월 11일 TIL (0) | 2020.08.17 |
| 2020년 8월 10일 TIL (0) | 2020.08.10 |
| 2020년 8월 16일 TIL (0) | 2020.08.17 |
|---|---|
| 2020년 8월 13일 TIL (0) | 2020.08.17 |
| 2020년 8월 12일 TIL (0) | 2020.08.17 |
| 2020년 8월 11일 TIL (0) | 2020.08.17 |
| 2020년 8월 10일 TIL (0) | 2020.08.10 |
| 2020년 8월 16일 TIL (0) | 2020.08.17 |
|---|---|
| 2020년 8월 14일 TIL (0) | 2020.08.17 |
| 2020년 8월 12일 TIL (0) | 2020.08.17 |
| 2020년 8월 11일 TIL (0) | 2020.08.17 |
| 2020년 8월 10일 TIL (0) | 2020.08.10 |
| 2020년 8월 14일 TIL (0) | 2020.08.17 |
|---|---|
| 2020년 8월 13일 TIL (0) | 2020.08.17 |
| 2020년 8월 11일 TIL (0) | 2020.08.17 |
| 2020년 8월 10일 TIL (0) | 2020.08.10 |
| 오늘부터 TIL(Today I Learned)을 적기로 하였습니다. (0) | 2020.08.09 |
| 2020년 8월 14일 TIL (0) | 2020.08.17 |
|---|---|
| 2020년 8월 13일 TIL (0) | 2020.08.17 |
| 2020년 8월 12일 TIL (0) | 2020.08.17 |
| 2020년 8월 10일 TIL (0) | 2020.08.10 |
| 오늘부터 TIL(Today I Learned)을 적기로 하였습니다. (0) | 2020.08.09 |
Weekly test#2 준비
Java Homework & TIL 작성
블로그 업데이트
Weekly Test#2 준비(복습)
Java 수업 TIL작성
인텔리J 프로젝트와 모듈에 대한 조사?
Homework #6 복습 클래스 & 메서드 예제
Weekly Test#2 결과 복습
질문 사항 해결
Homework #7 복습
| 2020년 8월 14일 TIL (0) | 2020.08.17 |
|---|---|
| 2020년 8월 13일 TIL (0) | 2020.08.17 |
| 2020년 8월 12일 TIL (0) | 2020.08.17 |
| 2020년 8월 11일 TIL (0) | 2020.08.17 |
| 오늘부터 TIL(Today I Learned)을 적기로 하였습니다. (0) | 2020.08.09 |
package src;
/**
* MyMath 클래스 구현하기
* 인스턴스를 생성할 수 없는 MyMath 클래스를 구현하시오.
*
* MyMath 클래스는 다음 정적 변수를 가진다.
* PI = 3.1415927;
* E = 2.718281;
*
* MyMath 클래스는 다음 정적 메소드를 가진다.
* min - 정수 또는 실수를 여러개 입력받아 최소값을 구한다.
* max - 정수 또는 실수를 여러개 입력받아 최대값을 구한다.
* abs - 정수 또는 실수를 입력받아 절대값을 구한다.
* floor - 실수를 입력받아 내림 연산한 정수를 출력한다.
* ceil - 실수를 입력받아 올림 연산한 정수를 출력한다.
*/
public class MyMath {
public static double PI = 3.1415927;
public static double E = 2.718281;
private MyMath(){}
//min()
static public int min(int... params) {
int minVal=0;
for(int i : params){
minVal = i < minVal ? i : minVal;
}
return minVal;
}
static public double min(double... params) {
double minVal=0;
for(double i : params){
minVal = i < minVal ? i : minVal;
}
return minVal;
}
//max()
static public int max(int... params) {
int maxVal=0;
for(int i : params){
maxVal = i > maxVal ? i : maxVal;
}
return maxVal;
}
static public double max(double... params) {
double maxVal=0;
for(double i : params){
maxVal = i > maxVal ? i : maxVal;
}
return maxVal;
}
//abs()
static public int abs(int i){
return i >0? i : -i;
}
static public double abs(double d){
return d>0? d: -d;
}
//floor
static public double floor(double d){
return d>= 0 ? d-( d % 1) : d - ( 1 + d % 1);
}
//ceil
static public double ceil(double d){
return d > 0 ? d + ( 1 -(d % 1)) : d - (d % 1);
}
}
class MyMathTest {
public static void main(String[] args) {
// MyMath m = new MyMath(); // 인스턴스 생성 불가
System.out.println(MyMath.PI);
System.out.println(MyMath.E);
System.out.println(MyMath.min(2, 3, -4, 6, 3.0, 4.2, 7.3, -1.1, -4.2));
System.out.println(MyMath.max(7, 0, 6, 16, -4, 3.0, 9.0, 21.0));
System.out.println(MyMath.abs(4));
System.out.println(MyMath.abs(-2.3));
System.out.println(MyMath.floor(0));
System.out.println(MyMath.ceil(-3.12312245));
}
}
package src;
/**
* 싱글톤 패턴 구현하기
*
* 단 하나의 인스턴스만 존재할 수 있는 클래스 SingletonPattern을 구현하시오.
*
* 생성자를 외부에서 직접 호출할 수 없다.
* 정적 메소드인 getInstance() 메소드를 이용해 객체를 받아온다.
* 받아온 객체는 항상 같은 객체를 참조해야 한다.
*/
public class SingletonPattern {
private final static SingletonPattern instance = new SingletonPattern();
private SingletonPattern(){}
public static SingletonPattern getInstance(){
return instance;
}
}
class SingletonPatternTest {
public static void main(String[] args) {
// SingletonPattern instance = new SingletonPattern(); // should fail
SingletonPattern instanceOne = SingletonPattern.getInstance();
SingletonPattern instanceTwo = SingletonPattern.getInstance();
System.out.println(instanceOne == instanceTwo);
}
}
package src;
/**
* 3차원 벡터 클래스 구현하기
*
* 3차원 벡터를 클래스로 구현하시오.
*
* 속성
* float타입의 x, y, z
*
* 생성자
* Vector3D(float x, float y, float z)
*
* 메소드
* - x, y, z에 대한 getter 및 setter
* - add(): 벡터끼리의 덧셈, 실수와의 덧셈을 반환
* - sub(): 벡터끼리의 뺄셈, 실수와의 뺄셈을 반환
* - inner(): 두 벡터의 내적을 반환
* - mul(): 실수와의 곱을 반환
* - mag(): 벡터의 크기를 반환
* - print(): 벡터의 내용을 "(%.3f, %.3f, %.3f)\n" 형식으로 콘솔에 출력
*/
public class Vector3D {
float x;
float y;
float z;
public Vector3D (float x, float y, float z){
this.x = x;
this.y = y;
this.z = z;
}
public void print(){
System.out.printf("(%.3f, %.3f, %.3f)\n",x,y,z);
}
public Vector3D add(Vector3D v){
return new Vector3D(this.x + v.x,
this.y + v.y,
this.z + v.z);
}
public Vector3D add(float f){
return new Vector3D(this.x + f,
this.y + f,
this.z + f);
}
public Vector3D sub(Vector3D v){
return new Vector3D(this.x - v.x,
this.y - v.y,
this.z - v.z);
}
public Vector3D sub(float f){
return new Vector3D(this.x - f,
this.y - f,
this.z - f);
}
public float inner(Vector3D v){
return (this.x * v.x) + (this.y * v.y) + (this.z * v.z);
}
public Vector3D mult(float f){
return new Vector3D(this.x * f,
this.y * f,
this.z * f);
}
public float mag(){
return (float)Math.sqrt((Math.pow(this.x,2) + Math.pow(this.y,2)
+ Math.pow(this.z,2)));
}
public float getX() {
return x;
}
public void setX(float x) {
this.x = x;
}
public float getY() {
return y;
}
public void setY(float y) {
this.y = y;
}
public float getZ() {
return z;
}
public void setZ(float z) {
this.z = z;
}
}
class Vector3DTest {
public static void main(String[] args) {
Vector3D v1 = new Vector3D(0.5f, 0.2f, 0.9f);
Vector3D v2 = new Vector3D(0.8f, 0.1f, 1.3f);
v1.add(v2).print();
v2.sub(v1).print();
v1.add(0.2f).print();
v2.sub(0.05f).print();
System.out.println(v1.inner(v2));
v1.mult(1.2f).print();
System.out.println(v2.mag());
}
}
| [Java]3_4_상속(Inheritance) (0) | 2020.08.18 |
|---|---|
| [Java]3_3_JavaDocs(주석) (0) | 2020.08.18 |
| [Java] 3_2_2_클래스 - 메소드 (0) | 2020.08.09 |
| [Java] 3_2_1클래스(class) (0) | 2020.08.05 |
| [Java] 3_1_객체지향 프로그래밍(O.O.P.) (0) | 2020.08.05 |
매일 매일 공부한 것들을 정리하기 위해 오늘 할일 / 오늘 한일 / 내일 할일 이라는 포멧에 맞춰서 TIL을 적어보려고 합니다. 과목별 내용정리는 기존의 하던 것 들을 유지하면서 오늘 정리한 부분을 링크하는 형식으로 작성하려고 합니다. 화이팅
| 2020년 8월 14일 TIL (0) | 2020.08.17 |
|---|---|
| 2020년 8월 13일 TIL (0) | 2020.08.17 |
| 2020년 8월 12일 TIL (0) | 2020.08.17 |
| 2020년 8월 11일 TIL (0) | 2020.08.17 |
| 2020년 8월 10일 TIL (0) | 2020.08.10 |
class Bar{
// 인스턴스 메소드( 보통 그냥 메소드라고 부름)
// Return type(출력의 자료형)
public int add(int x, int y){ // 입력 파라미터 (메서드 호출시 같이 입력)
return x + y ; //반환 값(Return value)
} // return 값이 있기 때문에 정의가 되있는것이다. 변수는 어떻다고했는데
// int를 반환하는 add라는 메서드인데 int x,y를 입력받는다 => 선언!
//선언(Declaration) - ~한 것이 있다. 실제 구현은 X
//정의(Definition) - 선언 + 구현(초기화)
//정적 메소드(static method), 클래스 메소드
// void return type은 return이 없음.(return이라고 적어도 되지만 안적어도됨)
public static void classMethod(){
System.out.println("클래스메소드 호출");
}
// 실행부
public class Method {
// main 메소드에서 실행이 되는 것은 약속. main메서드도 static 메서드
public static void main(String[] args) {
Bar.classMethod(); //클래스메소드 호출 // 클래스메서드는 바로 콜이됨
//Bar.add(1,2); // 콜이 되지 않음
Bar bar = new Bar(); //Bar 인스턴스를 생성
System.out.println(bar.add(1,2));//3 // bar.add(1,2)가 반환값으로 대치가됨
bar.classMethod(); // 클래스메소드호출// 인스턴스에서 클래스메서드호출 가능 but 권장X
class Person {
static String korWord = "사람";
boolean isHungry = true; // 인스턴스 멤버 변수
// 클래스 메소드
public static void describe(){
System.out.println(korWord+"입니다.");
// 클래스 메소드는 클래스 변수를 사용할 수 있다.
// 단, 객체에 속하는 속성은 사용할 수 없다.
}
// 인스턴스 메소드
public void eat(){
isHungry = false;
}
}
//실행부
Person p1 = new Person(); // p1 변수명 자료형 Person// Person이라는 인스턴스가 할당되어있음
Person p2 = new Person();
// 인스터느 메소드는 객체의 속성을 변화시키는 역할을 한다.
p1.eat(); //메서드 콜
System.out.println(p1.isHungry);//false
System.out.println(p2.isHungry);//true // p1만 먹었기에 p2는 아직 배고픔
Person.describe();//사람입니다. // 특정한 객체의 속성을 바꾸는 역할을 하지 않는다
// static 변수를 변화 시킬수는 있다.클래스 메서드는 클래스 변수의 속성을 변화시킬 수 있지만 인스턴스 변수를 변화시키지 않는다
인스턴스 메서드는 객체의 속성을 변화시키는데 사용된다.
class Foo{
int value;
}
class Bar{
//기본형 변수를 파라미터로 사용한 메서드
public static void swapPrimitive(int x, int y){ // bar에 속성과는 상관없어서 static으로만듬
int temp = x;
x = y;
y = temp;
}
// int x, int y의 사본이 넘어온다.
// 기본형 타입(Primitive type)인 경우에 해당
// call by value : 메소드 호출을 할 때, 값을 복사해서 넘긴다.
// 값을 복사해온 이후에는 외부의 x,y변수와는 상관없는 애가됨. 그래서 밖에 변수가 안변함
// 참조형 변수를 파라미터로 사용한 메서드
public static void swapReference(Foo x, Foo y){
// Foo -> class, class는 참조형 변수// 사본이 아닌 해당 변수를 가르킴
int temp = x.value;
x.value = y.value;
y.value = temp;
}
//실행부
// Call by
int x = 10;
int y = 20;
Bar.swapPrimitive(x, y);
System.out.println(x+","+y); //10,20 // 변화없음 왜? 위에 메서드에 설명
Foo f1 = new Foo();
Foo f2 = new Foo();
f1.value = 10;
f2.value = 20;
Bar.swapReference(f1, f2);
System.out.println(f1.value + "," +f2.value);//20, 10 => 값의 변화에 영향을줌
기본형 변수를 파라미터로 사용할 경우 외부변수의 사본을 가져와서 실행문에 입력
=> 메서드의 결과 값이 외부 변수에 영향을 X => 실행문에 출력값에 변화를 주지 못함
참조형 변수를 파라미터로 사용할 경우 해당 변수를 참조 하기 때문에 메서드의 결과값이 해당 변수에 영향을 줌
=> 실행문에 출력값에 변화
// 여러개의 int를 입력 받는다.
// 입력 받은 결과는 배열로 주어진다.
// 가변 인자(Variable arguments) 인자가 변한다.
public static int sumAll(int... params){
int sum = 0;
for (int val : params){
sum+= val;
}
return sum;
}
// 메소드 오버로딩 Overloading
// 함수명은 같고 입력인자가 다른 메서드
// 입력 인자의 갯수도 다를 수 있다.
public static float sumAll(float... params){
float sum = 0;
for (float val : params){
sum+= val;
}
return sum;
//실행부
System.out.println(Bar.sumAll(2,3,4,1,3,24,346,1,2,34,-123,-12,2));// 287
System.out.println(Bar.sumAll(2.2f,0.2f,3.2f,56.23f));// 287
// println이 자료형에 상관없이 동장하는 이유 = 오버로딩 public class Method {
public static void classMethod() {
System.out.println("클래스 메소드 호출");
}
public void instanceMethod() {
System.out.println("인스턴스 메소드 호출");
}
// main 메소드에서 실행이 되는 것은 약속. main메서드도 static 메서드
public static void main(String[] args) {
//main 메서드에서는 어떻게 클래스 /인스턴스 메서드를 호출 하나 - 퀴즈
classMethod();// 동일 클래스에 속한 클레스 메소드 호출(클래스 명 필요 X)
// 클래스메서드에서는 같은 클래스에 다른 클래스메서드를 바로 호출이 가능함
Method.classMethod();// 생략 안할수도 있음
Method m = new Method(); // 인스턴스 생성 안되어있으니 생성해야함.
m.instanceMethod(); // 인스턴스 메소드 호출public class Constructor {
int x;
int y;
String z; // 3개다 인스턴스 변수
// public Constructor() {} 기본 생성자, 구현하지 않아도 알아서 생긴다.(생략가능)
public Constructor() {
this(1, 2, "");
}
// 실행부
class ConstructorTest {
public static void main(String[] args) {
Constructor c = new Constructor(); // 기본 생성자 호출
//System.out.println(c.x+","+c.y+","+c.z);//0,0,null //기본생성자
// z의 경우, 클래스이기 때문에 null로 초기화 됨
// null -> 아무것도 참조하고 있지 않다. // 참조형 변수의 경우 null로 초기화
System.out.println(c.x + "," + c.y + "," + c.z);//1,2,초기화//생성자 수정 이후
//파라미터 생성자
public Constructor(int x, int y, String z) {
this.x = x; // this는 멤버 변수를 표기하기 위해 사용될 수 있다.
this.y = y;
this.z = z;
}
//생성자는 클래스이름, return이없기에 return type적지 않음
public Constructor(int a, int b) {
this(a, b, ""); // 이전 생성자를 불러오는 this.
//this.는 무조건 첫줄에 사용할 수 있다.
//가장 긴 파라미터를 기준으로 짧은것을 this로 불러올 수 있다.
}
/// 실행부
Constructor c1 = new Constructor(10, 20, "파라미터생성자");
System.out.println(c1.x + "," + c1.y + "," + c1.z); // 10,20,파라미터생성자
Constructor c2 = new Constructor(10, 20);
System.out.println(c2.x + "," + c2.y + "," + c2.z); //10,20,
this는 이전 생성자를 호출할 때 사용됨. 가장 입력인자가 많은 생성자를 this로 호출해 필요한 부분만 따로 초기화 값을 지정해줌
또한 this는 멤버 변수명과 인력인자명이 같을 경우에 멤버 변수를 가르키는 용도로도 사용됨.
this를 사용하는 이유는 코드 중복을 최소화하여 실수를 방지 하기 위하여 사용함 // 중복을 최소로 할 수록 좋은 코드가 됨
-> 정보의 은닉/보호public class GetterSetter {
int x,y;
String z;
float w; // code - generate - GetterSetter
//constructor도 Generate를 통해 만들 수 있다.
//constructor 만들면 기본 생성자가 사라짐.
//만약 둘다 필요하다면 기본생성자를 작성해주면됨
public GetterSetter(){};
public GetterSetter(int x, int y, String z, float w) {
this.x = x;
this.y = y;
this.z = z;
this.w = w;
}
public int getX() {
return x;
}
public void setX(int x) {
if(x>0 && x <= 1000){
this.x=x;
}else{
System.out.println("x should be 1<= x <=1000");
System.out.println("however, you put in x =" +x);
}
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
public String getZ() {
return z;
}
public void setZ(String z) {
this.z = z;
}
public float getW() {
return w;
}
public void setW(float w) {
this.w = w;
}
}
class GetterSetterTest {
public static void main(String[] args) {
GetterSetter g = new GetterSetter();
g. x= 10;
System.out.println(g.x);
g.setX(20);
System.out.println(g.getX()); // 왜이렇게 귀찮게 해?
// 속성에 대한 접근을 개발자가 설정할 수 있음
g.x=20; // 권장되지 않은 접근
g.setX(1111111111);
System.out.println(g.getX());
}
}필요한 변수를 선언한 후 Menu -Code - Generate - Getter, Setter를 선택하여 만들 수 있음
get()메서드는 해당 변수를 불러 오는 메서드이고 set메서드는 해당 변수의 값을 수정할 때 사용하는 메서드
-set()메서드는 조건을 설정해서 조건하에서만 변수의 값을 수정할 수 있게 작성 가능
사용자에게 멤버 변수에 접근을 제한적으로 설정 할 때 사용할 수 있음(값을 수정할수 없거나 불러올 수 없거나)
public class Main {
static int classVar;
static int instancecount;
int instanceVar;
// static initializer
static {
System.out.println("static block1");
classVar = 20; // class variable에만 접근 가능, 객체생성 이전
}
// object initializer
{
System.out.println("block1");
instanceVar = 30;// 객체 생성이후이기 때문에 instanceVar에 접근가능
classVar = 50;// 추천되지 않음, 객체생성이 스태틱에 영양주기에
instancecount++; //예외적으로 전체적으로 관리해주어야 할항목은 넣을 수 있음
}
static{ //2번째 staticinitialze는 첫번째 이후에 바로실행됨
System.out.println("static block2");
classVar = 5;
}
{ // 2번째 object도 마찬가지.. 결국은 동일한 중괄호 안에 있는것과 다르지 않다.
instanceVar =5;
System.out.println("block2");
}
// 초기화 블록을 어디다쓴다고 했지?
}
class MainTest{
public static void main(String[] args) {
//static block 실행(만들어지면서 실행바로됨)
System.out.println((Main.classVar));//20// static block에서 초기화됨
//instance 생성시 initializer 실행
Main main = new Main();
System.out.println(Main.instancecount);
System.out.println(main.instanceVar);//30 // object initialize에서 초기화됨
System.out.println(Main.classVar);//20
Main main2 = new Main();
System.out.println(Main.instancecount); //block1
// block2
// 2
Main main3 = new Main();
System.out.println(Main.instancecount);//block1
// block2
// 3
}
}
| [Java]3_3_JavaDocs(주석) (0) | 2020.08.18 |
|---|---|
| [Java] 3_2_3_클래스 & 메서드 예제 (0) | 2020.08.10 |
| [Java] 3_2_1클래스(class) (0) | 2020.08.05 |
| [Java] 3_1_객체지향 프로그래밍(O.O.P.) (0) | 2020.08.05 |
| [Java] 2_9_문자열(String) & 예제 (0) | 2020.08.05 |
class Car{ // 클래스 이름은 보통 PascalCase로 적는다.
int speed = 0; // 속성 = 멤버 변수
// 속성 : attribute, filed
// 멤버 변수 : member variable
// 같은 개념이지만 컨텍스트에 따라 다르게 부르기도 함 그래서 용어를 익숙하게 알아야함
void move() { // 메소드 (method), (가끔 멤버 함수라고 부르는 사람도잇음), (가끔 함수, 메서드가 더정확한 표현)
speed = 10; // 행위를 구현, 주로 속성을 변경하는 역할
}
}public class Main {
public static void main(String[] args) {
Car carOne = new Car(); // new 키워드로 클래스에서 객체 생성(Instanciation)
// 생성방법 : 자료형은 클래스명 변수명은 camelCase = new 클래스명();
System.out.println(carOne.speed);//0// .으로 속성 접근 가능
carOne.move();
System.out.println(carOne.speed);//10 // move()메서드가 속성을 변경함
Car carTwo = new Car();
System.out.println(carTwo.speed); // 0 // carOne과는 독립적인 객체로 존재함
Car carThree = carOne; // 참조형 객체 (가르키는 객체)
System.out.println(carThree.speed); //10//carThree는 new하지 않았으니 새로운 객체가 생긴 것이 아님
carThree.speed = 5;
System.out.println(carThree.speed);//5
System.out.println(carOne.speed);//5 carThree가 가르키는 carOne의 값이 바뀐 것이 었음!
//carThee와 carOne은 다른 변수이지만 같은 값을 가르키고 있다.
// String은 immutable이기에 참조형 객체이어도 이런 문제가 없다.(수정이 불가하기 때문에)
// 그러나 보통 class는 mutabl이기 떄문에 신경써서 사용해야 함클래스 영역 ( Class area, method area, code area, static area)
스택 영역(Stack area)
힙 영역 (Heap area)
-new 키워드로 생성된 객체(객체의 속성(멤버 변수))
// 메모리 구조 예시
public class MemoryStructure {// 클래스 영역
int x, y; // 힙 영역(new 키워드로 생선된 객체에 속한 변수로 생성됨)
// int x,y의 값은 값이 실제로 힙영역에 메모리가 생성되서 그 값을 담게됨
String string = "String!!!"; // 힙 영역(변수자체는 힙영역에 생성), 상수풀("String!!!"은 상수풀에 생성)
// string은 클래스이기 때문에 값을 생성하는게 아닌 상수풀에 잡힌 값을 참조하는 참조값이 담기게 됨
public void method(int value) {// 클래스 영역'
// int value => 스택 영역 //
char c = 'w'; // 스택 영역
} // 메서드 사용시에 임시로 스택영역에 메모리가 할당되고 메서드 사용 후에 사라지는 영역(지역 변수)
// 참고 : 주소값을 몇bit로 쓰느냐에 따라 32-bit, 64-bit으로 나뉨, 근데 요즘은 대부분 64-bit os를 쓰기 때문에 대부분 64bit
// 메모리 주소를 몇 bit를 쓰느냐에 따라 운영체제가 32-bit 64-bit나뉘고 ram을 4gb이상쓰기위해 64bit os가 주를 이룸// 클래스에서 변수 생성
public class Variables {
static int classVar; // static 자료형 변수명; // 클래스 멤버 변수, 스태틱 변수(정적 변수)
int instanceVar; // 인스턴스 멤버 변수, 필드, 속성
public void method(int paramVar) { // paramVar : 로컬 파라미터 변수
System.out.println(paramVar);
int localVar; // 로컬 변수 // 메서드 안에 속하는 로컬 변수
//System.out.println(localVar); // localVar은 0으로 초기화 안되서 바로 출력 불가
localVar = 10; //메서드 안에서 자유롭게 접근가능
System.out.println(localVar); // 값 대입 후에는 출력가능
{
localVar = 30; // 메소드 안에 {}에서도 접근 가능
int localVar2 =20;
}
System.out.println(localVar); // 블록 내에서 수정한 것도 반영됨
// locaVar2 =40;// {}밖에서 접근 불가, 생명주기가 끝났다. Life-Cycle 끝났다.
}
}// 각 변수에 대한 접근
class variableTest{
public static void main(String[] args){
System.out.println("클래스 변수"); // 클래스에 속하기에 인스턴스 만들지 않아도 존재// 특이 케이스
System.out.println(Variables.classVar);//0 으로 초기화됨 => 어떤 변수는 초기화 하지 않아도 자동으로 된다는 것은 특이한케이스
// 클래스 변수는 0으로 초기화 된다!!
/// 클래스 변수는 클래스 이름으로 바로 접근 가능
Variables.classVar = 10;
System.out.println(Variables.classVar);//10
System.out.println("");
System.out.println("인스턴스 멤버 변수");
Variables var = new Variables();
System.out.println(var.instanceVar);//0 // 인스턴스 변수도 0으로 초기화됨 - 특이 케이스
//Variables.instanceVar // 접근 불가능, 인스턴스 만들어야 객체(실체)가 생기기 때문
var.instanceVar = 20;
System.out.println(var.instanceVar);//20
System.out.println("");
Variables var2 = new Variables();
System.out.println(var2.instanceVar); // 0// 0으로 초기화된 새로운 객체 생성
// System.out.println(var2.classVar);//10// 인스턴스로도 클래스변수에 접근 가능, but 이러한 접근은 권장되지 않음
// 클래스명으로해서 클래스전체에 속한 변수라는 것을 명확히 하며 사용하라는 뜻
System.out.println("");
//Variables.method(); // 잘못된 접근, 객체로 접근해야함
var.method(9);
// System.out.println(var.method(9)); //return값이 있어야 가능함
}
}| [Java] 3_2_3_클래스 & 메서드 예제 (0) | 2020.08.10 |
|---|---|
| [Java] 3_2_2_클래스 - 메소드 (0) | 2020.08.09 |
| [Java] 3_1_객체지향 프로그래밍(O.O.P.) (0) | 2020.08.05 |
| [Java] 2_9_문자열(String) & 예제 (0) | 2020.08.05 |
| [Java] 2_8_2_배열, 다차원 배열 예제 (0) | 2020.08.04 |
클래스, 객체, 메서드
클래스 (class)(틀, 정의)
같은 종류의 집단에 속하는 속성과 행위를 정의한 것
클래스는 다른 클래스 또는 외부 요소와 독립적으로 디자인해야 함
자신(정의) 공유의 속성을 가지며, 클래스에 정의된 행위를 수행(행위=메서드)
사람이라는 클래스에 먹는다는 메서드가 있다면, 사람이라는 개념은 먹지못하지만 실제 존재하는 정한솔은 먹을 수있음
그리고 그외에 사람들은 똑같이 먹을 수 있다. 그리고 각각의 속성을 가진다.
배부르다는 속성이 있다면 각각의 행동에의해 결정됨
그러나 그걸 우리는 묶어서 사람으로 부를수 있다.
메서드(Method)(실체의 동작)
OOP is A.P.I.E(갖추야할 것) oop는 a Pie이다 라고 읽음
Polymorphism(다형성) : 오버로딩과 오버라이딩을 하여 하나의 메소드명으로 다양한 동작을 구현할 수 있음
Encapsulation(캡슐화) : 사용자에게 불필요한 정보를 은닉/ 보호해야 한다.
| [Java] 3_2_2_클래스 - 메소드 (0) | 2020.08.09 |
|---|---|
| [Java] 3_2_1클래스(class) (0) | 2020.08.05 |
| [Java] 2_9_문자열(String) & 예제 (0) | 2020.08.05 |
| [Java] 2_8_2_배열, 다차원 배열 예제 (0) | 2020.08.04 |
| [Java]2_8_1_다차원 배열 연습 (0) | 2020.07.31 |
String s1 = "문자열 생성 방법"; // 보통의 생성 방법, String 변수명 = "값";
String s2 = new String("문자열 생성 방법2"); // 클래스 생성자. 권장하지 않음
String s3 = "abcde"; // String 생성하면 상수풀에 생성됨
String s4 = "abcde"; // 상수풀에 동일한 문자열이 있으면 그것을 참조하고 없으면 생성함
String s5 = new String("abcde"); // 흙빛이 되어버림.. 구지 생성한다고?// 힙메모리에 생성하는건가?
System.out.println(s3 == s4); //true // 문자열을 곧바로 생성할 경우 상수 풀에서 찾아 사용
// String은 immuntable하기에 같은값을 참조해도 문제가 발생하지 않음
System.out.println(s3 == s5); //false // 문자열을 클래스로 생성할 경우 새로운 값을 생성
System.out.println(s3.equals(s4));//true // equals는 무슨 메서드였지? -> String 값비교 메서드.
System.out.println(s3.equals(s5));//true String s = "This is a string.";
System.out.println(s.length()); //16 //length 같이 이름만들어도 기능이 예상되는게 잘지은 이름이다.
//이름을 짓기 어려운 기능은 메서드로 만들지 않는 것이 좋다.
System.out.println(s.charAt(2));//i
System.out.println(s.indexOf('a'));//8 // a가 몇번 인덱스에 위치하는가?
System.out.println(s.equalsIgnoreCase("this Is A STRiNg."));//true//문자열비교해서 같은면true
// 대소문자 구분x
System.out.println(s.replace('i','t'));//Thts ts a strtng.//기존의 String을 바꾸는것은 아님
//변경된 String을 생성해서 출력하는 것
System.out.println(s);//This is a string.// 기존 내용 유지
System.out.println(s.substring(3, 9));//s is a // index 3~8번까지 출력해줌(마지막 인덱스 제외)
System.out.println(" wwefw ".trim());//wwefw// 양옆의 공백 제거해주는 메소드
System.out.println("*".repeat(10));//********** //문자열을 반복해줌
// 추가적인것은 더 찾아서 사용하면 된다.
char[] characters = s.toCharArray();
for(char value : characters){
System.out.println(value);
} // String의 배열을 불러온것이 아닌 새로운 배열을 만든것임// so 여기 배열 내용 변경시켜도 원문에 변화없음/**
* 도메인 뒤집기
*
* 주어진 홈페이지 주소를 .을 기준으로 각각 뒤집어 출력하시오.
*
* ex) www.google.com -> www.elgoog.moc
*
* 인자
* string: 홈페이지 주소
*/
public class DomainReverse {
public static void main(String[] args) {
//
// // #1 replace()
// String string = "www.google.com";
//
// System.out.println(string.replace("google.com","elgoog.moc"));
//
// // #2 split()
//
// String[] strA = string.split("\\.",0);
//
// for (int i = 0; i <strA.length;i++){
//
// for(int j = strA[i].length()-1 ; j>=0 ; j-- ) {
// System.out.print(strA[i].charAt(j));
// }
// if(i != strA.length-1){
// System.out.print('.');
// }
// }
// System.out.println("");
//
// // #3 String Buffer
//
// for(int i = 0 ; i < strA.length;i++ ){
// StringBuffer sBuffer = new StringBuffer(strA[i]);
// System.out.print(sBuffer.reverse());
// if(i != strA.length-1){
// System.out.print('.');
// }
// }
//
//풀이 예시
String string = "www.google.com";
int i = string.indexOf('.'); // 처음 점 찾기
StringBuilder s = new StringBuilder(string.length());// ()안에 길이를 설정.
while (i > 0) {
StringBuilder s_ = new StringBuilder(string.substring(0, i));//0 ~ i-1까지 짜름// www
string = string.substring(i + 1);// gooogle.com
s.append(s_.reverse());//www을 뒤짚음
s.append('.');
i = string.indexOf('.');
}
s.append(new StringBuilder(string).reverse());// 마지막꺼 뒤짚기기
string = s.toString();// string빌더를 string으로 바꿔주기
System.out.println(string);
}
}
| [Java] 3_2_1클래스(class) (0) | 2020.08.05 |
|---|---|
| [Java] 3_1_객체지향 프로그래밍(O.O.P.) (0) | 2020.08.05 |
| [Java] 2_8_2_배열, 다차원 배열 예제 (0) | 2020.08.04 |
| [Java]2_8_1_다차원 배열 연습 (0) | 2020.07.31 |
| [Java]2_8_다차원 배열 (N-D Arrays) (0) | 2020.07.31 |
/**
* 행렬의 곱 계산하기
*
* 두 행렬의 곱을 구하는 프로그램을 작성하시오.
* 행렬의 곱을 계산한 후에 행렬 형태로 출력하시오.
*
*
* 인자
* matA: N x M 행렬
* matB: M x K 행렬
*/
public class MatMul {
public static void main(String[] args) {
// int[][] matA = {{1, 2, 3}, {4, 5, 2}};
// int[][] matB = {{5, 2}, {6, 2}, {1, 0}};
// int[][] mulMat = new int[matA.length][matB[0].length];
//
// // mulMat (0,0) (1,1) 곱셈
// for(int i = 0; i<matA.length; i++){
// for(int j = 0; j<matA[0].length; j++){
// mulMat[i][i*1] += matA[i][j] * matB[j][i];
//
// }
// }
// // mulMat (1,0)(0,1) 곱셈
//
// for(int i = 0; i<matA.length; i++){
// for(int j = 0; j<matA[0].length; j++){
// mulMat[i][1-(i*1)] += matA[i][j] * matB[j][1-(i*1)];
// }
// }
// // mulMAt 출력
// for(int[] array : mulMat){
// for(int val : array){
// System.out.printf("%d ",val);
// }
// System.out.println("");
// }
//풀이 예시
//3X2 2X3, 가운데 2를 하나의 축으로 활용해서 풀면된다는데...
int [][] matA = {{1, 2, 3} ,{4, 5, 2}};
int [][] matB = {{5, 2}, {6, 2}, {1, 0}};
int [][] matC = new int[matA.length][matB[0].length];
for (int i = 0; i < matC.length; i++) {
for (int j = 0; j < matC[i].length; j++) {
for (int k = 0; k < matA[0].length; k++) {
matC[i][j] += matA[i][k] * matB[k][j];
}
}
}
for (int [] row: matC) {
for (int val: row) {
System.out.printf("%d\t", val);
}
System.out.println("");
}
}
}
/**
* 배열의 연속합 최대 구하기
*
* 정수 배열에서 연속된 값의 합의 최대값을 구하시오.
*
* ex1) {1, 45, -2, 5, -6} => 1 + 45 + (-2) + 5 = 49
* ex2) {-4, 5, 12, -7, 52, -5, 7} => 52
*
*
* 인자
* * integers: 정수 배열
*/
public class MaxSum {
public static void main(String[] args) {
// int [] integers = {-4, 7, 14, 9, -5, 4, 16, -22, 31};
// int [] sum = new int[9];
// int maxValue = 0;
//
// for(int i= 0; i < integers.length; i++){
//
// if(i==0){
// sum[i] = integers[i];
// } else{
// sum[i] = integers[i] + sum[i-1];
// maxValue= maxValue > sum[i] ? maxValue : sum[i];
// System.out.println(sum[i]);
// }
//
// }
// System.out.println("연속된 값의 합의 최대값 : "+maxValue);
//풀이 예시
//2개의 변수를 통해 풀수 있다.
//나는 무조건 앞에것을 더햇는데 앞에 자리를 자를수 있다느것을 생각못햇네?
int [] integers = {-4, 7, 14, 9, -5, 4, 16, -22, 31};
int maxSum = 0;
int currentSum = 0;
for (int elem: integers) {
currentSum += elem;
currentSum = currentSum > elem ? currentSum : elem; // 이전에 더한값보다 지금 더하는값이 더큰가?
maxSum = maxSum > currentSum ? maxSum : currentSum;
}
System.out.println(maxSum);
}
}| [Java] 3_1_객체지향 프로그래밍(O.O.P.) (0) | 2020.08.05 |
|---|---|
| [Java] 2_9_문자열(String) & 예제 (0) | 2020.08.05 |
| [Java]2_8_1_다차원 배열 연습 (0) | 2020.07.31 |
| [Java]2_8_다차원 배열 (N-D Arrays) (0) | 2020.07.31 |
| [Java] 2_7_1_배열 연습 (0) | 2020.07.31 |
int [][] matA = {{1,2,3},{3,4,5}};
int [][] matB = {{3,4,5},{1,4,2}};
int [][] mulMat = new int[matA.length][matA[0].length];
// 1. matA + maB를 구하고, 출력하시오
// 내풀이
for(int i=0; i<matA.length;i++){
for(int j=0; j<matA[i].length; j++){
mulMat[i][j] = matA[i][j] * matB[i][j];
System.out.printf("%d ",mulMat[i][j]);
}
System.out.println("");
}
System.out.println("");
// 2. matA를 Transpose하고 출력하시오.
// 행열이 반전되어서 만들어지는 배열
// ex
// 1 2 3
// 4 5 6
// 1 4
// 2 5
// 3 6
int[][] matA_ = new int[matA[0].length][matA.length];
for(int i = 0 ; i < matA.length; i++){
for (int j = 0; j < matA[0].length;j++){
matA_[j][i] = matA[i][j];
}
System.out.println("");
}
for(int[] array: matA_){
for(int val : array){
System.out.printf("%d ",val);
}
System.out.println("");
}
}
}
| [Java] 2_9_문자열(String) & 예제 (0) | 2020.08.05 |
|---|---|
| [Java] 2_8_2_배열, 다차원 배열 예제 (0) | 2020.08.04 |
| [Java]2_8_다차원 배열 (N-D Arrays) (0) | 2020.07.31 |
| [Java] 2_7_1_배열 연습 (0) | 2020.07.31 |
| [Java] 2_7_배열 (Arrays) (0) | 2020.07.31 |
// 다차원 배열의 선언
int[][] ints; // int array를 담고있는 array// java-like
int[] halfCStyle[]; // hybrid
int oldCStyle[][]; // old...
int [][] ints1 = new int[10][5]; // 길이가 5인 intArray를 담고있는 길이가 10인 intArrary
// 앞에 있는 숫자가 더 큰 차원의 수
int [][] ints2 = new int[10][];
for(int i = 0; i< ints2.length; i++){
ints2[i] = new int[5];
}
int[][] ints3 = new int[5][]; // 하위 차원의 길이는 달라질 수 있다.
ints3[0] = new int[10];
ints3[1] = new int[8];
ints3[2] = new int[4];
ints3[3] = new int[15];
ints3[4] = new int[9];
int[][] ints4 = {{1, 2, 3}, {4, 5, 6}}; // int[2][3] 길이가 3인 intArray가 2개가 있다.
int[][] ints5 = {{1, 3 ,2}, {1,2}, {4,5,3}}; // int[3][]// 다차원 배열과 반복문
for (int i =0; i < ints5.length; i++){ //ints5.length = 3
System.out.printf("[%d] :", ints5[i].length);
for(int j = 0; j < ints5[i].length; j++){ //ints5[i].length 3, 2, 3
System.out.printf("%d ", ints5[i][j]);
}
System.out.println("");
}
for(int[]array : ints5){ //1차원 배열을 array[]로 가져옴
for (int val: array){ //1차원 배열의 값을 val에 입력
System.out.printf("%d ", val);
}
System.out.println("");
}| [Java] 2_8_2_배열, 다차원 배열 예제 (0) | 2020.08.04 |
|---|---|
| [Java]2_8_1_다차원 배열 연습 (0) | 2020.07.31 |
| [Java] 2_7_1_배열 연습 (0) | 2020.07.31 |
| [Java] 2_7_배열 (Arrays) (0) | 2020.07.31 |
| [Java] 2_6_2_반복문 예제 (0) | 2020.07.31 |
int[] integers = {4, 5, 7, 34, 52, 32, 67, 12, 44};
//1. 위 배열에서 최대값을 찾는 프로그램을 작성하시오.
int maxVal = integers[0];
for (int i = 0; i < integers.length; i++) {
maxVal = integers[i] > maxVal ? integers[i] : maxVal;
}
System.out.println("최대값 : "+maxVal);
maxVal = integers[0];
for (int val : integers) {
maxVal = maxVal > val ? maxVal : val;
}
System.out.println("최대값 : "+maxVal);
// 2. 위 배열에서 2번재로 큰 값을 찾는 포르그램을 작성 하시오.
// 내 방법
int secondVal = integers[0];
for (int i = 0; i < integers.length; i++) {
if (integers[i] == maxVal) {
continue;
}else {
secondVal = integers[i] > secondVal ? integers[i] : secondVal;
}
}
System.out.println("두번째로 큰 값 :"+secondVal);
//Enhanced for활용
secondVal = integers[0];
for(int val : integers) {
if (val == maxVal) {
continue;
} else {
secondVal = secondVal > val ? secondVal : val;
}
}
System.out.println("두번째로 큰 값 :"+secondVal);
//풀이 예시
int [] maxVals = new int[2];
for(int val : integers) {
if(maxVals[0] < val) {
maxVals[1] = maxVals[0];
maxVals[0] = val;
}else if(maxVals[1] < val){
maxVals[1] = val;
}
}
System.out.println("두번째로 큰 값 :" + maxVals[1]);
| [Java]2_8_1_다차원 배열 연습 (0) | 2020.07.31 |
|---|---|
| [Java]2_8_다차원 배열 (N-D Arrays) (0) | 2020.07.31 |
| [Java] 2_7_배열 (Arrays) (0) | 2020.07.31 |
| [Java] 2_6_2_반복문 예제 (0) | 2020.07.31 |
| [Java] 2_6_1_반복문 연습 (0) | 2020.07.31 |
int intval;
int[] integers;
// int cStyleInteger[]; // 배열선언가능하나 가독성때문에 안쓰임//쓰지마
long[] longs;
char[] chars;
String[] strings;
new 자료형[배열의크기] 로 초기화 함
혹은 바로 {}안에 값을 입력하여 초기화 하기도함
// 배열의 생성과 초기화
integers = new int[10]; // 선언된 배열을 초기화
int[] integers2 = new int[10]; // 선언과 동시에도 가능
integers2[0] = 5;
integers2[1] = 10;
integers2[3] = 9;
// 값을 넣을 때 순차적으로 하지 않아도 된다.
System.out.println(integers2[0]);
System.out.println(integers2[1]);
System.out.println(integers2[2]); // 0으로 자동으로 초기화// 입력없으면=0
System.out.println(integers2[3]);
System.out.println("");
int[] integers3 = new int[]{5, 2, 3, 6, 12, 4}; // 바로 입력할 때는 길이 입력 안해도 된다.
System.out.println(integers3[0]);
System.out.println(integers3[1]);
System.out.println(integers3[2]);
System.out.println(integers3[3]);
System.out.println(integers3[4]);
System.out.println(integers3[5]);
// System.out.println(integers3[6]);// ArrayIndexOutOfBoundsException 오류 발생
//배열 사용할 때에는 선언해 준 길이까지만 접근해야 한다.
int[] integers5 = {1, 4, 5, 23, 0}; // new int[] 안 붙여도 된다. // 배열을 반복문으로 접근
float[] floats = new float[5];
for (int i = 0; i < floats.length; i++) { // for문을 이용한 초기화, new할때도 초기화지만 처음값넣을때도 초기화//혼용 사용
floats[i] = (float) (i * 0.25);
}
// for문을 통한 배열 출력
for (int i = 0; i < floats.length; i++) {
System.out.println(floats[i]);
}
// Enhanced for, for each문이라고도 함
// 배열에 접근하는 다른 방법
// for(자료형 변수명 : 배열명){ 배열0부터 끝까지 값을 floatVal에 대입해줌)
for(float floatVal: floats){
System.out.println(floatVal);
}
// 밑에 for문과 같은 역할을 함
for(int i = 0 ; i < floats.length; i++){
float floatVal = floats[i];
System.out.println(floatVal);
}
int [] src = {1, 2, 3, 4, 5};
int [] dst = new int[10];
for(int i = 0; i< src.length; i++){
dst[i] = src[i];
}
for(int integer : dst){
System.out.println(integer);
}
// 배열 크기변경은 빈번하기에 크기변경 함수 존재
int[] src2 = {1, 2, 3, 4, 5};
int[] dst2 = new int[10];
System.arraycopy(src2,0,dst2,0,src2.length);//arraycopy(어디에서,몇번째부터, 어디로, 몇번째부터,어디까지)
for(int integer: dst2){
System.out.println(integer);
}| [Java]2_8_다차원 배열 (N-D Arrays) (0) | 2020.07.31 |
|---|---|
| [Java] 2_7_1_배열 연습 (0) | 2020.07.31 |
| [Java] 2_6_2_반복문 예제 (0) | 2020.07.31 |
| [Java] 2_6_1_반복문 연습 (0) | 2020.07.31 |
| [Java] 2_6_반복문 (Loops) (0) | 2020.07.31 |
public class Fibonacci {
/**
* 피보나치 수열
*
* 피보나치 수열을 출력하는 프로그램을 작성하시오.
*
* 피보나치 수열의 점화식 : f(n) = f(n-1) + f(n-2)
* f(1) = 0, f(2) = 1
*
* 0, 1, 1, 2, 3, 5, 8, ...
*
* 인자
* seqLength: 출력하고자 하는 피보나치 수열의 길이
*/
public static void main(String[] args) {
int seqLength = 100;
double previousNum = 0;
double nextNum = 1;
for(int i = 0 ; i < seqLength; i++) {
System.out.printf("1.%.0f\n",previousNum);
double sum = previousNum + nextNum;
previousNum = nextNum;
nextNum = sum;
}
}
}
/**
* 369게임+
* <p>
* 369게임에 참여했을 때, 내가 외쳐야 하는 숫자나 동작을 순서대로 출력하시오.
* <p>
* 규칙
* 1. 3, 6, 9, 5가 포함 되지 않은 숫자는 숫자를 외친다. (2!)
* 2. 숫자에 포함된 3, 6, 9의 개수 만큼 박수를 친다. (짝!)
* 3. 숫자에 포함된 5의 개수 만큼 발을 구른다. (쿵!)
* 4. 박수와 발구르기의 순서는 관계 없으나, 반드시 번갈아 수행한다.
* <p>
* 예시
* 2 -> 2!
* 33 -> 짝!짝!
* 553 -> 쿵!짝!쿵! (짝!쿵!쿵!x)
* 47 -> 47!
* <p>
* 인자
* gameLength: 게임이 종료되는 데 걸리는 턴 수
* numPeople: 게임에 참여하는 인원 수
* myTurn: 내가 숫자를 외치는 순번
*/
public static void main(String[] args) {
int gameLength = 1000;
int numPeople = 12;
int myTurn = 3;
for(int i = myTurn ; i < numPeople; i+=numPeople){
int numClap = 0;
int numFoot = 0;
int intVal = i;
while(intVal >0 ){
int currentVal = intVal % 10;
if (currentVal == 3 || currentVal ==6 || currentVal==9 ){
numClap++;
}else if (currentVal == 5){
numFoot++;
}
intVal /= 10;
}
if(numClap + numFoot == 0){
System.out.println(i);
} else {
if(numClap>numFoot){
while(numClap>0||numFoot>0){
if (numClap>0){
System.out.println("짝!");
numClap--;
}
if (numFoot>0){
System.out.println("쿵!");
numFoot--;
}
}
} else {
while(numClap>0||numFoot>0){
if (numFoot>0){
System.out.println("쿵!");
numFoot--;
}
if (numClap>0){
System.out.println("짝!");
numClap--;
}
}
}
System.out.println("");
}
}| [Java] 2_7_1_배열 연습 (0) | 2020.07.31 |
|---|---|
| [Java] 2_7_배열 (Arrays) (0) | 2020.07.31 |
| [Java] 2_6_1_반복문 연습 (0) | 2020.07.31 |
| [Java] 2_6_반복문 (Loops) (0) | 2020.07.31 |
| [Java] 2_5_조건문 (Conditional Statements) (0) | 2020.07.31 |
/**
* 반복문/조건문 연습
*
*/
/**
*
*/
public static void main(String[] args) {
// 예제1
/**
* **********
* **********
* **********
* **********
*/
for(int i = 0 ; i<4 ; i++){
for(int j =0; j< 10; j ++)
System.out.print("*");
System.out.println("");
}
//예제2
/**
* *
* **
* ***
* ****
* *****
*/
for(int i = 0; i<5; i++){
for(int j =0 ; j < i+1; j++ ){
System.out.print("*");
}
System.out.println("");
}
//예제3
/**
* *
* **
* ***
* ****
* *****
*/
for(int i = 0; i<5; i++){
for(int j = 0 ; j < 4-i; j++ ){
System.out.print(" ");
}
for(int p = 0; p<i+1; p++) {
System.out.print("*");
}
System.out.println("");
}
//예제 4
/**
* *
* ***
* *****
* *******
* *********
*/
for(int i = 0; i<5; i++){
for(int j =4 ; j > i; j-- ){
System.out.print(" ");
}
for(int p = 0; p<(2*i)+1; p++) {
System.out.print("*");
}
System.out.println("");
} //예제 5
/**
* 1
* 222
* 33333
* 4444444
* 555555555
*/
for(int i = 0; i<5; i++){
for(int j =4 ; j > i; j-- ){
System.out.print(" ");
}
for(int p = 0; p<(2*i)+1; p++) {
System.out.print(i+1);
}
System.out.println("");
} // 예제6
/**
* 1
* 212
* 32123
* 4321234
* 543212345
*/
// 내방법
for(int i = 0; i<5; i++){
for(int j =4 ; j > i; j-- ){
System.out.print(" ");
}
for(int p = 0; p<(2*i)+1; p++) {
if(p>i){
continue;
}
System.out.print(i+1-p);
}
for(int q=0; q<i; q++){
System.out.print(2+q);
}
System.out.println("");
}
// 풀이 예시1
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 4 - i;j++) {
System.out.print(' ');
}
for (int j = 0; j < 2 * i + 1; j++) {
System.out.print(j - i > 0 ? j - i + 1 : i - j + 1);
}
System.out.println("");
}
// 풀이 예시2
for (int i = 0; i < 5; i++) {
for (int j = 5; j > 1; j--) {
if (j <= i + 1) {
System.out.print(j);
} else {
System.out.print(' ');
}
}
for (int j = 1; j <= 5; j++) {
if (j <= i + 1) {
System.out.print(j);
} else {
System.out.print(' ');
}
}
System.out.println("");
}
//다양하게 코드 쓸수있지만 다 쓸 수 있는 코드는 아니다
//어떤 것이 쓸수 있는 코드인지는 판단능력을 길러야한다. /**
* 369 게임
* 기본형 (순서대로 다 출력, 짝! 하는거는 3,6,9 나오면 한번만)
* 1부터 시작해서 20까지
*/
for(int i = 1; i<= 10; i++){
if(i % 3 == 0){
System.out.println("짝!");
}else {
System.out.println(i);
}
}; /**
* 순서대로 다 출력,1 ~ 30까지
*
*/
for(int i =1; i<=30 ; i++){
int num1 = i % 10;
int num2 = i / 10;
if(num1 ==3 || num1 ==6 || num1 == 9 ||
num2 ==3 || num2 ==6 || num2 == 9 ){
System.out.println("짝!");
} else{
System.out.println(i);
}
} /**
* 369
* 5명 같이하고, 내가 1번
* 3,6,9가 여러개 있으면 해당 횟수만큼 짝!
* 1 ~ 60;
*/
for(int i = 1; i<=60; i += 5) {
int num1 = i % 10;
int num2 = i / 10;
int numClap = 0;
if(num1 ==3 || num1 ==6 || num1 == 9 ) {
numClap++;
}
if(num2 == 3 || num2 ==6 || num2 == 9 ){
numClap++;
} if (numClap == 0) {
System.out.println(i);
} else{
for (int j = 0; j <numClap; j++){
System.out.print("짝!");
}
System.out.println("");
}
} /**
* 내가 1번, 8명이 같이 합니다.
* 짝 을 여러번 해요
* 10의 배수에는 다같이 만세를 외칩니다.
* 1 ~99
*/
for(int i = 1; i<=99; i ++) {
int num1 = i % 10;
int num2 = i / 10;
int numClap = 0;
if (i % 10 == 0){
System.out.println("만세!");
continue;
}
if((i-1)% 8 !=0){
continue;
}
if(num1 ==3 || num1 ==6 || num1 == 9 ) {
numClap++;
}
if(num2 == 3 || num2 ==6 || num2 == 9 ){
numClap++;
} if (numClap == 0) {
System.out.println(i);
} else{
for (int j = 0; j <numClap; j++){
System.out.print("짝!");
}
System.out.println("");
}
}| [Java] 2_7_배열 (Arrays) (0) | 2020.07.31 |
|---|---|
| [Java] 2_6_2_반복문 예제 (0) | 2020.07.31 |
| [Java] 2_6_반복문 (Loops) (0) | 2020.07.31 |
| [Java] 2_5_조건문 (Conditional Statements) (0) | 2020.07.31 |
| [Java] 2_예제1 (0) | 2020.07.29 |
# 반복문 (Loops)
- 종류로는 for 문, while 문 등이 있음
- 초기화 - 반복문을 실행하기 위해서 증감할 변수를 초기화
- 조건식 - 반복문을 실행할 조건(또는 종료할 조건)
- 실행문 - 조건식이 참(또는 거짓)일 경우 실행할 코드
- 증감식 - 실행문이 실행된 후에 변수에 증감을 주는 것
## for문
- for(초기화;조건식;증감식){실행문}
- 초화는 처음 한번만 , 다음 반복에서는 바로 증감식으로 감
- i=0으로 시작 하는 이유는 유구한 전통, 배열과 연관됨
```
for (int i = 0; i < 5; i++) {
System.out.println(i);
}
System.out.println("");
// 증감식에도 대입연산자가 들어갈 수 있음
for (int i = 0; i < 5; i += 2) {
System.out.println(i);
}
System.out.println("");
// 4~0 을 출력
for (int i = 4; i >= 0; i--) {
System.out.println(i);
}
System.out.println("");
```
### Nested for 문
- Nested if 문과 같이 for문이 중첩된 형태
- i=0 일때 j가 0~5까지 증가 하는 것을 i =5일때까지 반복하는 반복문
```
// nested for (중첩된 for문)
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
System.out.printf("(%d, %d)\n", i, j);
}
} // 5*5 = 25
```
### for문 유의사항
- for문 다음에 중괄호를 안쓰면 for문 코드 한줄만 실행됨
= 그 그것을 확장 하기 위해 {}을 사용해서 {}안에 코드를 다 실행함
```
for (int i = 0; i < 5; i++)
System.out.print(i); // iterated -용어기억
System.out.println(""); //not iterated(반복되다)
```
## while 문
- for문의 초기화 문이 바깥으로가고 실행문 증감식이 수행문안쪽으로 들어온 형태의 반복문
- for문과의 차이점으로 while문에서 int i는 반복문 밖에서 선언 되어서 코드전체에서 사용불가
- 반면 for문에서 선언된 int i 는 지역변수로 for문안에서만 사용되기에 재사용 가능
```
int i = 0;
// while (i<5) {
// System.out.println(i);
// i++;
// }
```
## 제어문 - break, continue 문
- 제어문(반복문,조건문)에서 countinue문을 만나면 수행문을 더이상 수행하지 않고 바로 증감식으로 올라감
- break문을 만나면 제어문을 빠져나감.
- label을 설정하면 nested 제어문에서 가까운 제어문이 아닌 원하는 위치의 제어문으로 break하거나 continue할 수 잇음
- label은 변수와 같이 이름을 설정할 수 있음
```
for (int i = 0; i < 10; i++) {
if (i == 3) {
continue;
}
System.out.println(i);
}
for (int i = 0; i < 10; i++) {
if (i == 3) {
break;
}
System.out.println(i); // if문과 함께 사용됨.
}
// label
outer:
for(int i = 0; i<5 ; i ++){
for (int j = 0; j < 5; j ++){
if(i ==3 ){
System.out.println("continue called");
continue outer;
}
System.out.printf("%d * %d = %d\n", i, j, i*j);
}
}
```
| [Java] 2_6_2_반복문 예제 (0) | 2020.07.31 |
|---|---|
| [Java] 2_6_1_반복문 연습 (0) | 2020.07.31 |
| [Java] 2_5_조건문 (Conditional Statements) (0) | 2020.07.31 |
| [Java] 2_예제1 (0) | 2020.07.29 |
| [Java]2_4_연산자 (Operators) (0) | 2020.07.29 |
String snum = "510225-2055132";
char c = snum.charAt(7);
System.out.println(c);
// if (bollean) {true일때 실행문}
if(c=='1' ) {
System.out.println("남자 입니다.");
}
if(c=='1' || c == '3') {
System.out.println("남자 입니다.");
} else {
System.out.println("여자 입니다.");
}
int x = 6; // 1 2 3 6
if (x % 2 == 0) {
System.out.println("짝수 입니다.");
} else {
System.out.println("홀수 입니다.");
}
System.out.println(x % 2 == 0 ? "짝수 입니다." : "홀수 입니다");
// 둘 중에 어떤 코드가 나은 코드냐 하면 상황에 따라 다르다 라고 답할수 있음
// 근데 나중에 코드컨벤션에 의해 코드를 줄일 때 유용할 수 있음int score = 2;
char grade;
if (score>= 9) {
grade = 'A';
} else if ( score >= 7) {
grade = 'B';
} else if ( score >= 5) {
grade = 'C';
} else if ( score >= 3) {
grade = 'd';
} else {
grade = 'F';
}
System.out.println(grade);score = 90;
boolean isLate = true;
// late인 경우에는 하나 낮은 그레이드를 주기로 하였다.
if(score >= 90){
if (isLate){
grade = 'B';
} else {
grade = 'A';
}
} else if (score >= 80) {
if (isLate){
grade = 'C';
} else {
grade = 'B';
}
} else if (score >= 70) {
if (isLate){
grade = 'D';
} else {
grade = 'C';
}
} else if (score >= 60) {
if (isLate){
grade = 'F';
} else {
grade = 'D';
}
} else{
grade = 'F';
}
System.out.println(grade); switch(grade) {
case 'A':
System.out.println("휼륭합니다!"); // fall - through//라고 주석해주어야함
case 'B':
System.out.println("멋집니다!");
break;
case 'C':
case 'D':
System.out.println("많이 노력하세요!");
break;
default :
System.out.println("다음엔 잘하세요.");
}| [Java] 2_6_1_반복문 연습 (0) | 2020.07.31 |
|---|---|
| [Java] 2_6_반복문 (Loops) (0) | 2020.07.31 |
| [Java] 2_예제1 (0) | 2020.07.29 |
| [Java]2_4_연산자 (Operators) (0) | 2020.07.29 |
| [Java] 2_3_자료의 입출력 (Inputs and Outputs) (0) | 2020.07.28 |
문제1)
import java.util.Scanner;
public class Main {
/**
* 환자 레코드 출력하기
*
* 환자 레코드를 열전사 프린터로 보기좋게 프린트하려 한다.
* 환자의 ID, 환자의 병명, 그리고 비고 사항을 입력받아
* 포맷에 맞게 출력하는 프로그램을 작성하시오.
*
* 제한 사항
* - 환자의 ID는 1 이상 999999 이하의 정수로 입력된다고 가정한다.
* - 환자의 병명은 5자 이하의 문자열로 입력되며, 좌측 정렬하여 출력한다.
* - 비고 사항은 10자 이하의 문자열로 입력되며, 좌측 정렬하여 출력한다.
*
* 출력 포맷
* *----------*--------*---------------*
* | ID004029 | 코로나19 | 자가 격리 조치 |
* *----------*--------*---------------*
*
*/
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("ID 입력(1~999999) :");
int patientID = scanner.nextInt();
System.out.println("병명 입력(5자 이하) :");
String nameOfaDisease = scanner.next();
System.out.println("비고 사항(10자 이하) :");
String note = scanner.next();
System.out.println("*----------*--------*---------------*");
System.out.printf("|ID %06d | %-5s | %-10s |\n",patientID,nameOfaDisease,note);
System.out.println("*----------*--------*---------------*");
}
}- nextInt를 엔터로 입력받기 위해서 nextLine()을 한줄 추가 해주었다
문제2)
import java.util.Scanner;
public class InputOutput {
/**
* 입력받아 처리하기
*
* 3개의 정수를 입력받아, 그 중 최대값을 출력하고자 한다.
* 이를 수행하는 프로그램을 작성하시오.
*
*/
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("최대값을 구할 숫자 3개를 입력하시오");
int a = scanner.nextInt();
int b = scanner.nextInt();
int c = scanner.nextInt();
int val_MAX = a > b ? a :b;
val_MAX = val_MAX > c ? val_MAX : c;
System.out.println(val_MAX);
}
}- 여러개의 변수가 아닌 val_MAX변수 하나로 2가지 식을 다구할 수 있었다(변수 줄여서 사용하기)
문제3
import java.util.Scanner;
public class RingCounter {
/**
* 링카운터 출력기
*
* 크기가 4인 링카운터는 아래와 같이 동작한다.
*
* 0b0001 -> 0b0010 -> 0b0100 -> 0b1000 -> 0b0001 ...
*
* 즉, 링카운터는 하나의 비트만 1의 값을 가지며 1의 위치가 N번마다 반복되는 형태로 동작한다.
*
* 링카운터의 크기 numBits 와 카운트된 횟수 numCount를 이용하여
* 현재 링카운터의 값을 10진수로 출력하는 프로그램을 작성하시오.
*/
public static void main(String[] args){
int numBits = 12;
int numCount = 19;
int currentCount = (numCount - 1) % numBits;
System.out.println(1 << currentCount);
}
}
- 입력필요없는 문제에서 불필요하게 Scanner 넣엇던 것 수정하였음
- 불필요한 변수 생성 줄이고 출력문에서 shift를 해주었음
- 모듈러스 연산자와 비트 연산자를 활용하는 문제 였음
| [Java] 2_6_반복문 (Loops) (0) | 2020.07.31 |
|---|---|
| [Java] 2_5_조건문 (Conditional Statements) (0) | 2020.07.31 |
| [Java]2_4_연산자 (Operators) (0) | 2020.07.29 |
| [Java] 2_3_자료의 입출력 (Inputs and Outputs) (0) | 2020.07.28 |
| [Java] 2_2_자료형(Data Type) (0) | 2020.07.28 |
int x = 10, y = 20, z;
z = x + y; // +: 연산자(동사), x:피연산자, y:피연산자, x+y:연산식(expression)
// 항이 2개있는 연산자 = 이항 연산자, 항=피연산자
// =:연산자, z:피연산자, x+y : 피연산자(연산식이 피연산자가됨)
//연산자들간에 우선순위가 있기 때문에 =이 앞에 있지만 가장 늦게 연산된다
System.out.println(z); //30 System.out.println("정수형 사칙 연산");
System.out.println(20 -5); // 15
System.out.println(5-20); // -15
System.out.println(10 * 662); //6620
System.out.println(150 / 8); //18, 정수의 나눗셈은 몫만 나옴, 사라지는 수는 &로 구함
System.out.println(150 & 8); // modulus,(모듈러스연산) 나머지 구하는 연산자
System.out.println("실수형 사칙 연산");
System.out.println(10.0 + 52.3);
System.out.println(10.5f + 12.3); //float이 double로 자동으로 변환되서 계산됨
System.out.println(10.4 - 50);//정수와 실수의 계산에서는 실수형으로 변환후 연산
System.out.println(10.2 * 4.2);// 42.839999
System.out.println(150 / 8.0); //18.75, 정수/실수이기에 실수로 변환 되서 몫이 아닌 실수값이 나옴
System.out.println(5.2 / 1.2); // 몫이 아닌 실수값
System.out.println(5.2 % 1.2);// 실수도 modulus 연산으로 나머지 계산 가능
//0.4가 나와야되는데 소숫점 조금더나오는데 그건 부동소수점 오차
System.out.println(""); System.out.println("사칙연산 주의사항");
//overflow가 있음
System.out.println(Integer.MAX_VALUE /2 *3); //-1073741827,값이 overflow되버림
System.out.println(Integer.MAX_VALUE); //최대값
System.out.println(Integer.MAX_VALUE+1); // 최대값+1 = 최소값
System.out.println(Integer.MIN_VALUE); // 최소값
System.out.println(Integer.MIN_VALUE-1); //최소값 -1 = 최대값
//참고 : 최대값 +1이 최소값이 되는 이유
int maxVal = 0b01111111111111111111111111111111; // 최대값 에서 +1을 하면 맨끝짜리부터 값이 올라가서 00000하다가 맨끝에서1이됨
int maxVal1= 0b10000000000000000000000000000000; // 에 +1을 해주면 최소값이됨 (최대 범위보다 +1많잖아 최소값이)
System.out.println(maxVal);
System.out.println(maxVal1);
int minVal = 0b10000000000000000000000000000001;// +1을 해준 결과
//맨앞자리가 0이면 양수 1이면 음수
// 원래는 1의 보수구할때는 역수를하고 +1을하면 음수가나옴//근데 maxval minval에서는 0을 표현해야되서 min이 1더많잖아 그래서 -1더해줘야함
System.out.println(minVal);
//1's C 1의 보수 , 2진수의 음수를 만들기 위한 값
// 0과 1을 다 뒤짚어 주고 1을 더해주면 1's C이 된다.
//실수의 오차발생
System.out.println((6 - 5.9) *10); //0.99999999999999964// 1이어야 하는데 정밀도 부족
System.out.println(Math.floor((6-5.9)*10)); //0.0 // floor는 내림연산 1미만이기에 0
// 큰 문제 발생가능// 특히 실수 6.0이 정밀도 떨어져서 더 오차 발생
System.out.println(40/0.0); // infinity // 0으로 나누면 -0을 무한대로 하는 개념, so그 전에 막아버림
System.out.println(40%0.0); // NaN// Not a Number 숫자가 아니다. 인피티티가 뜬다 난이뜬다 라고 얘기함
// 수식에는 문제가 없지만 값에 문제가 있는 경우이기에 살펴봐야함
System.out.println("");
//실수형 오차는 딥러닝 같이 여러번 연산을 반복하는 경우 큰 문제가 발생하지만, 그외에 경우에는 미미해서 크게 영향은없음
// 하지만 실수의 연산 값을 정수형으로 활용하려고 할때는 데이터 소실의 문제가 발생할 수 있다. // 대입 연산자
z = x + y;
z += 10; // z = z+10;의 줄인 형태, +자리에 4칙연산자 + %까지 가능함, 비트연산자도 가능
z %= 2;비교 연산자는 두개의 항을 비교할때 사용하는 연산자로 그 출력값은 boolean 타입(true / false)
'=='는 같다, '!=' 같지 않다(not) 외에 부등호가 사용됨
System.out.println("비교 연산자");// 출력이 boolean
System.out.println(10>20); // false
System.out.println(10<20); // true
System.out.println(10>=10); // true // 노란색 불빛은 자명해서 나옴.
x= 10;
y= 10;
System.out.println(x == y); //true// 같다는 "=="
System.out.println(x != y); //false// 다르다는 "!="논리연산자는 입력과 출력이 모두 boolean인 연산자
a AND b : a, b 모두 참일때 만 참 &
a OR b : a 또는 b 둘 중 하나만 참이어 도 참 |
a XOR b : a 또는 b 둥 중 하나만 참이어 야 참.(둘다 참이면 거짓)// exclusive or,베타적 or 라고함 ^
NOT a : a가 참이면 거짓, 거짓이면 참 ! (단항연산자)
논리 연산자를 2개 사용하는 것을 short-circuit이라하고 더 빠르게 연산하게 된다. ex) &&, ||
System.out.println(10 <20 & 40 >= 2);// true // 양쪽이 모두 ture이기에 true
System.out.println(40 < 2 | 1> 0); //true // 1>0이 참이기에 참
System.out.println(!(10>20)); //true //false의 not은 true// 단항연산자!!
System.out.println(10>2 ^ 5 >2); //false //^ = XOR
System.out.println("");
//short - circuit // 앞에만 비교해서 조건맞으면 뒤에는 검사 안한다
System.out.println(10<20 && 4<2); // 비트단위로 비교하는 short -circuit. 연산이 더 빠르다정도만 알자
System.out.println(10<20 || 2<5); int val = 0;
System.out.println(val++); //0 // value값을 그대로 사용한 후에 다음에 value에 +1을 해줌
// val = 0으로 먼저 Expression 평가 후에 val +=1 적용
// sout(val);
// val +=1;
System.out.println(++val); //2 // val +=을 먼저 계산 후에 Expression 평가
// val +=1;
//sout(val)
System.out.println(val--); //2
// sout(val);
// val -=1;
System.out.println(--val); //1
// val -=1;
//sout(val)
val = 5;
int new_val = val++ * 10 + --val;
// 5*10
// val++ 로 val 이 6이됨
// --val 로 val 이 5가됨
// 5*10 +5=5
System.out.println(new_val); //55 System.out.println(true?1:0);//1
System.out.println(false?1:0);//0
x = 10;
y = 13;
System.out.println(x > y ? x : y); // max function, 더 큰게 출력 되는 구조
System.out.println(x < y ? x : y); // min funciton, if문을 간단하게 쓰는 연산자로 자주쓰임 System.out.printf("b%32s\n", Integer.toBinaryString(1252));
System.out.printf("b%32s\n", Integer.toBinaryString(15234));
System.out.printf("b%32s\n", Integer.toBinaryString(1252 & 15234)); //하나라도 0이면 0, 둘다 1이면 1
System.out.printf("b%32s\n", Integer.toBinaryString(1252 | 15234)); //하나라도 1이면 1 둘다0이면 0
System.out.printf("b%32s\n", Integer.toBinaryString(1252 ^ 15234)); //XOR
System.out.printf("b%32s\n", Integer.toBinaryString(~1252)); //not은 !아닌 ~ System.out.printf("b%32s\n", Integer.toBinaryString(8)); //1000
//Integer.toBinaryString(int)
System.out.printf("b%32s\n", Integer.toBinaryString(8>>1));//100 // >>은shift 연산자
//>>1 은 오른쪽으로 한칸씩 옮긴것임 1000 => 100, 2진수에서 한칸씩 내려간다는 것은 절반으로 줄어든다는 뜻
System.out.printf("b%32s\n", Integer.toBinaryString(7));//111
System.out.printf("b%32s\n", Integer.toBinaryString(7>>1)); //11 3,5가 아닌 소숫점 자른 3이 나온다
System.out.printf("b%32s\n", Integer.toBinaryString(1423));//10110001111
System.out.printf("b%32s\n", Integer.toBinaryString(1423<<2)); //1011000111100
System.out.printf("b%32s\n", Integer.toBinaryString(1423>>4)); //1011000
System.out.printf("b%32s\n", Integer.toBinaryString(1423<<2)); //1011000111100
System.out.printf("b%32s\n", Integer.toBinaryString(1423<<4)); //101100011110000
//새로 추가 되는 비트는0으로 추가됨
System.out.printf("b%32s\n", Integer.toBinaryString(-1)); //b11111111111111111111111111111111
System.out.printf("b%32s\n", Integer.toBinaryString(-1>>1)); //b11111111111111111111111111111111
// 사인비트의 영향으로 1으로채워짐//변화없음
System.out.printf("b%32s\n", Integer.toBinaryString(-1>>>1)); // b 1111111111111111111111111111111
// 사인비트보다 한칸 더채워서 0으로채워짐
// <<에는 <<<없지만 >>에는 >>>이 있다. int intVal = 4123;
intVal >>= 2; // intVal = intVAll>>2; Shift 연산자도 대입연산자 가능
intVal |= 412; // intVal = intVal | 412; Bitwise 연산자도 대입연산자 가능| [Java] 2_5_조건문 (Conditional Statements) (0) | 2020.07.31 |
|---|---|
| [Java] 2_예제1 (0) | 2020.07.29 |
| [Java] 2_3_자료의 입출력 (Inputs and Outputs) (0) | 2020.07.28 |
| [Java] 2_2_자료형(Data Type) (0) | 2020.07.28 |
| [Java] 2_1_변수 (0) | 2020.07.28 |