【有哪些特点】
1.封装 2.继承3.重写4.抽象
一.面向对象的特点
TS中属性具有三种修饰符**:
- public(默认值),可以在类、子类和对象中修改
- protected ,可以在类、子类中修改
- private ,可以在类中修改
不使用任何修饰符,建立模型
//面向对象----将生活中具体事物通过程序代码镜像抽象化---通过class创建类-----属性(事物的特征)与方法(事物的功能)
//1.创建类----抽象化的对象
class Student{
//实例属性
name:string;
age:number;
//创建构造函数---需要构建这个函数才能进行多个值书写
constructor(name: string, age: number){
this.name = name;
this.age = age;
}
//实例方法
playGame(gameName:string){
console.log(`${this.name}喜欢玩${gameName}`);
}
}
//2.使用类
//实例化对象
let s1=new Student("张三",22);
//使用类中方法
s1.playGame("王者荣耀")
//获取数据
console.log(s1.age);
//修改数据
s1.name="小红"
结果:
1.封装
(1).public(默认值),可以在类、子类和对象中修改---不需要get与set(读取属性的方法叫做setter方法,设置属性的方法叫做getter方法 )
例题1.public修饰名字,和方法(方法一样,可去举一反三,根据所需求)
//面向对象----将生活中具体事物通过程序代码镜像抽象化---通过class创建类-----属性(事物的特征)与方法(事物的功能)
//1.创建类----抽象化的对象
class Student {
//实例属性
public name: string;
age: number;
//创建构造函数---需要构建这个函数才能进行多个值书写
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
//实例方法
public playGame(gameName: string) {
console.log(`${this.name}喜欢玩${gameName}`);
}
}
//2.使用类
//实例化对象
let s1 = new Student("张三", 22);
//使用类中方法
s1.playGame("王者荣耀")
//获取数据
console.log(s1.name);
//修改数据
s1.name = "1111"
console.log(s1);
结果:
结论: 用public修饰符可以在可以在类、子类和对象中修改属性值。不会报错,是公开修饰符。
(2)protected ,可以在类、子类中修改---需要用到get与set
例题2:(会有报错)
修改:
//面向对象----将生活中具体事物通过程序代码镜像抽象化---通过class创建类-----属性(事物的特征)与方法(事物的功能)
//1.创建类----抽象化的对象
class Student {
//实例属性
protected name: string;
age: number;
//创建构造函数---需要构建这个函数才能进行多个值书写
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
//实例方法
protected playGame(gameName: string) {
console.log(`${this.name}喜欢玩${gameName}`);
}
get name1() {
return this.name;
}
set name1(name: string) {
this.name = name
}
fn() {
this.playGame("")
}
}
//2.使用类
//实例化对象
let s1 = new Student("张三", 22);
//使用类中方法
// s1.playGame("王者荣耀") //不能这样调用--会报错
//获取数据
console.log(s1.name1);
//修改数据
s1.name1 = "1111"
console.log(s1);
//调用方法
s1.fn()//---调用方法 需要用函数来调用
结果:
结论: 用protected修饰符可以在类、子类中修改,但如果要在对象内修改,需要用到get与set方法。
(2)private ,可以在类中修改
例题3:(会有报错)
修改:
//面向对象----将生活中具体事物通过程序代码镜像抽象化---通过class创建类-----属性(事物的特征)与方法(事物的功能)
//1.创建类----抽象化的对象
class Student {
//实例属性
private name: string;
age: number;
//创建构造函数---需要构建这个函数才能进行多个值书写
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
//实例方法
private playGame(gameName: string) {
console.log(`${this.name}喜欢玩${gameName}`);
}
get name1() {
return this.name;
}
set name1(name: string) {
this.name = name
}
fn() {
this.playGame("gameName: string")
}
}
//2.使用类
//实例化对象
let s1 = new Student("张三", 22);
//使用类中方法
// s1.playGame("王者荣耀") //不能这样调用--会报错
//获取数据
console.log(s1.name1);
//修改数据
s1.name1 = "1111"
console.log(s1);
//调用方法
s1.fn()//---调用方法 需要用函数来调用
结果:
补充: static,可以在类中修改,静态修饰符。
例题:
//面向对象----将生活中具体事物通过程序代码镜像抽象化---通过class创建类-----属性(事物的特征)与方法(事物的功能)
//1.创建类----抽象化的对象
class Student {
//实例属性
name: string;
age: number;
static sex: string = "25岁" //静态设置常量
//创建构造函数---需要构建这个函数才能进行多个值书写
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
//实例方法
playGame(gameName: string) {
console.log(`${this.name}喜欢玩${gameName}`);
}
}
//2.使用类
//实例化对象
let s1 = new Student("张三", 22);
//获取常量
console.log(Student.sex);
结果:
2.继承
通过继承可以将其他类中的属性和方法引入到当前类中(将父中的属性由子中继承)
//继承
class Fu{
//属性
name:string;
age:number;
//构造函数
constructor(u_name:string,u_age:number){
this.name=u_name,
this.age=u_age
}
//方法
fuFn(){
console.log("父类方法");
}
}
//子类
class Son extends Fu{
sonFn(){
this.name="小明"
// this.age=22----私有只能在类中修改使用
}
}
//实例化子类
let son = new Son("张三",20);
console.log(son);
// console.log(son.name,son.age);
son.fuFn()
son.sonFn()//调用方法
console.log(son);
结果:
3.重写
发生继承时,如果子类中的方法会替换掉父类中的同名方法,这就称为方法的重写
实例:
//重写
class Fu{
//属性
name:string;
age:number;
//构造函数
constructor(u_name:string,u_age:number){
this.name=u_name,
this.age=u_age
}
//方法
fuFn(){
console.log("父类方法");
}
}
//子类
class Son extends Fu{
//重写----父类方法名与子类的方法名称一致
fuFn(){
console.log("子类方法");
}
}
//实例化子类
let son = new Son("张三",20);
son.fuFn()
结果:
4. 抽象类
抽象类是专门用来被其他类所继承的类,它只能被其他类所继承不能用来创建实例
实例:
//抽象化----用于子类继承 不能实例化
abstract class Fu {
//属性
name: string;
age: number;
//构造函数
constructor(u_name: string, u_age: number) {
this.name = u_name,
this.age = u_age
}
//方法
abstract fn(): void//必须在子类中进行重写
}
//子类
class Son extends Fu {
fn(): void {
console.log("子类方法1");
}
}
//实例化子类
let son = new Son("张三", 20);
son.fn()
结果:
二.接口
实例:1.制造一个汽车接口
2.在创建一个关于接口的类
class Bom implements Car{
brand:string;
color:string
seat:number
price:number
consumption:string
constructor( brand:string,color:string,seat:number,price:number,consumption:string){
this.brand=brand,
this.color=color,
this.price=price,
this.seat=seat,
this.consumption=consumption
}
//重写
run() {
}
listen() {
}
playGame(){
}
}
let bom=new Bom("宝马x5","blue",4,800000,"2.0T")
console.log(bom);
注意:在类中可以添加接口没有的属性与方法,但接口中有的属性与方法,类中必须继承
三.泛型
当函数的参数,返回值类型不确定的情况,可以泛型
1.单个使用
function fn<T>(a:T):T{
return a
}
(1)在不知道类型的情况下使用
(2)指定类型
2.多个使用
返回值指定那个,就确定哪个类型的值
(1) 在不知道类型的情况下使用
(2)指定类型