class 이름{ }
클래스를 선언할 때 위와 같은 방식으로 선언한다.
- 클래스에 넣어줄 값으로는 다음과 같다
// name(팀이름) - 변수
// members(맴버들) - 변수
// sayHello(인사) - 함수
// introduce(멤버소개) - 함수
void main() {
}
// Team class
// name(팀이름) - 변수
// members(맴버들) - 변수
// sayHello(인사) - 함수
// introduce(멤버소개) - 함수
class Team{
String name = '리버풀';
List<String> members = ['알리송', '반다이크', '핸더슨', '살라'];
void sayHello(){
print('안녕하세요 리버풀입니다.');
}
void introduce(){
print('저희 맴버는 알리송, 반다이크, 핸더슨, 살라 입니다.');
}
}
void main() {
Team이라는 클래스를 사용해서 변수를 만들 때 Team이라는 타입을 지정해주고 변수이름을 작성하면 된다.
Team liverpool = Team();
//Team liverpool = new Team(); new를 넣어도 되고 안넣어도 된다.
print(liverpool.name);
print(liverpool.members);
liverpool.sayHello();
liverpool.introduce();
}
// Team class
// name(팀이름) - 변수
// members(맴버들) - 변수
// sayHello(인사) - 함수
// introduce(멤버소개) - 함수
class Team{
String name = '리버풀';
List<String> members = ['알리송', '반다이크', '핸더슨', '살라'];
void sayHello(){
print('안녕하세요 리버풀입니다.');
}
void introduce(){
print('저희 맴버는 알리송, 반다이크, 핸더슨, 살라 입니다.');
}
}
=>
리버풀
[알리송, 반다이크, 핸더슨, 살라]
안녕하세요 리버풀입니다.
저희 맴버는 알리송, 반다이크, 핸더슨, 살라 입니다.
constructor
생성자를 사용한다.void main() {
// 6. 생성자를 만드는 순간 파라미터 값에 에러가 발생한다.
// positional parameter를 사용했기 때문에 파라미터 값을 넣어줘야 한다.
Team liverpool = Team(
'리버풀',
['알리송', '반다이크', '핸더슨', '살라']
);
print(liverpool.name);
print(liverpool.members);
liverpool.sayHello();
liverpool.introduce();
Team manutd = Team(
'맨유',
['데헤아', '바란', '에릭센', '호날두']
);
print(manutd.name);
print(manutd.members);
manutd.sayHello();
manutd.introduce();
}
// Team class
// name(팀이름) - 변수
// members(맴버들) - 변수
// sayHello(인사) - 함수
// introduce(멤버소개) - 함수
// constructor (생성자)
class Team{
// 7. 외부에서 값을 받기로 했기 때문에 값을 지워줘도 상관없다.
String name;
List<String> members;
// 1. 생성자는 class안에 작성한다.
// 2. 생성자는 클래스이름(); 형식으로 작성한다. Team()
// 3. Team(); 파라미터로 바꾸고 싶은 값을 넣어준다. name, members
// 4. positional parameter 와 named parameter를 사용한다.
// 5. 파라미터를 받으면 클래스에 저장을 해야한다. 이때 this를 사용한다.
Team(String name, List<String> members)
: this.name = name, // this.name은 클래스를 뜻하고 name은 파라미터를 뜻한다.
this.members = members;
void sayHello(){
print('안녕하세요 리버풀입니다.');
}
void introduce(){
print('저희 맴버는 알리송, 반다이크, 핸더슨, 살라 입니다.');
}
}
팀이름과 맴버
들은 바뀌었지만 인사, 맴버소개
는 바뀌지 않았다.String
값을 넣어주었기 때문에 바뀌지 않는 것이다.this
를 활용하면 된다.void main() {
Team liverpool = Team('리버풀', ['알리송', '반다이크', '핸더슨', '살라']);
print(liverpool.name);
print(liverpool.members);
liverpool.sayHello();
liverpool.introduce();
Team manutd = Team('맨유', ['데헤아', '바란', '에릭센', '호날두']);
print(manutd.name);
print(manutd.members);
manutd.sayHello();
manutd.introduce();
}
// Team class
// name(팀이름) - 변수
// members(맴버들) - 변수
// sayHello(인사) - 함수
// introduce(멤버소개) - 함수
// constructor (생성자)
class Team {
String name;
List<String> members;
Team(String name, List<String> members)
: this.name = name,
this.members = members;
void sayHello() {
print('안녕하세요 ${this.name}입니다.');
}
void introduce() {
print('저희 맴버는 ${this.members} 입니다.');
}
}
void main() {
Team liverpool = Team('리버풀', ['알리송', '반다이크', '핸더슨', '살라']);
print(liverpool.name);
print(liverpool.members);
liverpool.sayHello();
liverpool.introduce();
Team manutd = Team('맨유', ['데헤아', '바란', '에릭센', '호날두']);
print(manutd.name);
print(manutd.members);
manutd.sayHello();
manutd.introduce();
}
class Team {
String name;
List<String> members;
Team(this.name, this.members);
// 클래스의 name과 members를 바로 받아온다.
void sayHello() {
print('안녕하세요 ${this.name}입니다.');
}
void introduce() {
print('저희 맴버는 ${this.members} 입니다.');
}
}
void main() {
Team liverpool = Team('리버풀', ['알리송', '반다이크', '핸더슨', '살라']);
print(liverpool.name);
print(liverpool.members);
liverpool.sayHello();
liverpool.introduce();
Team manutd = Team.fromList([
['데헤아', '바란', '에릭센', '호날두'],
'맨유'
]);
print(manutd.name);
print(manutd.members);
manutd.sayHello();
manutd.introduce();
}
// Team class
// name(팀이름) - 변수
// members(맴버들) - 변수
// sayHello(인사) - 함수
// introduce(멤버소개) - 함수
// constructor (생성자)
class Team {
String name;
List<String> members;
Team(this.name, this.members);
Team.fromList(List values)
: this.members = values[0],
this.name = values[1];
void sayHello() {
print('안녕하세요 ${this.name}입니다.');
}
void introduce() {
print('저희 맴버는 ${this.members} 입니다.');
}
}
final
를 사용하는 습관을 가져야한다.void main() {
Team liverpool = Team('리버풀', ['알리송', '반다이크', '핸더슨', '살라']);
print(liverpool.name);
print(liverpool.members);
liverpool.sayHello();
liverpool.introduce();
Team manutd = Team.fromList([
['데헤아', '바란', '에릭센', '호날두'],
'맨유'
]);
print(manutd.name);
print(manutd.members);
manutd.sayHello();
manutd.introduce();
}
// Team class
// name(팀이름) - 변수
// members(맴버들) - 변수
// sayHello(인사) - 함수
// introduce(멤버소개) - 함수
// constructor (생성자)
// immutable
class Team {
final String name;
final List<String> members;
const Team(this.name, this.members);
Team.fromList(List values)
: this.members = values[0],
this.name = values[1];
void sayHello() {
print('안녕하세요 ${this.name}입니다.');
}
void introduce() {
print('저희 맴버는 ${this.members} 입니다.');
}
}
void main() {
Team liverpool = Team('리버풀', ['알리송', '반다이크', '핸더슨', '살라']);
Team manutd = Team.fromList([
['데헤아', '바란', '에릭센', '호날두'],
'맨유'
]);
print(liverpool.firstMember);
print(manutd.firstMember);
liverpool.firstMember = '고메즈';
manutd.firstMember = '프레드';
print(liverpool.firstMember);
print(manutd.firstMember);
}
// getter / setter
// 데이터를 가져올때 / 데이터를 설정할때
// 데이터를 간단하게 가공할 때 사용한다.
class Team {
String name;
List<String> members;
Team(this.name, this.members);
Team.fromList(List values)
: this.members = values[0],
this.name = values[1];
void sayHello() {
print('안녕하세요 ${this.name}입니다.');
}
void introduce() {
print('저희 맴버는 ${this.members} 입니다.');
}
// getter
String get firstMember {
return this.members[0];
}
// setter 무조건 한개 파라미터
set firstMember(String name) {
this.members[0] = name;
}
}
void main() {
print('---------Team---------');
Team liverpool = Team(name: '리버풀', membersCount: 11);
liverpool.sayName();
liverpool.sayMembersCount();
England manutd = England('맨유', 11);
manutd.sayMembersCount();
manutd.sayName();
}
// 상속 - inheritance
//
// 상속을 받으면 부모 클래스의 모든 속성을
// 자식 클래스가 부여 받는다.
class Team {
// 이름
String name;
// 멤버숫자
int membersCount;
Team({
required this.name,
required this.membersCount,
});
void sayName() {
print('우리는 ${this.name} 입니다');
}
void sayMembersCount() {
print('${this.name}은 ${this.membersCount}명의 멥버가 있습니다.');
}
}
class England extends Team {
England(
String name,
int membersCount,
) : super(name: name, membersCount: membersCount);
}
void main() {
TimesTwo tt = TimesTwo(2);
print(tt.calculate());
TimesFour tf = TimesFour(2);
print(tf.calculate());
}
// method - function (class 내부에 있는 함수)
// override - 덮어쓰다. (우선시하다)
class TimesTwo {
final int number;
TimesTwo(
this.number,
);
// method
int calculate() {
return this.number * 2; // 클래스에 number 하나만 존재할 경우 this 생략가능.
}
}
class TimesFour extends TimesTwo{
TimesFour(
int number,
): super(number);
// @override
// int calculate(){
// return super.number * 4;
// }
int calculate(){
return super.calculate() * 2; // 부모 클래스에서 calculate()를 불러와서 사용할 수도 있다.
}
}
static
은 인스턴스
에 귀속되지 않고 클래스
에 귀속된다.void main(){
Empoloyee tom = Empoloyee('톰');
Empoloyee james = Empoloyee('제임스');
tom.name = '마이크';
tom.printNameAndBuilding();
james.printNameAndBuilding();
// 인스턴스에 귀속된다는 것은 인스턴스를 만든 후에 실행하거나 값을 변경할 수 있다는 것을 의미한다.
Empoloyee.building = 'A타워';
tom.printNameAndBuilding();
james.printNameAndBuilding();
// 클래스에 귀속된다는 것은 클래스 이름에 바로 접근할 수 있다는 것이다.
// static은 클래스 이름에 바로 접근 할 수 있다.
Empoloyee.printBuilding();
}
class Empoloyee{
// static은 인스턴스에 귀속되지 않고 클래스에 귀속된다.
// 알바생이 일하고 있는 건물
static String? building;
// 알바생 이름
String name;
Empoloyee(
this.name,
);
void printNameAndBuilding(){
print('제 이름은 $name 입니다. $building 건물에서 근무하고 있습니다.');
}
static void printBuilding(){
print('저희는 $building 건물에서 근무중입니다.');
}
}
void main(){
}
// interface
class IdolInterface{
String name;
IdolInterface(this.name);
void sayName(){}
}
class BoyGroup implements IdolInterface{
}
void main(){
}
// interface
class IdolInterface{
String name;
IdolInterface(this.name);
void sayName(){}
}
class BoyGroup implements IdolInterface{
String name;
BoyGroup(this.name);
void sayName(){}
}
void main(){
BoyGroup bts = BoyGroup('BTS');
GirlGroup redVelvet = GirlGroup('레드벨벳');
bts.sayName();
redVelvet.sayName();
}
// abstract 사용
// 추상화를 하여 사용을 하지 못하게한다.
// 함수 body 부분을 지워줘도 된다.
abstract class IdolInterface{
String name;
IdolInterface(this.name);
void sayName()
}
class BoyGroup implements IdolInterface{
String name;
BoyGroup(this.name);
void sayName(){
print('제 이름은 $name 입니다.');
}
}
class GirlGroup implements IdolInterface{
String name;
GirlGroup(this.name);
void sayName(){
print('제 이름은 $name 입니다.');
}
}
void main() {
Lecture<String> lecture1 = Lecture('123', 'lecture');
lecture1.printIdType();
Lecture<int> lecture2 = Lecture(123, 'lecture');
lecture2.printIdType();
}
// generic - 타입을 외부에서 받을 떄 사용
class Lecture<T> {
final T id;
final String name;
Lecture(this.id, this.name);
void printIdType() {
print(id.runtimeType);
}
}
=>
String
int
Test
라는 클래스를 만들고 인스턴스를 작성했다test.
을 하면 이미 4개의 속성들이 존재하고 있다.class Test extends Object
extends Object
는 모든 클래스들이 상속 받기 때문에 생략이 가능하다.