java

 

 

 

231010(화)

 

#1. JVM, JDK, JRE의 차이? 

 

1. JVM (Java Virtual Machine):
   • JVM은 Java 바이트 코드를 기계어로 변환하여 운영체제(OS) 위에서 실행시키는 역할을 하는 가상 머신입니다.
   • JVM은 플랫폼에 독립적이지 않습니다. 즉, Windows, Linux, MacOS 등의 OS별로 다른 JVM 버전이 필요합니다.
   • JVM 덕분에 Java는 "한 번 작성하면 어디서든 실행할 수 있다(Write Once, Run Anywhere)"는 특성을 가지게 됩니다.
2. JDK (Java Development Kit):
   • JDK는 Java 애플리케이션을 개발하기 위한 도구 모음입니다.
   • JDK에는 JVM, JRE, 컴파일러(javac), 디버거 등 다양한 개발 도구가 포함되어 있습니다.
   • 개발자가 Java 프로그램을 작성하고 컴파일하기 위해 JDK를 설치해야 합니다.
3. JRE (Java Runtime Environment):
   • JRE는 Java 애플리케이션을 실행하기 위한 환경입니다.
   • JRE에는 JVM과 Java 클래스 라이브러리(Java API) 등이 포함되어 있습니다. 하지만 개발 도구는 포함되어 있지 않습니다.
   • 사용자는 Java로 작성된 애플리케이션을 실행하기 위해서만 JRE를 설치하면 됩니다.

-How java programming is independent 
First.java (source code)
First.class  (byte code)    
JVM(interpreter,JIT compiler)  -> execute the program(JVM이 byte 코드를 machine 코드로 변환.) 
Operating System 
Hardware 

 

 

-> JDK는 compiler과 JRE를 포함,  JRE는 라이브러리와 JVM을 포함 ,  JVM은 바이트 코드를 기계어로 변환  

 

 

 

#2. Stack 과 Heap 

스택과 힙의 차이를 이해하는 것은 프로그래밍 및 소프트웨어 개발에서 중요한데, 여러 이유가 있습니다:

1. 메모리 관리:
   • 스택과 힙은 메모리 할당 및 반환 방식이 다릅니다. 스택은 자동으로 할당 및 반환되지만, 힙은 수동으로 관리될 수 있습니다(예: Java에서는 가비지 컬렉터에 의해 관리). 메모리 누수와 같은 문제를 피하려면 힙 메모리를 올바르게 관리하는 방법을 알아야 합니다.
2. 성능:
   • 스택 메모리는 빠른 액세스를 제공하지만, 제한된 크기를 가집니다. 힙은 더 큰 메모리 공간을 제공하지만, 할당 및 해제가 더 느릴 수 있습니다.
3. 변수의 수명:
   • 스택 변수는 해당 메소드나 블록의 실행 도중에만 존재합니다. 반면 힙에 할당된 객체는 참조가 유지되는 한 계속 존재할 수 있습니다.
4. 변수의 크기:
   • 스택에 할당된 메모리의 크기는 컴파일 시점에서 결정되어야 합니다. 반면 힙은 런타임에 동적으로 메모리를 할당할 수 있어서 크기가 가변적입니다.
5. 예외 상황:
   • 스택과 힙 메모리의 문제점을 알고 있으면, 예외 상황(예: 스택 오버플로우, 메모리 누수)에 대비하고 이를 디버깅하는 데 도움이 됩니다.
6. 데이터 구조 및 알고리즘 설계:
   • 메모리 사용과 관련된 알고리즘과 데이터 구조의 설계에 있어서 효율적인 결정을 내릴 수 있습니다.

스택과 힙의 차이점을 이해함으로써, 프로그래머는 메모리 사용과 관련된 문제를 최소화하고, 성능을 최적화하며, 더욱 효과적인 소프트웨어 설계와 구현을 할 수 있게 됩니다.

 

 

#3. narrowing, and widening 

"implicit narrowing" 및 "explicit"는 Java와 같은 프로그래밍 언어에서 형 변환 (type casting)에 관련된 용어입니다. 데이터 타입 간의 변환에 있어서 어떠한 개입이 필요한지, 또는 어떠한 개입이 발생하는지를 나타내는 용어로 사용됩니다. 각 용어의 의미와 예제를 통해 설명하겠습니다.

1. Implicit Narrowing (암시적 형변환):
   • Implicit narrowing은 프로그래머의 명시적인 개입 없이 컴파일러에 의해 자동으로 수행되는 형 변환을 의미합니다.
   • 이 형 변환은 데이터 손실의 위험이 있으므로 주의가 필요합니다. 예를 들어, 큰 데이터 타입에서 작은 데이터 타입으로의 변환은 값의 손실을 초래할 수 있습니다.
   • Java에서는 implicit narrowing을 허용하지 않습니다. 이로 인해 데이터 손실을 방지하려는 의도가 있습니다.
   javaCopy code

   int num = 100; byte b = num; // 컴파일 오류! 암시적 narrowing이 허용되지 않습니다.
2. Explicit Casting (명시적 형변환):
   • Explicit casting은 프로그래머가 명시적으로 데이터 타입을 다른 데이터 타입으로 변환하고자 할 때 수행됩니다.
   • 이 형 변환은 데이터 손실 위험이 있을 수 있지만, 프로그래머가 의도적으로 그렇게 하기를 원한다는 것을 나타냅니다.
   javaCopy code

   int num = 100; byte b = (byte) num; // 명시적 형변환. 데이터 손실 위험이 있지만, 프로그래머가 의도적으로 변환합니다.

요약하면, implicit narrowing은 암시적으로 데이터 타입을 변환하는 것을 의미하며, Java에서는 이를 허용하지 않습니다. 반면에 explicit casting은 프로그래머가 명시적으로 데이터 타입 변환을 요청하는 것을 의미합니다.

 

 

 

#4. Bitwise Operator

자바에서 비트 연산자는 주로 정수 값의 개별 비트를 다룰 때 사용됩니다. 비트 연산자는 AND(&), OR(|), XOR(^), NOT(~), 왼쪽 시프트(<<), 오른쪽 시프트(>>), 그리고 논리 오른쪽 시프트(>>>) 등이 있습니다.

비트 연산자를 사용하는 주요 상황은 다음과 같습니다:

1. 플래그 설정 및 검사:
   • 여러 플래그를 하나의 정수 변수에 저장하고, 특정 플래그가 설정되었는지 또는 해제되었는지 검사할 때.
2. 권한 제어:
   • 사용자 권한, 파일 권한 등을 비트로 표현하고, 특정 권한이 있는지 검사하거나 설정할 때.
3. 저수준 프로그래밍:
   • 하드웨어 제어, 네트워크 패킷 분석 등 저수준 작업에서 특정 비트를 조작해야 할 때.
4. 성능 최적화:
   • 일부 연산, 예를 들어 나눗셈을 비트 시프트로 대체하여 연산 속도를 높이려고 할 때.
5. 스와핑:
   • XOR 연산자를 사용하여 두 변수의 값을 스와핑하는 경우가 있습니다. 이 방법은 추가 변수를 사용하지 않고 값을 스와핑할 수 있습니다. 예:
   javaCopy code

   int a = 5; int b = 7; a = a ^ b; b = a ^ b; a = a ^ b;
   위 코드 실행 후 a는 7이 되고 b는 5가 됩니다.

그러나, 실제 개발에서 XOR을 사용한 스와핑은 많이 사용되지 않습니다. 이 방법은 알고리즘 문제나 특정 최적화 상황에서 주로 볼 수 있습니다. 일반적인 상황에서는 가독성을 위해 임시 변수를 사용하여 값들을 스와핑하는 것이 더 흔합니다.

 

 

#5. java vs javac

java와 javac는 Java 개발 키트(JDK)에 포함된 두 가지 주요 명령줄 도구입니다. 각 도구의 주요 기능은 다음과 같습니다:

1. javac:
   • 의미: javac는 "Java 컴파일러"를 의미합니다.
   • 기능: javac는 Java 소스 코드 파일 (.java 확장자를 가진 파일)을 바이트 코드 (.class 확장자를 가진 파일)로 컴파일합니다. 바이트 코드는 Java Virtual Machine (JVM)에서 실행될 수 있습니다.
   • 사용 예:
     bashCopy code

     javac MyProgram.java
     이 명령은 MyProgram.java라는 Java 소스 파일을 컴파일하여 MyProgram.class라는 바이트 코드 파일을 생성합니다.
2. java:
   • 의미: java 도구는 Java 애플리케이션 런처입니다.
   • 기능: java는 컴파일된 Java 바이트 코드를 실행하는 데 사용됩니다. 이를 위해, java는 Java Virtual Machine (JVM) 인스턴스를 시작하고 지정된 클래스의 main 메서드를 호출합니다.
   • 사용 예:
     bashCopy code

     java MyProgram
     이 명령은 MyProgram.class 바이트 코드를 JVM에서 실행합니다.

요약하면, javac는 Java 소스 코드를 컴파일하는 데 사용되며, java는 컴파일된 Java 바이트 코드를 실행하는 데 사용됩니다.

 

 

#6. public static void main(String[] args)

1. public:
   • 이는 main 메소드가 공개적으로 접근 가능하다는 것을 의미합니다. 따라서 JVM이 애플리케이션의 외부에서 이 메소드를 호출할 수 있습니다.
2. static:
   • main 메소드가 static이므로, 애플리케이션을 시작할 때 해당 클래스의 인스턴스(객체)를 생성하지 않고도 메소드를 호출할 수 있습니다.
3. void:
   • 이 메소드는 반환값이 없음을 의미합니다.
4. main:
   • Java에서 프로그램의 시작점이 되는 메소드의 이름입니다.
5. String[] args:
   • 커맨드 라인에서 프로그램을 실행할 때 전달하는 인수(arguments)를 받아들이는 문자열 배열입니다. 예를 들어, 프로그램을 java MyProgram arg1 arg2와 같이 실행하면 args[0]은 "arg1"이고 args[1]은 "arg2"가 됩니다.

요약하면, public static void main(String[] args)는 Java 프로그램이 실행될 때 가장 먼저 호출되는 메소드로, JVM이 자동으로 이 메소드를 찾아 실행합니다. 이 메소드는 프로그램의 실행을 시작하고, 필요한 초기화 작업을 수행하며, 필요한 다른 메소드나 객체를 호출하는 등의 작업을 담당합니다.

 

 

+보통 자바 버전 몇 쓰는지 프로젝트 때? 그리고 그 이유 ?   
-C랑 Java에서 어떻게 다른지.? public static void main (String args[]) 설명
-args 값 넘기는 것 테스트   (args[0],  args[1])  

 

 

 

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

 

(Day2)

 

import java.util.Scanner;

// Shape.java
abstract class Shape {
    protected double sideLength;

    public Shape(double sideLength) {
        this.sideLength = sideLength;
    }

    public abstract double area();

    public abstract double perimeter();
}

// Circle.java
class Circle extends Shape {
    public Circle(double radius) {
        super(radius);
    }

    public double area() {
        return Math.PI * sideLength * sideLength;
    }

    public double perimeter() {
        return 2 * Math.PI * sideLength;
    }
}

// Square.java
class Square extends Shape {
    public Square(double side) {
        super(side);
    }

    public double area() {
        return sideLength * sideLength;
    }

    public double perimeter() {
        return 4 * sideLength;
    }
}

// Triangle.java
class Triangle extends Shape {
    public Triangle(double base) {
        super(base);
    }

    public double area() {
        return 0.5 * sideLength * sideLength; // assuming an equilateral triangle
    }

    public double perimeter() {
        return 3 * sideLength; // assuming an equilateral triangle
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("Please enter a value:");
        double input = sc.nextDouble();

        Circle circle = new Circle(input);
        Square square = new Square(input);
        Triangle triangle = new Triangle(input);

        System.out.println("Perimeter of square: " + square.perimeter());
        System.out.println("Area of circle: " + circle.area());
        System.out.println("Area of square: " + square.area());
        System.out.println("Area of triangle: " + triangle.area());
    }
}

 

 

 

#0. 자바와 C의 컴파일 

자바의 경우 javac 가 바이너리 코드를 만들고(.class)  , 해당 코드를 JVM이 실행시킨다 .

C의 경우 컴파일링시 오브젝트 코드가 되고 링킹시 실행 가능한 파일(.exe)이 된다.  

 

#1. Principles of OOP 

abstraction : hiding internal details and showing the required things
encapsulation
inheritance
polymorphism 

 

 

#2. 추상클래스 

import java.util.*;

 

abstract class Shape{

    abstract void inputShape();

    abstract boolean isTriangle();

    abstract double getArea();

    abstract double getPerimeter();

}

 

class Rectangle extends Shape{

    private double length;

    private double width;

    public void inputShape(){

        System.out.println("Input length and width of Rectangle");

        Scanner sc = new Scanner(System.in);

        this.length = sc.nextDouble();

        this.width = sc.nextDouble();

    }

    public boolean isTriangle(){

        return false;

    }

    public double getArea(){

        return length * width;

    }

    public double getPerimeter(){

        return 2 * (length + width);

    }

}

 

class Square extends Shape{

    private double edge;

    public void inputShape(){

        System.out.println("Input edge of Square");

        Scanner sc = new Scanner(System.in);

        this.edge = sc.nextDouble();

    }

    public boolean isTriangle(){

        return false;

    }

    public double getArea(){

        return edge * edge;

    }

    public double getPerimeter(){

        return 4 * edge;

    }

}

 

class Circle extends Shape{

    private double radius;

    public void inputShape(){

        System.out.println("Input radius of Circle");

        Scanner sc = new Scanner(System.in);

        this.radius = sc.nextDouble();

    }

    public boolean isTriangle(){

        return false;

    }

    public double getArea(){

        return 2*Math.PI*radius*radius;

    }

    public double getPerimeter(){

        return Math.PI*radius;

    }

}

 

class Triangle extends Shape{

    private double side1;

    private double side2;

    private double side3;

    public boolean isTriangle(){

        if(side1 + side2 < side3 || side1 + side3 < side2 || side2 + side3 < side1){

            return false;

        }else{

            return true;

        }

    }

    public void inputShape(){

        Scanner sc = new Scanner(System.in);

        System.out.println("Input side1 of Triangle");

        this.side1 = sc.nextDouble();

        System.out.println("Input side2 of Triangle");

        this.side2 = sc.nextDouble();

        System.out.println("Input side3 of Triangle");

        this.side3 = sc.nextDouble();

    }

    public double getArea(){

        double s = (side1 + side2 + side3) / 2;

        return Math.sqrt(s * (s - side1) * (s - side2) * (s - side3));

    }

    public double getPerimeter(){

        return side1 + side2 + side3;

    }

}

 

class Example {

    public static void main(String args[]){

        System.out.println("Input the shape type(rect/circle/square/triangle)");

        Scanner sc = new Scanner(System.in);

        String shapeType = sc.nextLine();

        if("rect".equals(shapeType)){

            Shape shape = new Rectangle();

            shape.inputShape();

            System.out.println("Shape area: "+ shape.getArea());

            System.out.println("Shape perimeter: "+ shape.getPerimeter());

        }else if("circle".equals(shapeType)){

            Shape shape = new Circle();

            shape.inputShape();

            System.out.println("Shape area: "+ shape.getArea());

            System.out.println("Shape perimeter: "+ shape.getPerimeter());

        }else if("square".equals(shapeType)){

            Shape shape = new Square();

            shape.inputShape();

            System.out.println("Shape area: "+ shape.getArea());

            System.out.println("Shape perimeter: "+ shape.getPerimeter());

        }else if("triangle".equals(shapeType)){

            Shape shape = new Triangle();

            shape.inputShape();

            if(shape.isTriangle()){

                System.out.println("Shape area: "+ shape.getArea());

                System.out.println("Shape perimeter: "+ shape.getPerimeter());

            }else{

                System.out.println("Shape are not Triangle!!!");

            }

        }else {

            System.out.println("Wrong input!!! Application terminated!!");

        }

 

    }

}

 

 

#3. 인터페이스

 

 

 

 

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

 

231012  목요일

 

 

#1. Abstraction 

abstract class Vehicle {

    String regNo;

    Vehicle() {  // Constructor name fixed

        System.out.println("Creating Vehicle");

    }

   

    public abstract void start();  // Removed static and added abstract

    public abstract void stop();   // Removed static and added abstract

    public void display() {

        System.out.println("Vehicle reg no : " + regNo);

    }

}

class TwoWheeler extends Vehicle {

    public void start() {  // Made it public

        System.out.println("Two wheeler start logic");

    }

    public void stop() {  // Made it public

        System.out.println("Two Wheeler stop logic");

    }

}

public class VehicleManager {

    public static void main(String[] args) {

       

        Vehicle twoWheeler = new TwoWheeler();

        twoWheeler.regNo = "fpt";

        twoWheeler.start();

        twoWheeler.stop();

        twoWheeler.display();

    }

}

 

 

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

 

231012 목요일

 

 

-Java vs C  ?  

Java와 C는 모두 널리 사용되는 프로그래밍 언어지만, 몇 가지 중요한 차이점이 있습니다. 이 차이점 중 가장 두드러지는 것은 Java가 객체지향 프로그래밍 언어인 반면, C는 절차적 프로그래밍 언어라는 점입니다. 아래에 이와 관련한 주요 차이점을 나열하였습니다.

1. 기본 패러다임:
   • C (절차적 프로그래밍): C는 절차적 프로그래밍 언어입니다. 이는 프로그램을 일련의 절차나 함수로 분할하여 개발하는 방식을 의미합니다. 데이터와 기능(함수)이 명확하게 분리되어 있습니다.
   • Java (객체지향 프로그래밍): Java는 객체지향 프로그래밍 언어입니다. 이는 프로그램을 객체라는 독립된 단위로 분할하여 개발하는 방식을 의미합니다. 데이터와 기능(메소드)이 객체 내에서 결합됩니다.

-principles of OOP (4) & examples 

polymorphism is the concept where an object behaves differently in different situation 
since the object takes multiple forms, it is calleed Polymorphism 

-class vs object 

클래스로 객체를 생성 

-Interface 

핵심 기능만 만들어 놓고 추후에 구체화 

-Why do you need constructor ? 

to initialize object (initialize value and property) 
getter / settter 로 값을 넣어준다 

 

public class Person {

    // private 변수로 캡슐화

    private String name;

    private int age;

    // 기본 생성자

    public Person() {

    }

    // 파라미터를 가진 생성자

    public Person(String name, int age) {

        this.name = name;

        this.age = age;

    }

    // name의 getter 메소드

    public String getName() {

        return name;

    }

    // name의 setter 메소드

    public void setName(String name) {

        this.name = name;

    }

    // age의 getter 메소드

    public int getAge() {

        return age;

    }

    // age의 setter 메소드

    public void setAge(int age) {

        if(age >= 0) {  // 유효성 검사 예제: 음수 값 방지

            this.age = age;

        } else {

            System.out.println("Invalid age value");

        }

    }

    public static void main(String[] args) {

        Person person = new Person();

        // setter를 통한 값 할당

        person.setName("John");

        person.setAge(25);

        // getter를 통한 값 조회

        System.out.println("Name: " + person.getName());

        System.out.println("Age: " + person.getAge());

    }

}

 

 

-생성자의 이름은 클래스의 이름과 동일해야 하며,
반환형을 지정하지 않음 


- override vs overloading 


-Abstraction 
implement ojbect method  ->  
concrete class with declaration 

Phone samgsung = new Samsung(); 


-Rule for abstract class


-음.. 추상클래스를 구현할 때 여러 번 상속 받는 형식이라면, 그 때 선언한 추상 클래스에 메서드 선언이 안되어 있다면 호출이 안된다.




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