Java 학습 카드 Day 18

지식 내용

인터페이스의 다태: 다양한 유형의 인용이 같은 대상을 가리킬 때 대상을 바라보는 시각이 다르다는 것을 나타낸다.인용에 따라 보이는 대상의 범위가 다르기 때문에 자신의 유형이 성명한 범위만 호출할 수 있습니다.

흔한 관계: 클래스와 클래스: 단일 계승, extends 부류 명칭 클래스와 인터페이스: 다중 실현,implements 인터페이스 명칭 1, 인터페이스 명칭 2, 인터페이스 명칭 n 인터페이스와 인터페이스: 다중 계승, extends 부류 인터페이스 1, 부인터페이스 2, 부인터페이스 n

상량 인터페이스: 상태나 고정값을 나타내는 변수로 정적 상량의 형식으로 인터페이스에 정의됩니다.

인터페이스는 표준 리셋 원리이다. 기존 인터페이스의 사용자, 뒤에 인터페이스가 있는 실현자(1) 표준: 인터페이스(2) 도구: 인터페이스의 사용자(3) 인터페이스의 실현자: 프로그래머(4) 도구의 호출자: 프로그래머

오늘 연습

에는 다음과 같은 코드가 있다.

interface IA{
	void ma();
}

interface IB extends IA{
	void mb();
}
interface IC{
	void mc();
}

interface ID extends IB,IC{
	void md();
}

(1) 클래스 ClassE가 ID 인터페이스를 실현하고 ClassE가 추상적인 것을 원하지 않는다면 어떤 방법을 실현해야 합니까?참고 답안:public void mb() {}public void ma() {}public void mc() {}public void md () {} (2) 아래 코드를 완전하게 보충

public class TestClassE {

	public static void main(String[] args) {
		IC ic = new ClassE();
		// ma 
	
		// mb 
		
		// mc 
		
		// md 

	}


}

A:ClassE c1 = (ClassE)ic;c1.ma(); c1.mb(); ic.mc(); c1.md(); (3) 아래 코드의 출력 결과를 작성한다.

public class TestClassE {

	public static void main(String[] args) {
		IC ic = new ClassE();
		
		System.out.println(ic instanceof IA);
		System.out.println(ic instanceof IB);
		System.out.println(ic instanceof IC);
		System.out.println(ic instanceof ID);
		System.out.println(ic instanceof ClassE);
	}
}

대답: true true true true true

에는 다음과 같은 코드가 있다.

interface IA{
	void ma();
}

interface IB{
	void mb();
}

class MySuper implements IA{
	public void ma() {}

}

class MySub extends MySuper implements IB{
	public void mb() {}
}

public class TestMain {

	public static void main(String[] args) {
		MySuper ms = new MySub();
		System.out.println(ms instanceof IA);
		System.out.println(ms instanceof IB);
		System.out.println(ms instanceof MySuper);
		System.out.println(ms instanceof MySub);
	}
}

물음: 이 프로그램의 출력 결과는 무엇입니까?참조 답안:true true true true

인터페이스와 추상류에 대해 다음과 같은 표현이 정확하다. A.추상류는 구조 방법이 있을 수 있고 인터페이스에는 구조 방법이 없다.추상 클래스에는 속성이 있고 인터페이스에는 속성 C가 없습니다.추상류는 비추상적인 방법이 있을 수 있는데 인터페이스에 모두 추상적인 방법 D가 있다.추상 클래스와 인터페이스에서 대상 E를 만들 수 없습니다.하나의 클래스는 최대 하나의 추상적인 클래스를 계승할 수 있지만 여러 개의 인터페이스를 실현할 수 있다. ABCDE

아래 코드의 출력 결과를 쓰십시오

interface Light{
	void shine();
}
class Redlight implements Light{

	public void shine() {
		System.out.println("Red Light shine in Red");
		
	}
	
}
class Yellowlight implements Light{

	public void shine() {
		System.out.println("Yellow Light shine in Yellow");
		
	}
	
}
class Greenlight implements Light{

	public void shine() {
		System.out.println("Green Light shine in Green");
		
	}
	
}
class Lamp{
	private Light light;
	public void setLight(Light light){
		this.light = light;
	}
	public void on(){
		light.shine();
	}
}
public class TestLamp {

	public static void main(String[] args) {
		Light[] Is = new Light[3];
		Is[0] = new Redlight();
		Is[1] = new Yellowlight();
		Is[2] = new Greenlight();
		Lamp lamp = new Lamp();
		for(int i = 0 ; i < Is.length ; i++){
			lamp.setLight(Is[i]);
			lamp.on();
		}
	}
}

답: Red Light shine in Red Yellow Light shine in Yellow Green Light shin Green

아래 코드의 실행 결과를 작성

interface JavaTeacher{
	void teach();
}
class TeacherA implements JavaTeacher{

	public void teach() {
		System.out.println("TeacherA teach Java");
	}
	
}
class TeacherB implements JavaTeacher{

	public void teach() {
		System.out.println("TeacherB teach Java");
	}
	
}
class School{
	public static JavaTeacher getTeacher(int i){
		if(i==0)
			return new TeacherA();
		else
			return new TeacherB();
	}
}
public class TestSchool {

	public static void main(String[] args) {
		JavaTeacher jt = School.getTeacher(0);
		jt.teach();
		jt = School.getTeacher(10);
		jt.teach();

	}

}

A:TeacherA teach Java TeacherB teach Java

코드 공백

abstract class Animal{
	public abstract void eat();
	
}
interface Pet{
	void play();
}
class Dog extends Animal implements Pet{

	public void eat() {
		System.out.println("Dog eat Bones");
		
	}
	public void play() {
		System.out.println("play with Dog");
		
	}
}
class Cat extends Animal implements Pet{

	public void eat() {
		System.out.println("Cat eat Bones");
		
	}
	public void play() {
		System.out.println("play with Cat");
		
	}
}
class Wolf extends Animal{

	public void eat() {
		System.out.println("Wolf eat meat");
	
	}
}
public class TestMain {

	public static void main(String[] args) {
		Animal as[] = new Animal[3];
		as[0] = new Dog();
		as[1] = new Cat();
		as[2] = new Wolf();
		// as eat 
		//1
		// as play 
		//2
	}
}
		//1 _____________
		//2 _____________

A: 1곳의 코드:

for(int i = 0; i < as.length ; i++){
			as[i].eat();
		}

2곳의 코드:

for(int i = 0; i < as.length ; i++){
			if(as[i] instanceof Pet)
				((Pet) as[i]).play();
		}

기존 Chap6의 17문제를 토대로 코드를 수정한 회사는 Salaried Employee에게 매달 2000위안의 잔업비를 별도로 지급하고 Base Plus Sales Employee에게 1000위안의 잔업비를 지급하며 기존 코드를 고쳐 논리에 가입한다.그리고 이번 달 회사가 모두 얼마의 잔업비를 지급했는지 프린트하는 방법을 쓴다.A:

package Q8.T11;

interface OverTimeFire{
	public static final double SALARIED_EMPLOYEE = 2000.0;
	public static final double BASE_PLUS_SALAS_EMPLOYEE = 1000.0;
}
public class TestEmployee implements OverTimeFire {
	public static void main(String[] args) {
		Employee[] es = new Employee[4];
		es[0] = new SalariedEmployee("John", 5, 5000);
		es[1] = new HourlyEmployee("Tom", 10, 25, 170);
		es[2] = new SalesEmployee("Lucy", 7, 200000, 0.03);
		es[3] = new BasePlusSalesEmployee("James", 8, 1000000, 0.02, 5000);
		
		for(int i = 0; i<es.length; i++){
			System.out.println(es[i].getSalary(5));
		}
		double sum = 0;
		for(int i = 0; i<es.length; i++){
			if(es[i] instanceof SalariedEmployee)
				sum = sum + SALARIED_EMPLOYEE;
			if(es[i] instanceof BasePlusSalesEmployee)
				sum = sum + BASE_PLUS_SALAS_EMPLOYEE;
		}
		System.out.println(" ："+sum);
	}
}
class Employee{
	private String name;
	private int birthMonth;
	public Employee(String name,int birthMonth){
		this.name=name;
		this.birthMonth=birthMonth;
	}
	public String getName(){
		return name;
	}
	public double getSalary(int month){
		if (this.birthMonth==month) return 100;
		else return 0;
	}
}
class SalariedEmployee extends Employee implements OverTimeFire{
	private double salary;
	public SalariedEmployee(String name,int birthMonth,double salary){
		// name，birthMonth ， 
		super(name,birthMonth);
		this.salary=salary;
	}
	public double getSalary(int month){
		// getSalary （ ）， 
		return salary+super.getSalary(month) + SALARIED_EMPLOYEE ;
	}
}
class HourlyEmployee extends Employee{
	private double salaryPerHour;
	private int hours;
	public HourlyEmployee(String name, int birthMonth, double salaryPerHour, int hours) {
		super(name, birthMonth);
		this.salaryPerHour = salaryPerHour;
		this.hours = hours;
	}
	public double getSalary(int month){
		double result=0;
		if (hours>160) result=160*this.salaryPerHour+(hours-160)*this.salaryPerHour*1.5;
		else result=this.hours*this.salaryPerHour;
		return result+super.getSalary(month);
	}
}
class SalesEmployee extends Employee{
	private double sales;
	private double rate;
	public SalesEmployee(String name, int birthMonth, double sales, double rate) {
		super(name, birthMonth);
		this.sales = sales;
		this.rate = rate;
	}
	public double getSalary(int month) {
		return this.sales*this.rate+super.getSalary(month);
	}
}
class BasePlusSalesEmployee extends SalesEmployee implements OverTimeFire{
	private double basedSalary;
	public BasePlusSalesEmployee(String name, int birthMonth, double sales, double rate, double basedSalary) {
		super(name, birthMonth, sales, rate);
		this.basedSalary = basedSalary;
	}
	public double getSalary(int month) {
		return this.basedSalary+super.getSalary(month) + BASE_PLUS_SALAS_EMPLOYEE;
	}
}

interface ServiceInterface{
	void doService1();
	void doService2();
	void doService3();
}
abstract class AbstractService implements ServiceInterface{
	public void doService1(){}
	public void doService2(){}
	public void doService3(){}
}

ServiceInterface 인터페이스를 구현하는 클래스 My Service가 필요합니다.(1) 첫 번째 방식은 My 서비스로 하여금 서비스 인터페이스 인터페이스를 실현하게 할 수 있다. 즉,class My 서비스 implements 서비스 인터페이스 (2) 두 번째 방식은 My 서비스로 하여금 Abstract 서비스 종류를 실현하게 할 수 있다. 즉,class My 서비스 extends 서비스 인터페이스. 이 두 가지 방식은 어떤 차이가 있습니까?AbstractService 클래스는 어떤 역할을 합니까?답: 첫 번째 상황은 인터페이스 안의 모든 추상적인 방법을 다시 써야 한다. 두 번째 상황은 추상적인 방법을 다시 쓸 필요가 없다.

고드바흐가 6보다 큰 짝수를 입력할 것이라고 추측한 것을 검증하고 이 짝수가 어느 두 질수의 합으로 분해될 수 있는지 출력해 주십시오.예를 들어 10=3+7 12=5+7 요구: 두 사람이 한 조로 합작하여 완성한다.한 사람은 하나의 정수 n을 두 개의 정수의 합으로 나누는 것을 책임지고, 다른 한 사람은 함수를 써서 어떤 정수 a의 질수 여부를 판단하는 것을 책임진다.응답

 import java.util.Scanner;

interface MathTool{
	boolean isPrime(int n);
}

// 
class MathToolImpl implements MathTool{

	public boolean isPrime(int n) {
		for(int i = 2; i<= Math.sqrt(n); i++){
			if (n % i == 0) return false;
		}
		return true;
	}
	
}

// 
	public class TestGoldBach {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		MathTool mt = new MathToolImpl();
		for(int i = 2; i<=n/2; i++){
			if (mt.isPrime(i) && mt.isPrime(n - i)){
				System.out.println(n + "=" + i + "+" + (n - i));
			}
		}
	}
}

카드 타임

There is often only one reason for your confusion, which is that you think too much and do too little at an age when you should be working hard. - 막연한 이유는 한 가지뿐이다. 그것은 죽어라 노력해야 할 나이에 너무 많이 생각하고 너무 적게 하는 것이다.

이 내용에 흥미가 있습니까?

현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:

다양한 언어의 JSON

JSON은 Javascript 표기법을 사용하여 데이터 구조를 레이아웃하는 데이터 형식입니다. 그러나 Javascript가 코드에서 이러한 구조를 나타낼 수 있는 유일한 언어는 아닙니다. 저는 일반적으로 '객체'{}...

텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.

CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.

Java 학습 카드 Day 18

지식 내용

오늘 연습

카드 타임

좋은 웹페이지 즐겨찾기