1. node js 설치

2. vue cli 설치

3. vue create

4. vuetify 추가

5. router 추가

# vue add router

6. 서버 실행

var a = 5

val b = 10

// 변수명: 자료형 = 값

var a: Int 10

val b: int = 20

기본 자료형

Double : 64비트 부동소수점

Float  : 32비트 부동소수점

Long   : 64비트 정수

Int    : 32비트 정수

Short  : 16비트 정수

Byte   : 8비트 정수

리터럴

val a = 10    // val a: Int

val b = 10L   // val b: Long

val c = 10.0  // val c: Double

val d = 10.0f // val d: Float

문자형

String : 문자열

Char   : 하나의 문자

val str = "안녕하세요" // val str: String

val char = "안"       // val char: char

// 함수

fun greet(str: String): Unit {

  println(str)

}

greet( str:"안녕")

// 문자열 템플릿

val str = "안녕"

println(str + "하세요") // 자바 안녕하세요

--코틀린

println("$str 하세요") // 안녕 하세요

println("${str}하세요") //안녕하세요

// 배열

val numbers: Array<Int> arrayOf(1, 2, 3, 4, 5)

val number2 = arrayOf(1, 2, 3, 4, 5) // 자료형 생략

numbers[0] = 5 // [5, 2, 3, 4, 5]

//제어문

# if

if( a < b ) max = b // 일반적인 방법

if( a < b) {

  max = a

} else {

  max = b

}

val max = if(a > b) a else b // 식처럼 사용 가능

// when 문은 자바의 switch문에 대응

#1

val x = 1

when (x) {

  1 -> println("x == 1")                // 값 하나

  2, 3 -> println("x == 2 or x == 3")   // 여러 값은 콤마로

  in 4..7 -> println("4 부터 7 사이")    // in 연산자로 범위지정

  !in 8..10 -> println("8부터 10 사이가 아님")

} else -> {                             // 나머지

  print("x는 1이나 2가 아님")

}

#2

val numberStr = 1

val numberStr = when(number % 2) {

  0-> "짝"

  else -> "홀"

}

#3

val number = 1

fun isEven (num: Int) = when (num %2) { // 결과가 String으로 추론되어 반환형 선언 생략 가능

  0 -> "짝"

  else -> "홀"

}

println(isEven(number))

// for문

#1

val numbers = arrayOf(1, 2, 3, 4, 5)

for (num in numbers) {

  println(num)  //1; 2; 3; 4; 5;

}

#2

// 1~3 까지 출력

for (i in 1..3) {

  println(i) // 1; 2; 3;

}

// 0~10까지 2씩 증가하며 출력

for (i in 0..10 step 2) {

  println(i)    // 0; 2; 4; 6; 8; 10;

}

// 10부터 0 까지 2씩 감소하며 출력

for (i in 10 downTo 0 step 2) {

  println(i)    // 10; 8; 6; 4; 2; 0;

}

// while

var x = 10

println(x)

while ( x > 0 ) {

  x--

  println(x)    //9; 8; 7; 6; 5; 4; 3; 2; 1; 0;

}

// do while

var x = 10

do {

  x--

  println(x)    // 9; 8; 7; 6; 5; 4; 3; 2; 1; 0;

} while (x > 0)

// 클래스

# 클래스 선언

class Person {

}

#인스턴스 생성

val person = Person()

// 생성자

# 코틀린에서의 클래스

calss Person(var name: String) {

}

class Person {

  constructor(name: String) {

    println(name)

  }

}

class Person(name: String) {

  init {

    println(name)

  }

}

// 프로퍼티 : 클래스의 속성을 사용할 때는 멤버에 직접 접근하며 이를 프로퍼티라고 합니다.

# 클래스 선언

class Person(var name: String) {

}

// 인스턴스 생성

val person = Person("멋쟁이")

person.name = "키다리"   // 쓰기

println(person.name)    // 읽기

// 접근제한자 : 접근제한자란 변수나 함수를 공개하는 데 사용하는 키워드이다.

Class A {

  val a = 1             // public(생략가능) : 전체 공개

  private val b = 2     // private : 현재 파일 내부에서만 사용 가능

  protected val c = 3   // protected : 같은 모듈 내에서만 사용가능

  internal val d = 4    // internal : 상속받은 클래스에서 사용가능

}

// 클래스 상속

// 코틀린에서의 클래스는 기본적으로 상속이 금지된다.

// 상속이 가능하게 하려면 open키워드를 클래스 선언 앞에 추가한다.

// 다음은 Animal클래스를 상속받는 Dog 클래스를 나탄내다.

open class Animal {

}

class Dog : Animal() {

}

open class Animal(val name: String) {

}

class Dog(name: String) : Animal(name) {

}

// 내부 클래스

// 내부 클래스 선언에는 inner를 사용

// 내부 클래스는 외부 클래스에 대한 참조를 가지고 있다.

// 아래 코드에서 inner 키워드가 없다면 a를 20으로 변경할 수 없다.

class OuterClass {

  val a = 10

  // 내부클래스

  inner class OuterClass2 {

    fun something() {

      a = 20 // 접근 가능

    }

  }

}

// 추상 클래스

// 추상클래스는 미구현 메서드가 포함된 클래스.

// 클래스와 미구현 메서드 앞에 abstract키워드를 붙인다.

// 추상클래스는 직접 인스턴스화 할 수 없고 다른 클래스가 상속하여 미구현 메서드를 구현해야 한다.

// 기본적으로 자바와 동일한 특성을 가진다.

abstract class A {

  abstract fun func()

  fun func2() {

  }

}

class B: A() {

  override fun func() {

    println("Hello")

  }

}

val a = A() // 에러

val a = B() // ok

// 인터페이스

// 인터페이스는 미구현 메서드를 포함하여 클래스에서 이를 구현한다.

// 추상클래스와 비슷하지만 클래스가 단일 상속만 되는 반면 인터페이스는 다중 구현이 가능하다.

// 주로 클래스에 동일한 속성을 부여해 같은 메서드라도 다른 행동을 할 수 있게 하는데 사용한다.

// 코틀린의 인터페이스는 자바와 거의 사용법이 같다.

//# 인터페이스 선언

//  다음과 같이 인터페이스에 추상 메서드를 포함할 수 있다.

//  원래 추상 클래스에서 추상 메서드는 abstract키워드가 필요한데 인터페이스에서는 생략할 수 있다.

interface Runnable {

  fun run()

}

// 인터페이스는 구현이 없는 메서드뿐만 아니라 구현된 메서드를 포함할 수 있다. 이는 자바의 default 메서드에 대응한다.

interface Runnable {

  fun run()

  fun fastRun() = println("빨리 달린다")

}

// 인터페이스의 구현

// 인터페이스를 구현할 때는 인터페이스 이름을 콜론 뒤에 나열한다.

// 그리고 미구현 메서드를 작성하는데 이때 override 키워드를 메서드 앞에 추가한다.

// run 함수를 오버라이드한다고 말한다.

class Human : Runnable {

  override fun run() {

    println("달린다")

  }

}

// 상속과 인터페이스를 함께 구현

// 다음과 같이 상속과 인터페이스를 함께 구현할 수 있다.

// 상속은 하나의 클래스만 상속하는 반면 인터페이스는 콤마로 구분하여 여러 인터페이스를 동시에 구현할 수 있다.

open class Animal {

}

interface Runnable {

  fun run()

  fun fastRun() = println("빨리 달린다")

}

interface Eatable {

  fun eat()

}

class Dog: Animal(), Runnable, Eatable {

  override fun eat() {

    println("먹는다")

  }

  override fun run() {

    println("달린다")

  }

}

val dog = Dog()

dog.run()

dog.eat()

1. 파이썬(Python)의 예약어

파이썬에서 변수명으로 사용할수 없는 것들 이있습니다.

그중에 먼저 '예약어'에대해 알아보겠습니다.

위에 있는 것들은 예약어로 불리며 변수명으로 사용이 불가능 합니다. 

파이썬에서 특정 기능을 동작하게 하는 것을 예약어라고 합니다.

2. 사용 불가능한 변수명

변수를 생성할 때 주의할 점이 몇가지 있습니다.

변수를 만들때 특수문자 및 숫자가 앞에오는 경우 불가능 합니다.

ex) 1abc %abc #abc

특수 문자에서 예외가 있습니다.

언더바( _ ) 는 사용이 가능합니다.

ex) _abc

3. 변수 구분

4. 변수 생성

5. 변수 삭제