/*
도형
도형은 넓이를 구할 수 있다.<< 추상 메소드 abstract 추상적 이기때문에 중괄호를 적지 않는다.
추상 메소드는 일반적인 클래스에 존재 할수 없음 x
추상 메소드는 추상 클래스 에만 존재 할수 있따
abstract class 에만 존재 가능
(또한 완성된 클래스가 아니기에 인스턴스 화가 불가능 하다.) 클래스 참조 변수 = new 클래스(); 가 불가능하다.
추상클래스가 있는 클래스는 상속 받기 위해서는 바디를 만들어 줄 필요가 있다.
메소드의 재정이를 해줄 필요가 있다 @Overrinde
사각형 extends 도형
원 extends 도형
override 메소드의 재정의
메소드의 이름이 같아야한다.(헤더) 접근 제한자 - 반환 타입 메서드 이름(파라미터){}
*/
abstract class Shape {
public abstract void printArea();
}
class Rectangle extends Shape {
@Override
public void printArea() {
System.out.println("가로 x 세로");
}
}
class Circle extends Shape {
@Override
public void printArea() {
System.out.println("파이 x r 제곱");
}
}
public class Main {
public static void main(String[] args) {
// Shape s = new Shape();
Rectangle r = new Rectangle();
Shape s = new Rectangle(); // 업캐스팅이 일어난것.
Circle c = new Circle();
r.printArea();
s.printArea(); // 부모의 형으로 메소드를 호출해도 자식 인스턴스의 동작이 실행된다.
c.printArea();
}
}
// 추상 클래스 라 하더라도 명시되있지 않지만 object 에서 상속 받고 있다.
// 추상 클래스는 일반 메서드와 비슷하며 추상 메서드를 가질수 있다
//하지만 인스턴스 화는 불가능하다.
// 미리 생성자 일반 메서드 (공통 적으로 쓰이는)
// 것을 구현 해두고 자식클래스로 상속을 해준다.
abstract class MyABstractSuper {
private String str;
protected int number;
public MyABstractSuper(String str, int number) {
super();
this.str = str;
this.number = number;
}
public void printField() { // 일반 메서드도 구연이 가능하다
System.out.println(str);
System.out.println(number);
}
public abstract void test();
}
//abstract class MyAbtractSub extends MyABstractSuper{
//
//}
class MySub extends MyABstractSuper {
private String sub;
public MySub(String str, int number, String sub) {
super(str, number);
this.sub = sub;
}
@Override
public void printField() { // printfield 메소드는 추상 클래스인 클래스에서 완성된 메소드 기에 super 함수가 먹히지만
super.printField();
System.out.println(sub);
}
@Override
public void test() {// test 메소드 같은 경우에는 추상 메소드 이기 떄문에 바디를 작성 해줘야 사용이 가능하다.
System.out.println("재정의된 메소드");
}
}
// 추상 메소드에 필드 값이 있더라도 인스턴스화는 불가능하다. (인스 턴스 화를 시킬 필요 없는 클래스다.)
public class Main3 {
public static void main(String[] args) {
// MyABstractSuper("문자열값",0);
MySub s = new MySub("문자열값", 100, "두번째 문자열값");
s.printField();
s.test();
}
}
// 대소를 비교할 수 있음 . 정의 인터페이스
// Comparable 추상 메서드 자체가 자바 내에 정의 되어있음 대소 비교용.
//사람
//키
// Comparable = 비교해서 인트 타입으로 반환해준다.
class Person implements Comparable<Person> {
// Comparable<사용되는 클래스 타입>으로 입력 하면 입력 받는 값이 object 가 아닌 Person 으로 받을수 있다. 이것을
// 제네렉 이라 부른다.
private int height;
public Person(int height) {
super();
this.height = height;
}
@Override
public int compareTo(Person o) { // 대소가 같으면 0 ,(this. 참조(필드값)가 크면 양수),(상대 참조가 크면 음수)
// Person target = (Person) o;
// 받는 파라미터 값이 오브젝트 타입으로 설정 되어 있기때문에 오브젝트를 Person 으로 다운 캐스팅 해야 나중에 연산식에서
// 사용가능.(원래)
// return this.height - target.height;
return this.height - o.height;
}
}
// 상대방 사람과 키를 비교해서 큰지 작은지 같은지를 알려 줄 수 있음
// 다리 (Birdge)
class Bridge implements Comparable<Bridge> {
// 다리 길이
private int length;
public Bridge(int length) {
super();
this.length = length;
}
public int compareTo(Bridge b) {
return this.length - b.length;
}
}
// 다른 다리와 길이를 비교해서 큰지 작은지 같은지를 알려 줄 수 있음
public class Main5 {
public static void main(String[] args) {
Person p = new Person(178);
Person p2 = new Person(180);
Bridge b = new Bridge(200);
Bridge b2 = new Bridge(190);
System.out.println(p.compareTo(p2));
System.out.println(b.compareTo(b2));
}
}
import java.util.Comparator;
// 상품을 담을 수 있는 박스
class Box implements Comparable<Box> {
// 총 중량
private int weight;
// 상품 개수
public int count;
public Box(int weight, int count) {
super();
this.weight = weight;
this.count = count;
}
// 다음박스와 중량을 비교해 알려줄 수 있음
@Override
public int compareTo(Box o) {
return this.weight - o.weight;
}
@Override
public String toString() {
return "Box [weight=" + weight + ", count=" + count + "]";
}
}
class BoxCountComparator implements Comparator<Box> {
// 저울 을 만들기 왼쪽 박스 - 오른쪽 박스 왼쪽이 크면 양수 오른쪽이 크면 음수 같으면 0
@Override
public int compare(Box o1, Box o2) {
return o1.count - o2.count;
}
}
public class Main6 {
public static void main(String[] args) {
Box b1 = new Box(40, 3);
Box b2 = new Box(35, 5);
System.out.println(b1.compareTo(b2));
// 박스 두 개의 상품 개수를 대소비교 하고싶음.
// BoxCountComparator comparator = new BoxCountComparator(); // 도 가능하지만
Comparator<Box> comparator = new BoxCountComparator(); // Comparator 로 다운 캐스팅 해서도 사용가능
System.out.println(comparator.compare(b1, b2));
}
}
// Comparator <타입> 제네렉에대한 설명
//자바는 타입에 매우 엄격함.
// Comparator 를 정의 할때 비교할때마다 대상이 다른데
// 그렇다면 Comparator 의 파라미터는 Object 타입을 받아야한다.
// 그러기 위에서 만들어진 제네렉 이 만들어졌다.
// 제네렉이란 동적으로 타입을 정하는 것으로
// 대응할 타입을 <>안에 작성 해주면 그 타입으로 따라 간다.
// 그렇다는 거은 Comparator 메서드 자체에서 형변환이 이루워 지는것이 아닌
// 제네렉 안쪽에서 형변환이 이루워 지는 것이라고 생각함.
// Comparalbe 은 객체 안에서 자체적으로 수를 비교하는 것= box 자체가 스스로 무게를 비교할수 있다
// Comparator 같은 경우에는 두개를 전달 받아서 하는것 = 저울을 만드는것.
import java.util.Arrays;
public class Main7 {
public static void main(String[] args) {
Box[] boxes = new Box[] { new Box(20, 4), new Box(30, 3), new Box(10, 5) }; // 박스 배열 생성
Arrays.sort(boxes); // 박스 배열 정렬
System.out.println(Arrays.toString(boxes)); // 박스 배열을 문자열로 출력.
// 정의한 타입의 배열을 만들었을때 객체 스스로가 비교를 할수 없을 경우엔
// Arrays 라는 클래스에서 무엇을 기준으로 비교 해야할지 모르기 때문에
// 원래 라면 대소비교가 불가능하다.
// 하지만 class 안쪽에 Comparable 가 정의 되 있다면박스를 크기 순으로 정렬 해준다.
}
}
import java.util.Arrays;
import java.util.Comparator;
//학생
class Student implements Comparable<Student> {
//이름
private String name;
//점수
private int score;
//키
private int height;
//몸무게
private int weight;
//생성자 (모든 필드값)
public Student(String name, int score, int height, int weight) {
super();
this.name = name;
this.score = score;
this.height = height;
this.weight = weight;
}
// 게터세터
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
// toString
@Override
public String toString() {
return "Student [name=" + name + ", score=" + score + ", height=" + height + ", weight=" + weight + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + height;
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + score;
result = prime * result + weight;
return result;
}
// equals.
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (height != other.height)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (score != other.score)
return false;
if (weight != other.weight)
return false;
return true;
}
@Override
public int compareTo(Student o) {
return this.score - o.score;
}
}
class HeightComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
return o1.getHeight() - o2.getHeight();
}
}
class NameComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
return o1.getName().compareTo(o2.getName());
}
}
// 수많은 Comparator 들이 생성 됨 근데 그건 너무 과함 ( main 안쪽에서 확인
public class Main8 {
public static void main(String[] args) {
Student s1 = new Student("둘리", 100, 130, 90);
Student s2 = new Student("도우너", 80, 150, 70);
Student s3 = new Student("길동", 75, 170, 80);
Student[] students = { s1, s2, s3 };
Arrays.sort(students);
System.out.println(Arrays.toString(students));
Arrays.sort(students, new HeightComparator());
System.out.println(Arrays.toString(students));
Arrays.sort(students, new NameComparator());
System.out.println(Arrays.toString(students));
// System.out.println(s1.getName());
// System.out.println(s1.getScore());
//
// System.out.println(s2.toString());
//
// System.out.println(s1.equals(s3));
// 익명 클래스(anonymous class), 내부 클래스 , 지역클래스 라고 도함.
// Comparator 자체가 클래스 객체 끼리의 비교 밖에 안되는듯
// int 타입 입력하니까 오류떳음.
Comparator<Student> com = new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
// 메인 안쪽에서 인스턴스 생성 인터페이스 형식으로 참조는 가능. 내부 클래스 라고도 함.
return o1.getWeight() - o2.getWeight();
}
};
Arrays.sort(students, com);
System.out.println(Arrays.toString(students));
}
}
package Main4;
import java.util.Arrays;
import java.util.Comparator;
//직사각형
// 가로 :int
// 세로 : int
// 생성자(모든 필드)
// 게터세터(모든 필드)
// toString(모든 필드)
// equals(모든 필드)
//getArea() : int - 면적을 구해 정수반환
// ----------------
//임의의 사격형 인스턴스를 여러개 생성하여
// 배열로 참조
// 배열 정렬 (가로 길이 오름차순)
// 배열정렬 (세로 길이 오름차순)
class Rectangle {
int width;
int length;
public Rectangle(int width, int length) {
super();
this.width = width;
this.length = length;
}
public int getWidth() {
return width;
}
public void setWidth(int width) {
this.width = width;
}
public int getLength() {
return length;
}
public void setLength(int length) {
this.length = length;
}
@Override
public String toString() {
return "Rectangle [width=" + width + ", length=" + length + "]";
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Rectangle other = (Rectangle) obj;
if (length != other.length)
return false;
if (width != other.width)
return false;
return true;
}
}
public class Main10 {
public static void main(String[] args) {
Rectangle r1 = new Rectangle(20, 30);
Rectangle r2 = new Rectangle(50, 10);
Rectangle[] rectangles = { r1, r2 };
Comparator<Rectangle> widthCompare = new Comparator<Rectangle>() {
@Override
public int compare(Rectangle o1, Rectangle o2) {
return o1.getWidth() - o2.getWidth();
}
};
Comparator<Rectangle> lengthCompare = new Comparator<Rectangle>() {
@Override
public int compare(Rectangle o1, Rectangle o2) {
return o1.getLength() - o2.getLength();
}
};
Arrays.sort(rectangles, widthCompare);
System.out.println(Arrays.toString(rectangles));
Arrays.sort(rectangles, lengthCompare);
System.out.println(Arrays.toString(rectangles));
}
}
package Main4;
interface A {
void a();
}
interface B {
void b();
}
// 인터페이스도 서로 상속 가능
interface C extends A {
void c();
}
// 인터페이스 A, B를 반드시 '책임'져야하는 관계이다
class MyImpleClass implements C {
@Override
public void a() {
}
@Override
public void c() {
}
}
public class Main12 {
public static void main(String[] args) {
// 인터페이스로 업캐스팅 가능
A m = new MyImpleClass();
m.a();
// m.c();
}
}
package Main4;
/*
작가
글을 쓸 수 있는 도구
글을 쓸 수 있음(도구 필요)
*/
interface Writeable {
void write (String line);
}
class Pencil implements Writeable {
@Override
public void write(String line) {
System.out.println("연필로 " + line + "을 적습니다.");
}
}
class BallPen implements Writeable {
@Override
public void write(String line) {
System.out.println("볼펜으로 " + line + "을 적습니다.");
}
}
// 인터페이스를 필드값으로 선언?
// 하지만 인터페이스는 인스턴스화 불가능
// 그러므로 인터페이스를 구현하는 연필이나 볼펜을 입력
class Author {
private Writeable tool;
public Author(Writeable tool) {
super();
this.tool = tool;
}
public void writeBook() {
tool.write("책 내용");
}
}
public class Main14 {
public static void main(String[] args) {
// 그러므로 인터페이스를 구현하는 연필이나 볼펜을 입력
Author author = new Author(new Pencil());
}
}
package Main4;
// 인터페이스에 추상메서드가 있긴 하지만 그 메소드가 디폴트로 선언하여 기본 메소드 바디를 가지고 있어서
// 컴파일 에러가 안난다. = 오버라이딩이 필수가 아니다.
class Sparrow implements Flyable {
@Override
public void fly() {
}
}
class Helicopter implements Flyable {
@Override
public void fly() {
System.out.println("프로펠로를 회전시켜 납니다.");
}
}
public class Main15 {
public static void main(String[] args) {
Sparrow s = new Sparrow();
s.fly();
Helicopter h = new Helicopter();
h.fly();
}
}
package test;
import java.util.Arrays;
import java.util.Comparator;
import java.util.InputMismatchException;
import java.util.Scanner;
/*
문서 관리 프로그램
1. 문서 목록보기
- 제목 오름차순
- 중요도 오름차순
문서 (제목, 중요도)
*/
public class Main16 {
public static void main(String[] args) {
Document[] documents = new Document[10];
Comparator<Document> comName = new Comparator<Document>() {
@Override
public int compare(Document o1, Document o2) {
return o1.getTitle().compareTo(o2.getTitle());
}
};
Comparator<Document> comImportance = new Comparator<Document>() {
@Override
public int compare(Document o1, Document o2) {
return o1.getImportance() - o2.getImportance();
}
};
documents[0] = new Document("김영곤의 일지", 1);
documents[1] = new Document("오늘 점심 메뉴", 2);
documents[2] = new Document("이호재의 일지", 1);
documents[3] = new Document("스즈메의 문단속", 3);
documents[4] = new Document("노인과 바다", 3);
documents[5] = new Document("오늘 수업내용", 0);
documents[6] = new Document("가라토 시장으로 떠나다", 2);
documents[7] = new Document("용사 여행기", 3);
documents[8] = new Document("슬라임으로 전생한 건에 대하여", 2);
documents[9] = new Document("삼성 지하실 탐험기", 0);
Arrays.sort(documents, comName);
System.out.println("제목 가나다 순\n" + Arrays.toString(documents));
Arrays.sort(documents, comImportance);
System.out.println("중요도 기준\n" + Arrays.toString(documents));
Scanner scan = new Scanner(System.in);
boolean power = true;
while (power) {
System.out.println("찾고싶은 파일의 중요도를 입력해주세요");
System.out.println("현재 중요도는 0~3 까지 있으며 0번이 최 중요 파일입니다.");
try {
int userWant = scan.nextInt();
scan.nextLine();
if (userWant >= 0 && userWant <= 3) {
for (int i = 0; i < documents.length; ++i) {
if (userWant == documents[i].getImportance()) {
System.out.println(documents[i].toString());
}
power = false;
}
} else {
System.out.println("잘못 입력하셨습니다.\n");
}
} catch (InputMismatchException String) {
System.out.println("정수를 입력해주세요.\n");
scan.nextLine();
}
}
}
}