Kotlin 클래스 및 개체인터페이스추상류
17847 단어 Kotlin
class Account {
var acc_no: Int = 0
var name: String? = null
var amount: Float = 0f
fun insert(ac: Int,n: String, am: Float ) {
acc_no=ac
name=n
amount=am
println(" : ${acc_no} ， :${name}， :${amount}")
}
fun deposit() {
//deposite code
}
fun withdraw() {
// withdraw code
}
fun checkBalance() {
//balance check code
}
}
Account acc_no，name，amount ：deposit()，withdraw()，checkBalance()。
Kotlin ， 。 ， acc_no 0，name null，amount 0f。
：
fun main(args: Array){
// Account()
var acc= Account()
acc.insert(832345,"Maxsu",1000f) //
println("${acc.name}") //
}
중첩 클래스와 내부 클래스 중첩 클래스 중첩 클래스는 다른 클래스에서 만들어진 클래스입니다.Kotlin에서 중첩 클래스는 기본적으로 정적입니다. 따라서 클래스 대상을 만들지 않고 데이터 구성원과 구성원 함수에 접근할 수 있습니다.중첩 클래스는 외부 클래스의 데이터 구성원에 접근할 수 없습니다.
：
class outerClass{
private var name: String = "Ashu"
class nestedClass{
var description: String = "code inside nested class"
private var id: Int = 101
fun foo(){
// print("name is ${name}") // cannot access the outer class member
println("Id is ${id}")
}
}
}
fun main(args: Array){
// nested class must be initialize
println(outerClass.nestedClass().description) // accessing property
var obj = outerClass.nestedClass() // object creation
obj.foo() // access member function
}
Kotlin 내부 클래스 내부 클래스는 키워드 inner를 사용하여 클래스에 생성된 클래스입니다.다시 말하면 inner로 표시된 플러그인 클래스를 내부 클래스라고 할 수 있다.내부 클래스는 인터페이스나 비내부 플러그인 클래스에서 설명할 수 없습니다.내부 클래스가 플러그인 클래스보다 낫다는 장점은 개인 클래스라도 외부 클래스의 구성원을 방문할 수 있다는 것이다.내부 클래스는 외부 클래스의 대상에 대한 인용을 유지합니다.Kotlin 구조 함수Kotlin에서 구조 함수는 메소드와 유사한 코드 블록입니다.구조 함수의 명칭은 클래스의 명칭과 같고, 그 다음은 괄호 () 와 같다.구조 함수는 대상을 만들 때 변수를 초기화하는 데 사용됩니다.Kotlin 구조 함수의 유형인 Kotlin에는 두 가지 유형의 구조 함수가 있다. 1.0 주 구조 함수 2.0 보조 구조 함수인 Kotlin 클래스에는 하나의 주요 구조 함수만 있고 보조 구조 함수는 하나 또는 여러 개일 수 있다.주 구조 함수 주 구조 함수는 클래스를 초기화하는 데 사용되며, 클래스 제목에 표시됩니다.주 구조 함수 코드는 선택할 수 있는 매개 변수가 있는 괄호로 묶여 있다
// name ， id
class myClass(val name: String, var id: Int) {
}
fun main(args: Array){
val myclass = myClass ("Susen", 10010)
println("Name = ${ myclass.name}")
println("Id = ${ myclass.id}")
}
초기화 블록의 주구조 함수 주구조 함수는 어떠한 코드도 포함하지 않으며 초기화 프로그램 블록은 초기화 코드에 사용됩니다.블록은 init 키워드를 접두어로 합니다.실례를 초기화하는 동안 블록의 실행 순서는 클래스에 나타나는 순서와 같습니다.
class myClass(name: String, id: Int) {
val e_name: String
var e_id: Int
init{
e_name = name.capitalize()
e_id = id
println("Name = ${e_name}")
println("Id = ${e_id}")
}
}
fun main(args: Array){
val myclass = myClass ("Maxsu", 10010)
}
// name id val var， myClass ,
e_name e_id
Kotlin 보조 구조 함수 Kotlin은 클래스에서 하나 이상의 보조 구조 함수를 만듭니다.constructor 키워드를 사용하여 보조 구조 함수를 만듭니다.
class MyClass{
var c_id:Int = 0
var c_name:String? = null
constructor(id: Int){
c_id = id
}
constructor(name: String, id: Int){
c_id = id
c_name =name
}
}
：
var my = MyClass(1)
var my2 = MyClass("",1)
같은 클래스에서 주와 보조 구조 함수를 사용할 수도 있다.같은 클래스에서 주와 보조구조 함수를 사용함으로써 보조구조 함수는 주구조 함수에 권한을 부여해야 한다.this () 키워드를 사용하여 같은 클래스의 다른 구조 함수를 권한을 부여합니다.
class myClass(password: String){
constructor(name: String, id: Int, password: String): this(password){
println("Name = ${name}")
println("Id = ${id}")
println("Password = ${password}")
}
}
fun main(args: Array){
val myclass = myClass ("Maxsu", 101, "passwd123")
}
같은 클래스의 보조 구조 함수에서 다른 보조 구조 함수를 호출합니다. Kotlin에서 보조 구조 함수는 같은 클래스의 다른 보조 구조 함수를 호출할 수 있습니다.this () 키워드를 사용하여 완성할 수 있습니다.
class myClass{
constructor(name: String, id: Int): this(name,id, "mypassword"){
println(" ")
println("Name = ${name}")
println("Id = ${id}")
}
constructor(name: String, id: Int,pass: String){
println(" ")
println("Name = ${name}")
println("Id = ${id}")
println("Password = ${pass}")
}
}
fun main(args: Array){
val myclass = myClass ("Maxsu", 10010)
}
파생 클래스 보조 구조 함수에서 하이퍼클래스 보조 구조 함수를 호출합니다. Kotlin에서 하나의 파생 클래스 보조 구조 함수는 기본 클래스의 보조 구조 함수를 호출할 수 있습니다.슈퍼 키워드를 사용하여 완성할 수 있습니다. 이것은 계승적인 개념입니다.
open class Parent{
constructor(name: String, id: Int){
println(" ")
println("Name = ${name}")
println("Id = ${id}")
}
constructor(name: String, id: Int,pass: String){
println(" ")
println("Name = ${name}")
println("Id = ${id}")
println("Password = ${pass}")
}
}
class Child: Parent{
constructor(name: String, id: Int): super(name,id){
println(" ")
println("Name = ${name}")
println("Id = ${id}")
}
constructor(name: String, id: Int,pass: String):super(name,id,"password"){
println(" ")
println("Name = ${name}")
println("Id = ${id}")
println("Password = ${pass}")
}
}
fun main(args: Array){
val obj1 = Child("Susen", 10010)
val obj2 = Child("Susen", 10010,"mypassword")
}
수식자:public: 공개적으로 보이는 보호자: 클래스나 하위 클래스에 대한 가시적 인터넷 허용: 필드를 실현하는 모듈에서만 볼 수 있도록 합니다.private: 성명 속성, 필드 등의 블록에서만 접근할 수 있으며, 접근 범위 외부는 허용하지 않습니다.이 특정 파일에서 개인 패키지 클래스에 접근할 수 있는 계승은 두 개 이상의 클래스가 같은 속성을 가지고 있을 때 계승의 개념을 도입한다.계승은 코드의 중용성을 높이는 데 쓰인다.파생 클래스는 하나의 기본 클래스만 있지만 여러 개의 인터페이스가 있을 수 있습니다. 기본 클래스는 하나 이상의 파생 클래스가 있을 수 있습니다. (1) Kotlin 클래스는 기본적으로final이기 때문에 쉽게 계승할 수 없습니다.클래스 이전에 오픈 키를 사용하여 다른 클래스를 계승합니다.(2) 하나의 클래스를 계승하여 클래스를 파생시킬 때 모든 필드와 함수는 계승된다.파생 클래스에서 이 필드와 함수를 사용할 수 있습니다.
open class Employee(name: String, age: Int, salary: Float) {
// code of employee
}
class Programmer(name: String, age: Int, salary: Float): Employee(name,age,salary) {
// code of programmer
}
class Salesman(name: String, age: Int, salary: Float): Employee(name,age,salary) {
// code of salesman
}
Kotlin 상속과 주요 구조 함수 기본 클래스와 파생 클래스가 모두 주 구조 함수를 가지고 있다면 매개 변수는 기본 클래스의 주 구조 함수에서 초기화됩니다.위의 계승 예시에서 모든 클래스는 세 개의 매개 변수를 포함한다:name,age,salary. 모든 매개 변수는 기본 클래스의 주 구조 함수에서 초기화됩니다.기본 클래스와 파생 클래스가 주 구조 함수에 서로 다른 수량의 매개 변수를 포함할 때 기본 클래스 매개 변수는 파생 클래스의 대상에서 초기화됩니다.
open class Employee(name: String,salary: Float) {
init {
println(" ：$name.")
println(" ：$salary")
}
}
class Programmer(name: String, dept: String, salary: Float):Employee(name,salary){
init {
println("$name ：$dept ， ：$salary.")
}
fun doProgram() {
println(" .")
}
}
class Salesman(name: String, dept: String, salary: Float):Employee(name,salary){
init {
println("$name ：$dept ， ：$salary.")
}
fun fieldWork() {
println(" ： .")
}
}
fun main(args: Array){
val obj1 = Programmer("Susen", " ", 40000f)
obj1.doProgram()
println()
val obj2 = Salesman("Ajax", " ", 30000f)
obj2.fieldWork()
}
Kotlin 계승 및 보조 구조 함수 파생 클래스에 주 구조 함수가 포함되지 않으면 슈퍼 키워드를 사용하여 파생 클래스에서 기본 보조 구조 함수를 호출해야 합니다.
open class Patent {
constructor(name: String, id: Int) {
println(" ： $id ， $name ")
}
}
class Child: Patent {
constructor(name: String, id: Int, dept: String): super(name, id) {
print(" ：$name, $id, $dept")
}
}
fun main(args: Array) {
val child = Child("Maxsu",10010, " ")
}
Kotlin 메소드 덮어쓰기 메소드 덮어쓰기는 super(parent) 클래스 메소드의 특정 구현을 하위 클래스 (하위) 클래스에 제공하는 것을 의미합니다.다시 말하면, 하위 클래스가 초클래스를 다시 정의하거나 수정하는 방법이 하위 클래스일 때, 이를 방법 덮어쓰기라고 부른다.방법 덮어쓰기는 계승에서만 가능합니다.Kotlin 메소드 덮어쓰기 규칙: 1.0 부모 클래스와 덮어쓸 메소드나 속성은 Open이어야 합니다. (final이 아닙니다.)2.0 기류와 파생류의 방법명은 반드시 같아야 한다.3.0 메서드에는 베이스 클래스와 동일한 매개변수가 있어야 합니다.4.0 부모 클래스를 덮어쓰는 방법은 덮어쓸 부모 클래스와 방법을 오픈으로 표시해야 합니다.또한 하위 클래스에서 다시 쓰는 방법은 오버라이드 키워드로 시작해야 합니다.
open class Bird {
open fun fly() {
println("Bird is flying...")
}
}
class Parrot: Bird() {
override fun fly() {
println("Parrot is flying...")
}
}
class Duck: Bird() {
override fun fly() {
println("Duck is flying...")
}
}
fun main(args: Array) {
val p = Parrot()
p.fly()
val d = Duck()
d.fly()
}
5.0 파생 클래스도 슈퍼 키워드를 사용하여 슈퍼 클래스 방법과 속성을 호출할 수 있다.
open class Bird {
open var color = " "
open fun fly() {
println("Bird is flying...")
}
}
class Parrot: Bird() {
override var color = " "
override fun fly() {
super.fly()
println("Parrot is flying...")
}
}
fun main(args: Array) {
val p = Parrot()
p.fly()
println(p.color)
}
Kotlin 다중 클래스는 Kotlin에서 이루어지고 파생 클래스는 뾰족한 괄호에 초유형 이름, 즉 슈퍼를 사용합니다. 여러 클래스에서 제공하는 같은 함수 이름을 실현할 때.예를 들어, 파생 클래스 Parrot은 하이퍼클래스 버드를 확장하고 같은 Duck 인터페이스 함수 fly()를 구현합니다.모든 종류와 인터페이스의 특정한 방법을 호출하려면, 반드시 뾰족한 괄호에서 슈퍼 형식의 이름을 슈퍼라고 언급해야 한다.fly () 및 super.fly().(실제 개발에서는 이 문제를 최대한 피해야 한다)
open class Bird {
open var color = " "
open fun fly() {
println("Bird is flying...")
}
}
interface Duck {
fun fly() {
println("Duck is flying...")
}
}
class Parrot: Bird(),Duck {
override var color = " "
override fun fly() {
super.fly()
super.fly()
println("Parrot is flying...")
}
}
fun main(args: Array) {
val p = Parrot()
p.fly()
println(p.color)
}
Kotlin 추상 클래스 1.0 abstract 키워드를 사용하여 설명하는 클래스를 추상 클래스라고 합니다.추상류를 실례화할 수 없다.추상류의 대상을 만들 수 없다는 뜻이다.abstract 관건 성명 클래스를 현식으로 사용해야만 추상 클래스의 방법과 속성을 나타낼 수 있으며, 그렇지 않으면 추상적이지 않다.2.0 추상류는 부분적으로 정의된 류, 방법과 속성으로 실현되지 않지만 파생류에서 실현되어야 한다.만약 파생류가 기류의 속성이나 방법을 실현하지 못한다면 그것도 추상류이다.3.0 추상 클래스나 추상 함수는 기본적으로 개방되어 있기 때문에 오픈 키워드를 사용하여 주석을 달 필요가 없다.추상 구성원 함수는 실현 주체를 포함하지 않는다.구성원 함수가 추상 클래스에 함수의 실현을 포함한다면 abstract로 설명할 수 없습니다.
abstract class Car{
abstract fun run()
}
class Honda: Car(){
override fun run(){
println("Honda is running safely..")
}
}
fun main(args: Array){
val obj = Honda()
obj.run();
}
4.0 비추상적인 오픈 구성원 함수는 추상적인 클래스에서 다시 불러올 수 있습니다.
open class Car {
open fun run() {
println("Car is running..")
}
}
abstract class Honda : Car() {
override abstract fun run()
}
class City: Honda(){
override fun run() {
// TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
println("Honda City is running..")
}
}
fun main(args: Array){
val car = Car()
car.run()
val city = City()
city.run()
}
Kotlin 인터페이스 인터페이스는 클래스의 청사진입니다.Kotlin 인터페이스는 자바 8의 인터페이스와 유사합니다. 추상적인 방법 설명과 방법의 실현 인터페이스를 포함합니다.interface 키워드로 정의된 기본적인 상황에서 방법체 (방법은 실현되지 않은 것만 설명) 가 없는 상황에서만 설명하는 방법은 추상적인 부모 클래스나 인터페이스에서 확장된 것입니다. 하위 클래스에서 (:) 연산자를 사용하여 완성된 것입니다. (이 점은 계승과 같고 인터페이스에 구조 함수가 없는 것과 다릅니다.)
interface MyInterface {
val id: Int // abstract property
fun absMethod()// abstract method
fun doSomthing() {
// optional body
}
}
인터페이스 사용의 장점 1.0 인터페이스 사용은 다중 계승 기능을 지원한다.2.0 이것은 느슨한 결합을 실현할 수 있다.3.0 이것은 추상을 실현하는 데 쓰인다.4.0 하나의 클래스는 하나의 슈퍼클래스만 확장할 수 있지만 여러 인터페이스를 실현할 수 있다.
interface MyInterface1 {
fun doSomthing()
}
interface MyInterface2 {
fun absMethod()
}
class MyClass : MyInterface1, MyInterface2 {
override fun doSomthing() {
println("overriding doSomthing() of MyInterface1")
}
override fun absMethod() {
println("overriding absMethod() of MyInterface2")
}
}
fun main(args: Array) {
val myClass = MyClass()
myClass.doSomthing()
myClass.absMethod()
}
Kotlin Data 클래스 선언 데이터 클래스에는 속성 매개변수(val 또는 var)가 있는 기본 구조 함수가 하나 이상 있어야 합니다.데이터 클래스는 추상적이고 내부적이며 개방적이거나 밀봉적일 수 없다.데이터 코스메틱 클래스를 사용하여 equals (): Boolean hashCode (): Int toString (): String component () 함수에 대응하는 속성copy () 를 다시 썼습니다.
：
data class User(var name: String, var id: Int, var email: String)
fun main(agrs: Array) {
val u = User("Maxsu", 10010, "[email protected]")
println(u)
}
Kotlin Sealed 클래스는 폐쇄 클래스에 대해 이 밀봉(Sealed) 클래스는 제한 클래스 차원 구조의 클래스입니다.클래스 이름 앞에서 sealed 키워드를 사용하여 클래스를 밀봉 클래스로 표시할 수 있습니다.그것은 제한을 받는 클래스 차원 구조를 나타내는 데 쓰인다.대상이 유한 집합의 유형 중 하나를 가지고 있지만 다른 유형이 있을 수 없을 때 밀봉류를 사용한다.밀봉류의 구조 함수는 기본적으로 사유이며, 비사유로 성명할 수도 없다.밀봉류와 when의 사용 밀봉류는 일반적으로 표현할 때와 함께 사용된다.밀봉류의 자류는 자신의 유형을 하나의 상황으로 하기 때문이다.따라서 밀봉류 중의 when 표현식은 모든 상황을 포괄하기 때문에else 자구를 사용하지 않는다.(열거와 유사)
sealed class Shape{
class Circle(var radius: Float): Shape()
class Square(var length: Int): Shape()
class Rectangle(var length: Int, var breadth: Int): Shape()
// object NotAShape : Shape()
}
fun eval(e: Shape) =
when (e) {
is Shape.Circle ->println("Circle area is ${3.14*e.radius*e.radius}")
is Shape.Square ->println("Square area is ${e.length*e.length}")
is Shape.Rectangle ->println("Rectagle area is ${e.length*e.breadth}")
//else -> "else case is not require as all case is covered above"
// Shape.NotAShape ->Double.NaN
}
fun main(args: Array) {
var circle = Shape.Circle(5.0f)
var square = Shape.Square(5)
var rectangle = Shape.Rectangle(4,5)
eval(circle)
eval(square)
eval(rectangle)
}
Kotlin에서 Java 코드를 호출하려면 Kotlin 파일에서 다른 패키지에 존재하는 Java 코드를 호출하려면 Kotlin 파일에서 Java 클래스를 사용하여 패키지 이름을 가져와야 합니다
//
fun main(args: Array) {
val sum= MyJavaClass.add(5, 10)
println("printing sum inside Kotlin file: "+sum)
}
public class MyJavaClass {
public static void main(String[] args){
}
public static void add(int a,int b){
int result = a + b;
System.out.println("printing inside Java class :"+result);
}
}
//
fun main(args: Array) {
val area: Int = MyJavaClass.area(3, 4)
println("printing area from java insideKotlin file: "+area)
}
public class MyJavaClass {
public static void main(String[] args){
}
public static int area(int a, int b){
int result = a * b;
return result;
}
}
Java에서 Kotlin 코드 호출
//kotlin
fun main(args: Array){
//code
}
fun area(a: Int, b: Int):Int{
return a*b
}
//java
public class MyJava {
public static void main(String[] args) {
int area = MyKotlinKt.area(4,5);
System.out.print("printing area inside Java class returning from Kotlin file: "+area);
}
}
Java Kotlin ， Java Kotlin ，
Java Kotlin 。 ：packageName.KotlinFileKt.methodName()
메모**@JvmName**를 사용하여 Kotlin 파일 이름을 변경하여 Kotlin 코드를 작성하고 맨 위에 메모 @file:JvmName("MyKotlinFileName")을 배치합니다.Kotlin 코드를 컴파일하면 파일 이름이 메모에 제공된 이름으로 변경됩니다(예: MyKotlinFileName).MyKotlin을 방문하는 중입니다.kt 코드를 사용할 때 파일 이름: MyKotlinFileName 을 사용해야 합니다.
//kotlin
@file: JvmName("MyKotlinFileName")
package mykotlinpackage
fun main(args: Array) {
}
fun area(l: Int,b: Int):Int{
return l*b
}
//java
package myjavapackage;
import mykotlinpackage.MyKotlinFileName;
public class MyJavaClass {
public static void main(String[] args){
int area = MyKotlinFileName.area(4,5);
System.out.println("printing area inside Java class returning from Kotlin file: "+area);
}
}
**@JvmMultifileClass**를 사용하여 동일한 Java 클래스 이름을 가진 여러 파일 메서드를 호출합니다. Kotlin의 여러 파일이 @JvmName 메모를 사용하여 동일한 Java 파일 이름을 생성하면 일반적으로 Java 파일에서 호출할 때 오류가 발생합니다.그러나 Kotlin 컴파일러는 생성된 Java 파일과 같은 이름의 파일에 대한 모든 설명을 포함하는 단일 Java façade 클래스를 생성합니다.façade 클래스를 활성화하기 위해서, 모든 파일에 @JvmMultifileClass 주석을 사용합니다.
：MyKotlin1.kt
@file: JvmName("MyKotlinFileName")
@file:JvmMultifileClass
package mykotlinpackage
fun main(args: Array) {
}
fun area(l: Int,b: Int):Int{
return l*b
}
：MyKotlin2.kt
@file: JvmName("MyKotlinFileName")
@file:JvmMultifileClass
package mykotlinpackage
fun volume(l: Int,b: Int,h: Int):Int{
return l*b*h
}
：MyJava.java
package myjavapackage;
import mykotlinpackage.MyKotlinFileName;
public class MyJavaClass {
public static void main(String[] args){
int area = MyKotlinFileName.area(4,5);
System.out.println("printing area inside Java class returning from Kotlin file: "+area);
int vol = MyKotlinFileName.volume(4,5,6);
System.out.println("printing volume inside Java class returning from Kotlin file: "+vol);
}
}
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
머티리얼 디자인 도입 직후에 할 일안드로이드 프로젝트에 머티리얼 디자인을 도입한 후에 할 일을 적는다. Android 프로젝트를 만든 후 Hello world에 대해 수행합니다. 머티리얼 디자인을 도입하기 위해, build.gradle 를 이하와 같...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.
좋은 웹페이지 즐겨찾기
