Java에서 클래스를 사용하는 방법

Java에서 클래스를 사용하는 방법

Generics와 Generics가 실제로 뒤에서 무엇을 하고 있는지에 대한 좋은 토론이 있기 때문에 우리는 모두 알고 있습니다.Vector<int[]>입니다.HashTable<String, Person>입니다.Person 하는 것은 s.의 이다.Class<>.

클래스 " " "Class템플릿 이름도 사용해야 합니다(또는 일식에서는 노란색 밑줄이 표시됩니다).★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★의 포인트Class오브젝트란 오브젝트에 대한 정보, 반사 등의 정보를 완전히 가지고 있지 않은 경우를 말합니다.할 수 거죠?Class브젝젝 츠요시 모릅니다 저는 이 말을 것입니다.Class오브젝트라면 특정 오브젝트를 사용할 수 있습니다.

"모든 클래스의 모든 인스턴스가 동일한 java.lang을 공유합니다.해당 유형의 클래스 개체"

예)

Student a = new Student();
Student b = new Student();

★★★★★★★★★★★★★★★.a.getClass() == b.getClass()정말이에요.

이제 가정해 보겠습니다.

Teacher t = new Teacher();

제네릭스를 사용하지 않고 다음과 같이 할 수 있습니다.

Class studentClassRef = t.getClass();

하지만 이건 지금 잘못된 건가요?

))public void printStudentClassInfo(Class studentClassRef) {}로 수 Teacher.class

제네릭을 사용하면 이 문제를 피할 수 있습니다.

Class<Student> studentClassRef = t.getClass(); //Compilation error.

T는?,, T가 뭐 ? 뭐 뭐 now?T는 유형 파라미터(타입 변수라고도 함)입니다.각괄호(<>)로 구분되어 클래스 이름 뒤에 표시됩니다.
T는 클래스 파일 쓰기 중에 선언된 변수 이름(임의의 이름일 수 있음)과 같은 기호일 뿐입니다.는 T로 됩니다.
중 한 클래스 ( 「」 「」 「 」HashMap<String> map = new HashMap<String>();)

))class name<T1, T2, ..., Tn>

★★★★★★★★★★★★★★★★★.Class<T>는 특정 유형인 ' 오브젝트'를 나타냅니다.T

클래스 메서드가 다음과 같이 알 수 없는 유형 매개 변수와 함께 작동해야 한다고 가정합니다.

/**
 * Generic version of the Car class.
 * @param <T> the type of the value
 */
public class Car<T> {
    // T stands for "Type"
    private T t;

    public void set(T t) { this.t = t; }
    public T get() { return t; }
}

는 기 t T 는 음 음 음 음 음 음 음 음 here here here here here here here here here here here here here here here here here here here hereStringCarName 이라고 입력합니다.

는 는는 T 、 또 는 는 음 be or T는 'T'로 사용할 수 있습니다.Integermodel Number로 입력합니다.

는 는는 T 、 또 는 는 음 be or T는 'T'로 사용할 수 있습니다.Object유효한 차량 인스턴스로 입력합니다.

다음은 실행 시 다르게 사용할 수 있는 단순한 POJO입니다.
, 은 T의 단, T를 String "으로 선언한 에는 T"를 "String "로 선언합니다.", "T"를 "T"로 선언합니다.
))HashMap<String> map = new HashMap<String>();스트링 클래스

일반적인 방법

범용 메서드는 자체 유형 매개 변수를 도입하는 메서드입니다.이는 일반 유형을 선언하는 것과 유사하지만 type 매개 변수의 범위는 선언된 메서드로 제한됩니다.정적 및 비정적 일반 메서드 및 일반 클래스 생성자를 사용할 수 있습니다.

일반 메서드의 구문에는 형식 매개 변수, 내부 꺾쇠 괄호가 포함되어 메서드의 반환 유형 앞에 표시됩니다.일반 메서드의 경우 메서드의 반환 유형 앞에 유형 매개 변수 섹션이 표시되어야 합니다.

 class Util {
    // Generic static method
    public static <K, V, Z, Y> boolean compare(Pair<K, V> p1, Pair<Z, Y> p2) {
        return p1.getKey().equals(p2.getKey()) &&
               p1.getValue().equals(p2.getValue());
    }
}

 class Pair<K, V> {

    private K key;
    private V value;
}

서 ★★★★<K, V, Z, Y>는 메서드 으로, 에 메서드(메서드)가 .boolean

선언을 합니다.<T>는 클래스 레벨에서 이미 선언되어 있기 때문에 메서드레벨에서는 필수가 아닙니다.

class MyClass<T> {
   private  T myMethod(T a){
       return  a;
   }
}

단, 클래스 레벨유형 파라미터 K, V, Z 및 Y는 스태틱콘텍스트(여기서는 스태틱 방식)에서는 사용할 수 없기 때문에 아래는 잘못되어 있습니다.

class Util <K, V, Z, Y>{
    // Generic static method
    public static  boolean compare(Pair<K, V> p1, Pair<Z, Y> p2) {
        return p1.getKey().equals(p2.getKey()) &&
               p1.getValue().equals(p2.getValue());
    }
}

기타 유효한 시나리오는 다음과 같습니다.

class MyClass<T> {

        //Type declaration <T> already done at class level
        private  T myMethod(T a){
            return  a;
        }

        //<T> is overriding the T declared at Class level;
        //So There is no ClassCastException though a is not the type of T declared at MyClass<T>. 
        private <T> T myMethod1(Object a){
                return (T) a;
        }

        //Runtime ClassCastException will be thrown if a is not the type T (MyClass<T>).  
        private T myMethod1(Object a){
                return (T) a;
        }       

        // No ClassCastException        
        // MyClass<String> obj= new MyClass<String>();
        // obj.myMethod2(Integer.valueOf("1"));
        // Since type T is redefined at this method level.
        private <T> T myMethod2(T a){
            return  a;
        }

        // No ClassCastException for the below
        // MyClass<String> o= new MyClass<String>();
        // o.myMethod3(Integer.valueOf("1").getClass())
        // Since <T> is undefined within this method; 
        // And MyClass<T> don't have impact here
        private <T> T myMethod3(Class a){
            return (T) a;
        }

        // ClassCastException for o.myMethod3(Integer.valueOf("1").getClass())
        // Should be o.myMethod3(String.valueOf("1").getClass())
    private  T myMethod3(Class a){
        return (T) a;
    }


        // Class<T> a :: a is Class object of type T
        //<T> is overriding of class level type declaration; 
        private <T> Class<T> myMethod4(Class<T> a){
            return  a;
        }
    }

으로 Static 명시적이어야 .<T>계급 레벨에서 하지 않는다.Class<T>클래스 레벨 T가 인스턴스에 바인드되어 있기 때문입니다.

제네릭에 관한 제약사항도 확인.

와일드카드와 서브타이핑

범용 메서드의 type 인수

Class의 생성 버전을 사용하면 무엇보다도 다음과 같은 것을 쓸 수 있습니다.

Class<? extends Collection> someCollectionClass = someMethod();

객체가 Class를 할 수 있습니다.Collection수집하다

Java 문서:

[...] 더욱 놀라운 것은 클래스가 생성되었다는 것입니다.이제 클래스 리터럴은 런타임 및 컴파일 시간 유형 정보를 모두 제공하는 유형 토큰으로 작동합니다.이를 통해 새로운 AnnotationElement 인터페이스의 getAnnotation 메서드에 의해 예시되는 스태틱팩토리 스타일이 활성화됩니다.

<T extends Annotation> T getAnnotation(Class<T> annotationType); 

이것은 일반적인 방법입니다.인수에서 유형 파라미터 T의 값을 유추하여 다음 스니펫에 나타나듯이 적절한 T 인스턴스를 반환합니다.

Author a = Othello.class.getAnnotation(Author.class);

제네릭스를 사용하기 전에 결과를 작성자에게 전달해야 합니다.또한 컴파일러가 실제 매개 변수가 주석의 하위 클래스를 나타내는지 확인할 방법이 없습니다. [...]

이런 걸 쓸 필요가 없었어요누구라도 있나요?

class<T>를 들어 예를 들면,

<T> T getService(Class<T> serviceClass)
{
    ...
}

@Kire Haglin의 답변에 이어 JAXB 언마셜링 관련 문서에서 제네릭 방식의 추가 예를 볼 수 있습니다.

public <T> T unmarshal( Class<T> docClass, InputStream inputStream )
         throws JAXBException {
  String packageName = docClass.getPackage().getName();
  JAXBContext jc = JAXBContext.newInstance( packageName );
  Unmarshaller u = jc.createUnmarshaller();
  JAXBElement<T> doc = (JAXBElement<T>)u.unmarshal( inputStream );
  return doc.getValue();
}

에 의해, 「」가 가능하게 됩니다.unmarshalJAXB의 약자

되듯이, 이 '다'라고 하는 이유, '다'라고 하는 이유, '다'라고 하는 이유, '다'라고 하는 것은 여러 가 있습니다.class범용화 되었습니다.을 알 있는 가 많아요.Class<T>.하거나 황일식 경고를 사용할 수 Class<?> 하고 .;)렇게 、 ))))) ;)

in in 。<T>범용 클래스를 의미합니다.Generic Class는 모든 데이터 유형에서 작업할 수 있는 클래스입니다.즉, 데이터 유형에 의존하지 않는 클래스라고 할 수 있습니다.

public class Shape<T> {
    // T stands for "Type"
    private T t;

    public void set(T t) { this.t = t; }
    public T get() { return t; }
}

여기서 T는 유형을 의미합니다.이제 이 Shape 클래스의 인스턴스를 만들 때 컴파일러에 이 클래스가 동작하는 데이터 유형을 알려야 합니다.

예:

Shape<Integer> s1 = new Shape();
Shape<String> s2 = new Shape();

Integer는 유형이며 String도 유형입니다.

<T>특히 Generic Type의 약자입니다.Java Docs에 따르면 일반 유형은 유형에 따라 매개 변수가 지정되는 일반 클래스 또는 인터페이스입니다.

하실 수 .Class를 들어, . 를를들 ..Class<? extends JComponent>가 '부재하다'의 할 수 JComponent . 。ClassClass.forName 하면 Class.asSubclass예를 들어 예를 들어 예를 들어 예를 들어 예를 들어 사례를 구축하기 전에 캐스팅을 해야 합니다.

예로 Class클래스)의(클래스)를 들 수 있습니다.Class<T>과 같은 인 함수를 할 수 를 사용하면 다음과 같은 일반적인 함수를 작성할 수 있습니다.

public static <T extends Enum<T>>Optional<T> optionalFromString(
        @NotNull Class<T> clazz,
        String name
) {
    return Optional<T> opt = Optional.ofNullable(name)
            .map(String::trim)
            .filter(StringUtils::isNotBlank)
            .map(String::toUpperCase)
            .flatMap(n -> {
                try {
                    return Optional.of(Enum.valueOf(clazz, n));
                } catch (Exception e) {
                    return Optional.empty();
                }
            });
}

처음에는 헷갈려요.단, 다음과 같은 상황에서는 도움이 됩니다.

class SomeAction implements Action {
}

// Later in the code.
Class<Action> actionClass = Class.forName("SomeAction"); 
Action action = actionClass.newInstance();
// Notice you get an Action instance, there was no need to cast.

쇠고기 클래스만 사용하십시오.

public <T> T beefmarshal( Class<beef> beefClass, InputBeef inputBeef )
     throws JAXBException {
     String packageName = docClass.getPackage().getBeef();
     JAXBContext beef = JAXBContext.newInstance( packageName );
     Unmarshaller u = beef.createBeef();
     JAXBElement<T> doc = (JAXBElement<T>)u.beefmarshal( inputBeef );
     return doc.getBeef();
}

언급URL : https://stackoverflow.com/questions/462297/how-to-use-classt-in-java