interface 인터페이스명 {

   public static final 자료형 변수명 = 변수값;

   public abstract 반환자료형 함수명(입력인자들);

}

interface IA {

   int ia = 11; // 앞에 public static final 이 생략됨

   void fun();  // 앞에 public abstract 가 생략됨

}

class CA implements IA {

   public void fun() {

       int ib = ia + 11; // ia는 인터페이스에서 정의된 정적 변수이다.

       System.out.println(“fun() redefined.”);

   }

}

package tut03;

public class Tut03 {

   public static void main(String[] args) {

       Violin v1 = new Violin();

       v1.ready();

       v1.play();

       Guitar g1 = new Guitar();

       g1.ready();

       g1.play();

   }

}

interface Playable {

   String player = "살레시오";

   void ready();

   void play();   

}

class Violin implements Playable {

   public void ready() {

       System.out.println(player+"의 바이올린이 준비되었다.");

   }

   public void play() {

       System.out.println("낑~깡~낑~깡~");

   }

}

class Guitar implements Playable {

   public void ready() {

       System.out.println(player+"의 기타가 준비되었다.");

   }

   public void play() {

       System.out.println("디리링~디리링~");

   }    

}

자바(JAVA) 강좌 전체 목록 (TOP) >>>

c{java},n{jv011}

>>> import numpy # 넘파이의 모든 객체를 numpy.obj 형식으로 불러 사용할 수 있다.

>>> import numpy as np  # 넘파이의 모든 객체를 np.obj 형식으로 불러 사용할 수 있다.

>>> from numpy import * # 넘파이의 모든 객체를 내장 함수 (객체) 처럼 사용 가능.

>>> np.array( [1, 2, 3] ) #1차 배열 (벡터) 생성

>>> np.array( [ [1, 2, 3], [4, 5, 6] ) # 2x3 크기의 2차원 배열 (행렬) 생성

>>> np.arange(10) # 1차원 배얼 [0,1,2, ... ,9] 생성

>>> c = np.linspace(0, 1, 6)   # start, end, num-points

>>> c

    array([ 0. , 0.2, 0.4, 0.6, 0.8, 1. ])

>>> d = np.linspace(0, 1, 5, endpoint=False)

>>> d

    array([ 0. , 0.2, 0.4, 0.6, 0.8])

>>> a = np.arange(10) # 1차원 배열 [0,1,2, ... ,9] 생성

>>> a = a.reshape(2,5) # 같은 요소를 가지고 2x5 배열로 변형

>>> b1 = np.ones( 10 ) # 1로 채원진 10 크기의 (1차원) 배열 생성

>>> b2 = np.zeros( (5,5) ) # 0으로 채원진 5x5 크기의 배열 생성

>>> np.eye(2, dtype=int)

    array([[1, 0],

           [0, 1]])

>>> np.eye(3, k=1)

    array([[ 0.,  1.,  0.],

           [ 0.,  0.,  1.],

           [ 0.,  0.,  0.]])

>>> x = np.arange(9).reshape((3,3))

>>> x

    array([[0, 1, 2],

           [3, 4, 5],

           [6, 7, 8]])

>>> np.diag(x)

    array([0, 4, 8])

>>> np.diag(x, k=1)

    array([1, 5])

>>> np.diag(x, k=-1)

    array([3, 7])

>>> np.diag(np.diag(x))

    array([[0, 0, 0],

           [0, 4, 0],

           [0, 0, 8]])

>>> c = np.empty( (2,2) ) # 가비지 값으로 채원진 2x2 크기의 배열 생성

넘파이(numpy) 글 전체 목록(TOP) >>>
파이썬 강좌 전체 목록 (TOP) >>>

c{ns},n{ns001}

접근 지정자

접근 범위

동일
클래스

동일
패키지

다른
패키지의
자식
클래스

다른
패키지

public

접근 제한 업음

O

O

O

O

protected

동일 패키지와 상속 받은 클래스 내부

O

O

O

default

동일 패지키 내에서만

O

O

private

동일 클래스 내에서만

O

package tut02;

public class CA {

   public int ia;

   protected int ib;

   int ic;

   private int id;

   public static int ie;

   protected static  int ig;

   static int ih;

   private static int ii;

}

package tut03;

import tut02.CA;

public class Tut03 {

   public static void main(String[] args) {

       CA a = new CA();// ia만 접근 가능

       CC c = new CC();// ia만

   }   

}

class CC extends CA {

   //ia, ib, ie, ig 접근 가능

}

자바(JAVA) 강좌 전체 목록 (TOP) >>>

c{java},n{jv010}

abstract class Animal {

   public String sName; //일반 멤버 변수

   ….

   public void move() { …} // 일반 메소드

   abstract void howl(); //추상 메소드

   …

}

package tut02;

abstract class Animal {

   public String sName;

   public void move() {

       System.out.println("어슬렁 어슬렁");

   }

   abstract void howl();

}

class Dog extends Animal {

   public void move() {

       System.out.println("팔짝 팔짝");

   }

   void howl() {

           System.out.println("멍멍");

   }

}

class Cat extends Animal {

   void howl() {

           System.out.println("냐옹");

   }

}

public class Tut02 {

   public static void main(String[] args) {

       Dog happy = new Dog();

       Cat julia = new Cat();

       happy.move(); // 오버라이드된 멤버함수 호출

       happy.howl(); // 구현된 멤버함수 호출

       jular.move(); // 일반 멤버함수 호출

       julia.howl(); // 구현된 멤버함수 호출

   }

}

실행 결과

팔짝 팔짝

멍멍

어슬렁 어슬렁

냐옹

자바(JAVA) 강좌 전체 목록 (TOP) >>>

c{java},n{jv009}

c{julia},n{ju001}

메소드명

기능

byteValue()

byte값을 반환한다.

shortValue()

short값을 반환한다.

intValue()

int값을 반환한다.

longValue()

long값을 반환한다.

floatValue()

float값을 반환한다.

doubleValue()

double값을 반환한다.

package tut02;

public class Tut02 {

   public static void main(String[] args) {

       int ia = new Integer("1234567").intValue();

       float fa = new Integer("1234567").floatValue();

       short sa = new Integer("1234567").shortValue(); //(*)

       System.out.println(ia);

       System.out.println(fa);

       System.out.println(sa);

   }

}

실행 결과

1234567

1234567.0

-10617

메소드명

기능

Byte.parseByte(String)

Byte.parseByte(String, radix)

문자열을 byte값으로 변환한다.

기수 radix인 문자열을 byte값으로 변환한다.

Short.parseShort(String)

Short.parseShort(String, radix)

문자열을 short값으로 변환한다.

기수 radix인 문자열을 short값으로 변환한다.

Integer.parseInt(String)

Integer.parseInt(String, radix)

문자열을 int값으로 변환한다.

기수 radix인 문자열을 int값으로 변환한다.

Long.parseLong(String)

Long.parseLong(String, radix)

문자열을 long값으로 변환한다.

기수 radix인 문자열을 long값으로 변환한다.

Float.parseFloat(String)

문자열을 float값으로 변환한다.

Double.parseDouble(String)

문자열을 double값으로 변환한다.

package tut02;

public class Tut02 {

   public static void main(String[] args) {

       int ia = Integer.parseInt("1234567");

       int ib = Integer.parseInt("11110010",2); //이진수

       int ic = Integer.parseInt("1ab3f",16); //십육진수

       System.out.println(ia);

       System.out.println(ib);

       System.out.println(ic);

   }

}

실행 결과

1234567

242

109375

메소드명

기능

Byte.valueOf(String)

Byte.valueOf(String,radix)

Byte.valueOf(byte)

문자열을 Byte 객체로 변환

기수 radix인 문자열을 Byte 객체로 변환한다.

byte값을 Byte 객체로 박싱

Short.valueOf(String)

Short.valueOf(String,radix)

Short.valueOf(short)

문자열을 Short 객체로 변환

기수 radix인 문자열을 Short 객체로 변환한다.

short값을 Short 객체로 박싱

Integer.valueOf(String)

Integer.valueOf(String,radix)

Integer.valueOf(int)

문자열을 Integer 객체로 변환

기수 radix인 문자열을 Interger 객체로 변환한다.

int값을 Interger 객체로 박싱

Long.valueOf(String)

Long.valueOf(String,radix)

Long.valueOf(long)

문자열을 Long 객체로 변환

기수 radix인 문자열을 Long 객체로 변환한다.

long값을 Long 객체로 박싱

Float.valueOf(String)

Float.valueOf(float)

문자열을 Float 객체로 변환한다.

float값을 FLoat 객체로 박싱

Double.valueOf(String)

Double.valueOf(float)

문자열을 Double 객체로 변환한다.

float값을 Double 객체로 박싱

int ia = Integer.valueOf("1234567");

자바(JAVA) 강좌 전체 목록 (TOP) >>>

c{java},n{jv008}

기본형

포장 클래스

생성 예

boolean

Boolean

Boolean bA = new Boolean(true);

Boolean bB = new Boolean(“false”);

char

Character

Character cA = new Character(‘a’);

byte

Byte

Byte byA = new Byte(10);

Byte byB = new Byte(“127”);

short

Short

Short sA = new Short(1234);

Short sB = new Short(“1234”);

int

Integer

Integer iA = new Integer(1234);

Integer iB = new Integer(“1234”);

long

Long

Long lA = new Long(1234);

Long lB = new Long(“1234”);

float

Float

Float fA = new Float(12.34f);

Float fB = new Float(“12.34f”);

double

Double

Double dA = new Double(12.34);

Double dB = new Double(“12.34”);

package tut02;

public class Tut02 {

   public static void main(String[] args) {

       Integer iA = new Integer(123);

       Integer iB = new Integer(123);

       int ia = (int)iA; //(1) 언박싱(unboxing)

       int ib = iB; //(2) 오토언박싱(auto unboxing)

       Integer iC = (Integer)456; //(3)박싱(boxing)

       Integer iD = ia; //(4)오토 박싱(auto boxing)

   }

}

package tut02;

public class Tut02 {

   public static void main(String[] args) {

       Integer iA = new Integer(123);

       Integer iB = new Integer(123);

       int ia = (int)iA; //(1) 언박싱(unboxing)

       int ib = iB; //(2) 오토언박싱(auto unboxing)

       Integer iC = (Integer)456; //(3)박생(boxing)

       Integer iD = ia; //(4)오토 박싱(auto boxing)

       Integer iE = iA + iB; // 포장형끼리의 연산

       Integer iF = ia - ib; // 기본형끼리의 연산 결과를 오토박싱

       int ic = ia * iB; // 기본형과 포장형 간 연산

   }

}

package tut02;

public class Tut02 {

   public static void main(String[] args) {

       Integer ia = new Integer(123);

       Integer ib = new Integer(123);

       Integer ic = new Integer(456);

       System.out.println("ia>=ib:"+(ia>=ib));

       System.out.println("ib>=ic:"+(ib>=ic));

       System.out.println("ia==ib:"+(ia==ib));

       System.out.println("ia.equals(ib):"+ia.equals(ib));

   }

}

ia>=ib:true

ib>=ic:false

ia==ib:false

ia.equals(ib):true

자바(JAVA) 강좌 전체 목록 (TOP) >>>

c{java},n{jv007}

$sudo sh netbeans-8.0.2-javase-linux.sh

라즈베리 파이 전체 글 목록 (TOP) >>>

리눅스 강좌 전체 목록 (TOP) >>>

파이썬 강좌 전체 목록 (TOP) >>>

c{rpi},n{rp003}

$sudo iwlist wlan0 scan

$sudo nano /etc/network/interfaces

$sudo ifdown wlan0

$sudo ifup wlan0

라즈베리 파이 전체 글 목록 (TOP) >>>

리눅스 강좌 전체 목록 (TOP) >>>

파이썬 강좌 전체 목록 (TOP) >>>

c{rpi},n{rp002}

int ia = 10;

ia++; //  ia = ia + 1 과 같다.

double da = 1.0;

da++; // da = da + 1과 같다.

형식

의미

++x

x를 먼저 1증가시킨 후 그 값을 사용

--x

x를 먼저 1감소시킨 후 그 값을 사용

x++

x값을 먼저 사용한 후 1 증가

x--

x값을 먼저 사용한 후 1 감소

package tut02;

public class Tut02 {

   public static void main(String[] args) {

       int ia, ib;

       ia = ib = 1;

       ia++;

       ib--;

       System.out.println("ia:"+ia+",ib:"+ib);

   }

}

ia = ia + 1;

ib = ib - 1;

package tut02;

public class Tut02 {

   public static void main(String[] args) {

       int  ia = 10, ib = 10, ix, iy;

       ia++;

       ++ib;

       System.out.println("ia:"+ia+", ib:"+ib);

       ix = --ia;

       iy = ib--;

       System.out.println("ia:"+ia+", ib:"+ib);

       System.out.println("ix:"+ix+", iy:"+iy);

   }

}

ia:11, ib:11

ia:10, ib:10

ix:10, iy:11

자바(JAVA) 강좌 전체 목록 (TOP) >>>

c{java},n{jv007}