HOW2J.CN - 学习笔记(类和对象)
引用
引用的概念,如果一个变量的类型是 类类型,而非基本类型,那么该变量又叫做引用。
1. 引用和指向
new Hero();
代表 创建 了一个Hero对象
但是也仅仅是创建了一个对象,没有办法访问它
为了访问这个对象,会使用 引用 来 代表 这个对象
Hero h = new Hero();
h这个遍历是Hero类型,又叫做引用
=的意思指的h这个引用 代表 右侧创建的对象
“代表” 在面向对象里,又叫做“指向”
public class Hero { String name; // 姓名 float hp; // 血量 float armor; // 护甲 int moveSpeed; // 移动速度 public static void main(String[] args) {// 创建一个对象new Hero(); // 使用一个引用来指向这个对象Hero h = new Hero(); }
}
2. 多个引用,一个对象
引用有多个,但是对象只有一个。
在这个例子里,所有引用都指向了同一个对象。
对象就像房产,引用就像房产证
房产证的复印件可以有多张,但是真正的房产只有这么一处
public class Hero { String name; // 姓名 float hp; // 血量 float armor; // 护甲 int moveSpeed; // 移动速度 public static void main(String[] args) { // 使用一个引用来指向这个对象Hero h1 = new Hero();Hero h2 = h1; // h2指向h1所指向的对象Hero h3 = h1;Hero h4 = h1;Hero h5 = h4; // h1,h2,h3,h4,h5 五个引用,都指向同一个对象 }
}
3. 一个引用,多个对象
Hero garden = new Hero(); 引用garen指向新创建的对象(对象1)
garen = new Hero(); 同一个引用garen指向新创建的对象(对象2)
这个时候,对象1,就没有任何引用指向了
换句话说,就没有任何手段控制和访问该对象,那么该对象就变得没有意义。
public class Hero {public String name;protected float hp;public static void main(String[] args) {Hero garen = new Hero();garen = new Hero();}
}
4. 练习 - 引用
如代码问题:
h4所指向的对象和h2所指向的对象,是否是同一个对象?
public class Hero {public String name;protected float hp;public static void main(String[] args) {Hero h1 = new Hero();Hero h2 = new Hero();Hero h3;Hero h4;h3 = h1;h4 = h3;}
}
h4 指向 h3,最终间接地指向了对象1
而h2指向的是对象2,所以h4和h2不是指向同一个对象
继承
在LOL中,武器是物品的一种,也是有名称和价格的
所以在设计类的时候,可以让武器继承物品,从而继承名称和价格属性
1. 物品类 Item
物品类Item,有属性name、price
public class Item {String name;int price;
}
2. 武器类 Weapon(不继承)
武器类:Weapon 不继承Item 的写法
独立设计 name和price属性
同时多了一个属性 damage 攻击力
public class Weapon {String name;int price;int damage; // 攻击力
}
3. 武器类 Weapon(继承类Item)
这一次Weapon 继承Item
虽然Weapon自己没有设计name和price,但是通过继承Item类,也具备了name和price属性
public class Weapon extends Item {int damage; // 攻击力public static void main(String[] args) {Weapon infinityEdge = new Weapon();infinityEdge.damage = 65; // damage属性在类Weapon中新设计的infinityEdge.name = "无尽之刃"; // name属性,是从Item中继承来的,就不需要重复设计了infinityEdge.price = 3600;}
}
4. 练习 - 护甲
设计一个类Armor护甲
继承Item类,并且额外提供一个int类型属性ac: 护甲等级
实例化出两件护甲
名称 价格 护甲等级
布甲 300 15
锁子甲 500 40
public class Armor extends Item {int ac;public static void main(String[] args) {Armor cloth = new Armor();Armor chain = new Armor();cloth.name = "护甲";cloth.price = 300;cloth.ac = 15;chain.name = "锁子甲";chain.price = 500;chain.ac = 40;}
}
方法重载
方法的重载指的是方法名一样,但是参数类型不一样
1. attack方法的重载
public void attack()
public void attack(Hero h1)
public void attack(Hero h1, Hero h2)
方法名是一样的,但是参数类型不一样
在调用方法attack的时候,会根据传递的参数类型以及数量,自动调用对应的方法
public class Hero {String name; // 姓名float hp; // 血量public void attack() {System.out.println(name + " 进行了一次攻击 ,但是不确定打中谁了");}public void attack(Hero h) {System.out.println(name + " 攻击了 " + h.name);}public void attack(Hero h1, Hero h2) {System.out.println(name + " 同时攻击了 " + h1.name + " 和 " + h2.name);}public static void main(String[] args) {Hero gareen = new Hero();gareen.name = "盖伦";Hero teemo = new Hero();teemo.name = "提莫";Hero db = new Hero();db.name = "死歌";gareen.attack();gareen.attack(teemo);gareen.attack(teemo, db);}
}
盖伦 进行了一次攻击 ,但是不确定打中谁了
盖伦 攻击了 提莫
盖伦 同时攻击了 提莫 和 死歌
2. 可变数量的参数
如果要攻击更多的英雄,就需要设计更多的方法,这样类会显得很累赘,像这样:
public void attack(Hero h1)
public void attack(Hero h1,Hero h2)
public void attack(Hero h1,Hero h2,Hero h3)
这时,可以采用可变数量的参数
只需要设计一个方法
public void attack(Hero … heros)
即可代表上述所有的方法了
在方法里,使用操作数组的方式处理参数heros即可
public class Hero {String name; // 姓名float hp; // 血量public void attack(Hero h) {System.out.println(name + " 攻击了 " + h.name);}public void attack(Hero... heros) {for (Hero hero : heros) {System.out.println(name + " 同时攻击了 " + hero.name);}}public static void main(String[] args) {Hero gareen = new Hero();gareen.name = "盖伦";Hero teemo = new Hero();teemo.name = "提莫";Hero db = new Hero();db.name = "死歌";Hero annie = new Hero();annie.name = "安妮";gareen.attack(teemo);gareen.attack(teemo, db, annie);}
}
盖伦 攻击了 提莫
盖伦 同时攻击了 提莫
盖伦 同时攻击了 死歌
盖伦 同时攻击了 安妮
3. 练习 - 治疗
设计一个类Support (辅助英雄)继承Hero,提供一个heal(治疗)方法
对Support的heal方法进行重载
heal()
heal(Hero h) //为指定的英雄加血
heal(Hero h, int hp) //为指定的英雄加了hp的血
public class Support extends Hero {void heal() {System.out.println(name + " 对自己进行治疗");}void heal(Hero h) {System.out.println(name + " 给英雄 " + h.name + " 加血");}void heal(Hero... heros) {int hp = 100;for (Hero hero : heros) {System.out.println(name + " 给英雄 " + hero.name + " 加了 " + hp + " 点血");}}void heal(Hero h, int hp) {System.out.println(name + " 给英雄 " + h.name + " 加了 " + hp + " 血");}public static void main(String[] args) {Support sp = new Support();sp.name = "索拉卡";Hero h1 = new Hero();h1.name = "EZ";Hero h2 = new Hero();h2.name = "虚空行者";Hero h3 = new Hero();h3.name = "潮汐精灵";sp.heal();sp.heal(h1);sp.heal(h1, 600);sp.heal(h2, h3);}
}
索拉卡 对自己进行治疗
索拉卡 给英雄 EZ 加血
索拉卡 给英雄 EZ 加了 600 血
索拉卡 给英雄 虚空行者 加了 100 点血
索拉卡 给英雄 潮汐精灵 加了 100 点血
构造方法
通过一个类创建一个对象,这个过程叫做 实例化
实例化是通过调用 构造方法(又叫做 构造器)实现的
1. 什么是构造方法
方法名和类名一样(包括大小写)
没有返回类型
实例化一个对象的时候,必然调用构造方法
public class Hero {public void attack(Hero hero) {}public void heal() {}public Hero() {System.out.println("Hero 类的构造方法");}public static void main(String[] args) {Hero h1 = new Hero();Hero h2 = new Hero();h1.attack(h2);h1.heal();}
}
Hero 类的构造方法
Hero 类的构造方法
2. 隐式的构造方法
Hero类的构造方法是
public Hero() {}
这个无参的构造方法,如果不写,就会默认提供一个
public class Hero {// public Hero() {// System.out.println("调用Hero的构造方法");// }public static void main(String[] args) {Hero h1 = new Hero();Hero h2 = new Hero();}
}
3. 如果提供了一个有参的构造方法
一旦提供了一个有参的构造方法
同时又 没有显式 的提供一个无参的构造方法
那么默认的无参的构造方法,就 “木有了”
public class Hero {String name;public Hero(String heroName) {name = heroName;}public static void main(String[] args) {Hero garen = new Hero("盖伦");// Hero teemo = new Hero(); // error}
}
4. 构造方法的重载
和普通方法一样,构造方法也可以重载
public class Hero {String name;float hp;// 带一个参数的构造方法public Hero(String heroName) {name = heroName;}// 带两个参数的构造方法public Hero(String heroName, float heroHp) {name = heroName;hp = heroHp;}public static void main(String[] args) {Hero garen = new Hero("盖伦");Hero teemo = new Hero("提莫", 383);}
}
5. 练习 - 构造方法
为Hero设计4个参数的构造方法,这四个参数分别是
String heroName
float heroHP
float heroArmor
int heroMoveSpeed
public class Hero {String name;float hp;float armor;int moveSpeed;public Hero() {System.out.println("无参");name = "盖伦";hp = 5000;armor = 500;moveSpeed = 450;}public Hero(String heroName, float heroHp, float heroArmor, int heroMoveSpeed) {System.out.println("有参");name = heroName;hp = heroHp;armor = heroArmor;moveSpeed = heroMoveSpeed;}public void showHero() {System.out.println("姓名:" + name + ",血量:" + hp + ",护甲:" + armor + ",移动速度:" + moveSpeed);}public static void main(String[] args) {Hero garen = new Hero();garen.showHero();Hero teemo = new Hero("提莫", 3000, 100, 500);teemo.showHero();}
}
无参
姓名:盖伦,血量:5000.0,护甲:500.0,移动速度:450
有参
姓名:提莫,血量:3000.0,护甲:100.0,移动速度:500
this
this这个关键字,相当于普通话里的 “我”
小明说 “我吃了” 这个时候,“我” 代表小明
小红说 “我吃了” 这个时候,“我**”** 代表小红
“我” 代表当前人物
this这个关键字,相当于普通话里的 “我”
1. this代表当前对象
public class Hero {String name;float hp;float armor;int moveSpeed;public void showAddressInMemory() {System.out.println("打印this看到的虚拟地址:" + this);}public static void main(String[] args) {Hero h1 = new Hero();System.out.println("打印对象看到的虚拟地址:" + h1);h1.showAddressInMemory();Hero h2 = new Hero();System.out.println("打印对象看到的虚拟地址:" + h2);h2.showAddressInMemory();}
}
打印对象看到的虚拟地址:Hero@1db9742
打印this看到的虚拟地址:Hero@1db9742
打印对象看到的虚拟地址:Hero@106d69c
打印this看到的虚拟地址:Hero@106d69c
2. 通过this访问属性
通过this关键字访问对象的属性
public class Hero {String name; // 名字float hp; // 血量float armor; // 护甲int moveSpeed; // 移动速度// 参数名和属性名一样,在方法体中,只能访问到参数namepublic void setName1(String name) {name = name;}// 为了避免setName1中的问题,参数名不得不使用其他变量名public void setName2(String heroName) {name = heroName;}// 通过this访问属性public void setName3(String name) {// name代表参数name,this.name代表的是属性namethis.name = name;}public static void main(String[] args) {Hero h = new Hero();System.out.println(h.name); // nullh.setName1("teemo");System.out.println(h.name); // nullh.setName2("garen");System.out.println(h.name); // garenh.setName3("死歌");System.out.println(h.name); // 死歌}
}
3. 通过this调用其他的构造方法
如果要在一个构造方法中,调用另一个构造方法,可以使用this()
public class Hero {String name; // 名字float hp; // 血量float armor; // 护甲int moveSpeed; // 移动速度// 带一个参数的构造方法public Hero(String name) {System.out.println("一个参数的构造方法");this.name = name;}// 带两个参数的构造方法public Hero(String name, float hp) {this(name);System.out.println("带两个参数的构造方法");this.hp = hp;}public static void main(String[] args) {Hero teemo = new Hero("提莫", 383);System.out.println(teemo.name);}
}
一个参数的构造方法
带两个参数的构造方法
提莫
4. 练习 - 构造方法(this)
public class Hero {String name; // 名字float hp; // 血量float armor; // 护甲int moveSpeed; // 移动速度public Hero(String name, float hp) {System.out.println("带两个参数的构造方法");this.name = name;this.hp = hp;}public Hero(String name, float hp, float armor, int moveSpeed) {this(name, hp);System.out.println("带四个参数的构造方法");this.name = name;this.hp = hp;this.armor = armor;this.moveSpeed = moveSpeed;}public static void main(String[] args) {Hero h = new Hero("提莫", 383, 100, 133);}
}
带两个参数的构造方法
带四个参数的构造方法
传参
变量有两种类型 基本类型 和 类类型
参数也是变量,所以传参分为 基本类型传参、类类型传参
1. 基本类型传参
基本类型传参
在方法内,无法修改方法外的基本类型参数
public class Hero {String name; // 姓名float hp; // 血量float armor; // 护甲int moveSpeed; // 移动速度public Hero() {}public Hero(String name, float hp) {this.name = name;this.hp = hp;}// 回血public void huixue(int xp) {hp = hp + xp;// 回血完毕后,血瓶=0xp = 0;}public static void main(String[] args) {Hero teemo = new Hero("提莫", 383);// 血瓶,其值是100int xueping = 100;// 提莫通过这个血瓶回血teemo.huixue(xueping);System.out.println(teemo.hp); // 483.0}
}
2. 引用与=
如果一个变量是基本类型
比如 int hp = 50;
我们就直接管hp叫变量
=表示赋值的意思。
如果一个变量是类类型
比如 Hero h = new Hero();
我们就管h叫做 引用。
=不再是赋值的意思
=表示指向的意思
比如 Hero h = new Hero();
这句话的意思是
引用h,指向一个Hero对象
3. 类类型传参
类类型又叫引用
garen.attack(teemo, 100); 的引用 teemo 与public void attack(Hero hero, int damage) 的引用 hero,是不同的引用
通过调用garen.attack(teemo, 100); 使得这 两个引用都指向了同一个对象
所以hero.hp = hero.hp - damage; 就使得该对象的hp值,发生了变化
因此打印该对象的Hp值就是变化后的值
public class Hero {String name; // 姓名float hp; // 血量float armor; // 护甲int moveSpeed; // 移动速度public Hero(String name, float hp) {this.name = name;this.hp = hp;}// 攻击一个英雄,并让他掉damage点血public void attack(Hero hero, int damage) {hero.hp = hero.hp - damage;}public static void main(String[] args) {Hero teemo = new Hero("提莫", 383);Hero garen = new Hero("盖伦", 616);garen.attack(teemo, 100);System.out.println(teemo.hp); // 283.0}}
4. 练习 - 传参
在方法中,使参数引用指向一个新的对象
外面的引用是指向原来的对象?还是新的对象?
public class Hero {String name; // 姓名float hp; // 血量float armor; // 护甲int moveSpeed; // 移动速度public Hero() {}public Hero(String name, float hp) {this.name = name;this.hp = hp;}// 复活public void revive(Hero h) {// h.hp = 383; // 这里没有创建新对象,引用仍是指向原来的对象h = new Hero("提莫", 383); // 这里是创建了一个新的对象}public static void main(String[] args) {Hero teemo = new Hero("提莫", 383);// 受到400伤害,挂了teemo.hp = teemo.hp - 400;teemo.revive(teemo);System.out.println(teemo.hp); // -17.0 不要让他指向新的对象}}
包
包: package
把比较接近的类,规划在同一个包下
1. 把比较接近的类,规划在同一个包下
Hero,ADHero 规划在一个包,叫做charactor(角色)
Item,Weapon规划在另一个包下,叫做 property(道具)
在最开始的地方声明该类所处于的包名
package charactor; // 在最开始的地方声明该类所处于的包名public class Hero {String name; // 姓名float hp; // 血量float armor; // 护甲int moveSpeed; // 移动速度
}
2. 使用其他包下的类,必须import
使用同一个包下的其他类,直接使用即可
但是要使用其他包下的类,必须import
package charactor;
// Weapon类在其他包里,使用必须进行import
import property.Weapon;
public class Hero {String name; // 姓名float hp; // 血量float armor; // 护甲int moveSpeed; // 移动速度// 装备一把武器public void equip(Weapon w) {}
}
3. 练习 - 包
创建一个新的包charactor1,并且让练习-治疗类:Support 声明在这个包下
package charactor1;
import charactor.Hero;
// 治疗
public class Support extends Hero {public Support() {}public void heal(Support a) {System.out.println(a.name + "对自己进行治疗");}public void heal(Support a, Hero b) {System.out.println(a.name + "给英雄" + b.name + "加血");}public void heal(Support a, Hero b, float hp) {System.out.println(a.name + "给英雄" + b.name + "加了" + hp + "点血");}public static void main(String[] args) {Support harpGirl = new Support();harpGirl.name = "琴女";Hero galen = new Hero();galen.name = "盖伦";harpGirl.heal(harpGirl, galen, 300);}
}
访问修饰符
成员变量有四种修饰符
private 私有的
package/friendly/default 不写
protected 受保护的
public 公共的
比如public 表示公共的
public String name;
而maxHP 没有修饰符即代表package/friendly/default
float maxHP
1. 类之间的关系
类和类之间的关系有如下几种:以Hero为例
自身:指的是Hero自己
同包子类:ADHero这个类是Hero的子类,并且和Hero处于同一个包下
不同包子类:Support这个类是Hero的子类,但是在另一个包下
同包类: GiantDragon 这个类和Hero是同一个包,但是彼此没有继承关系
其他类:Item这个类,在不同包,也没有继承关系的类
2. private 私有的
使用private修饰属性
自身:是可以访问的
同包子类:不能继承
不同包子类:不能继承
同包类:不能访问
其他包类:不能访问
红色字体,表示不可行
package charactor;public class Hero {// 属性id是private的,只有Hero自己可以访问// 子类不能继承// 其他类也不能访问private int id;
}
2. package/friendly/default 不写
没有修饰符即代表package/friendly/default
float maxHP; 血量上限
package charactor;public class Hero {private int id;String name;// 无修饰符的属性 hp// 自己可以访问// 同包子类可以继承// 不同包子类不能继承// 同包类可以访问// 不同包类不能访问}
4. protected 受保护的
受保护的修饰符
protected float hp; 血量
package charactor;public class Hero {private int id;String name;// protected饰符的属性 hp// 自己可以访问// 同包子类可以继承// 不同包子类可以继承// 同包类可以访问// 不同包类不能访问protected float hp;
}
5. public 公共的
公共的修饰符
public String name; 姓名
任何地方,都可以访问
package charactor;public class Hero {private int id;// public的属性 name// 自己可以访问// 同包子类可以继承// 不同包子类可以继承// 同包类可以访问// 不同包类可以访问public String name;protected float hp;}
6. 总结
7. 那么什么情况该用什么修饰符呢?
从作用域来看,public能够使用所有的情况。 但是大家在工作的时候,又不会真正全部都使用public那么到底什么情况该用什么修饰符呢?
- 属性通常使用private封装起来
- 方法一般使用public用于被调用
- 会被子类继承的方法,通常使用protected
- package用的不多,一般新手会用package,因为还不知道有修饰符这个东西
再就是作用范围最小原则
简单说,能用private就用private,不行就放大一级,用package,再不行就用protected,最后用public。 这样就能把数据尽量的封装起来,没有必要露出来的,就不用露出来了
类属性
当一个属性被static修饰的时候,就叫做类属性,又叫做静态属性
当一个属性被声明成类属性,那么所有的对象,都共享一个值
与对象属性对比:
不同对象的 对象属性 的值都可能不一样。
比如盖伦的hp 和 提莫的hp 是不一样的。
但是所有对象的类属性的值,都是一样的
1. 类属性
类属性: 又叫做静态属性
对象属性: 又叫实例属性,非静态属性
如果一个属性声明成类属性,那么所有的对象,都共享这么一个值
给英雄设置一个类属性叫做“版权" (copyright), 无论有多少个具体的英雄,所有的英雄的版权都属于 Riot Games公司。
package charactor;public class Hero {public String name; // 实例属性,对象属性,非静态属性protected float hp;static String copyright; 7 45// 类属性,静态属性kpublic static void main(String[] args) {Hero garen = new Hero();garen.name = "盖伦";Hero.copyright = "版权由Riot Games公司所有";System.out.println(garen.name); // 盖伦System.out.println(garen.copyright); // 版权由Riot Games公司所有Hero teemo = new Hero();teemo.name = "提莫";System.out.println(teemo.name); // 提莫System.out.println(teemo.copyright); // 版权由Riot Games公司所有}
}
2. 访问类属性
访问类属性有两种方式
- 对象.类属性
teemo.copyright
- 类.类属性
Hero.copyright
这两种方式都可以访问类属性,访问即修改和获取,但是建议使用第二种 类.类属性 的方式进行,这样更符合语义上的理解
3. 什么时候使用对象属性,什么时候使用类属性
如果一个属性,每个英雄都不一样,比如name,这样的属性就应该设计为对象属性,因为它是 跟着对象走的,每个对象的name都是不同的
如果一个属性,所有的英雄都共享,都是一样的,那么就应该设计为类属性。比如血量上限,所有的英雄的血量上限都是 9999,不会因为英雄不同,而取不同的值。 这样的属性,就适合设计为类属性
4. 练习 - 类属性
通过garen.copyright修改其值
garen.copyright = "Blizzard Entertainment Enterprise";
然后打印teemo.copyright,观察是否有变化
package charactor;public class Hero {public String name; // 实例属性,对象属性,非静态属性protected float hp;static String copyright; // 类属性,静态属性public static void main(String[] args) {Hero garen = new Hero();garen.name = "盖伦";Hero.copyright = "版权由Riot Games公司所有";// 修改的是类属性,是所有对象共有的 加上final就不能改变了garen.copyright = "Blizzard Entertainment Enterprise";System.out.println(garen.name); // 盖伦System.out.println(garen.copyright); // Blizzard Entertainment EnterpriseHero teemo = new Hero();teemo.name = "提莫";System.out.println(teemo.name); // 提莫System.out.println(teemo.copyright); // Blizzard Entertainment Enterprise}
}
类方法
1. 类方法
类方法: 又叫做静态方法
对象方法: 又叫实例方法,非静态方法
访问一个对象方法,必须 建立在有一个对象 的前提的基础上
访问类方法,不需要对象 的存在,直接就访问
package charactor;public class Hero {public String name;protected float hp;// 实例方法,对象方法,非静态方法// 必须有对象才能够调用public void die() {hp = 0;}// 类方法,静态方法// 通过类就可以直接调用public static void battleWin() {System.out.println("battle win");}public static void main(String[] args) {Hero gareen = new Hero();gareen.name = "盖伦";// 必须有一个对象才能调用gareen.die();Hero teemo = new Hero();teemo.name = "提莫";// 无需对象,直接通过类调用Hero.battleWin();}
}
2. 调用类方法
和 访问类属性 一样,调用类方法也有两种方式
- 对象.类方法
garen.battleWin();
2. 类.类方法
Hero.battleWin();
这两种方式都可以调用类方法,但是建议使用第二种 类.类方法 的方式进行,这样更符合语义上的理解。
并且在很多时候,并没有实例,比如 随机数的获取办法
Math.random()
random()就是一个类方法,直接通过类Math进行调用,并没有一个Math的实例存在。
3. 什么时候设计对象方法,什么时候设计类方法
如果在某一个方法里,调用了对象属性,比如
public String getName(){return name;}
t
HOW2J.CN - 学习笔记(类和对象)相关推荐
- Java 入门知识学习笔记 (类和对象)
一.类和对象的定义及关系 1.类是同一类别对象的抽象定义:可以理解为是某一类具体对象的模子,确定对象将会拥有的特性,包括该类对象具备的属性和方法. 2.对象是对类的一种具体化的客观存在,是对类的具体实 ...
- (JAVA学习笔记) 类与对象小结
1.类与对象 类是一个抽象的模板: 对象是类的一个具体的实例: 2.方法 方法的定义:修饰符,返回类型,方法名,参数列表,异常抛出,返回值. 方法的调用:静态方法,非静态方法,形参和实参,值传递和引用 ...
- java学习笔记-类与对象示例
类与对象 环境 类和对象的概念 代码格式 实例化对象 调用方法 小游戏:王者solo赛 问题:如果有100个英雄呢? 继承 概念 格式 具体内容 子类可以继承到父类的哪些 方法重写: 自动转型: 优点 ...
- Kotlin学习笔记——类和对象
推荐kotlin学习书籍 下载链接: https://pan.baidu.com/s/19b5WYDD3Yqh1CAsRvpUsqQ 提取码获取方式:扫描关注下面微信公众号,回复关键字: kotlin ...
- C#.NET学习笔记 -类,接口,对象
在开始谈接口和类的总结之前,先来了解接口和类的基本概念.熟悉了概念再来看代码就容易理解些. 先来看类的概念:什么是类? 类是面向对象程序设计的核心,实际上是一种复杂的数据类型.将不同类型的数据和与这些 ...
- 传智博客学习笔记8--面向对象下
传智博客学习笔记8--面向对象下 2009-3-12 15:41:42 继承 extends 接口 interface 如果一个抽象类中的所有方法都是抽象的,我们就可以将这个类用另外一种方式来定义,也 ...
- jmh学习笔记-State共享对象
系列文章目录 jmh学习笔记-源代码编译与bench mode jmh学习笔记-State共享对象 jmh学习笔记-State共享对象前后置方法 jmh学习笔记-代码清除 jmh学习笔记-常量折叠 j ...
- JavaScript:学习笔记(9)——Promise对象
JavaScript:学习笔记(9)--Promise对象 引入Promise Primose是异步编程的一种解决方案,比传统的解决方案回调函数和事件更加合理和强大.如下面为基于回调函数的Ajax操作 ...
- python学习笔记4(对象/引用;多范式; 上下文管理器)
python学习笔记4(对象/引用:多范式; 上下文管理器) ### Python的强大很大一部分原因在于,它提供有很多已经写好的,可以现成用的对象 21. 动态类型:对象/引用 对象和引用: 对象是 ...
最新文章
- 【Sql Server】数据库的安全机制
- 虚拟机VMware下CentOS6.6安装教程图文详解
- POJ 2430 状压DP
- 扩展城市信道etu模型matlab仿真,LTE System Toolbox:无线通信系统的仿真、分析和测试...
- Tomcat6.0.13下配置Tomcat Administration Web Application
- 微软这次发布会巨硬:安卓折叠手机、双屏电脑,还有无线耳机和超薄平板
- 如何通便清肠快速见效_如何三个月合理瘦身减脂
- UEFI下用rufus安装ubuntu16.04 LTS
- 微信小程序中相机api_微信小程序 Image API实例详解
- ZZ_MODIFIED_GEEBINF 不可用
- UILabel-IOS开发
- MySQL游标(cursor) 定义及使用
- 周伟焜:IBM为何重造信仰
- java itextpdf 5 基础知识
- java如何实现系统定位_如何快速定位到系统中某一功能的具体实现
- win10 SystemParametersInfo 设置屏保 不好使_Acer 暗影骑士 N50-N92电脑如何重装win10?win10专业版系统重装教程...
- No valid entries or contents found, this is not a valid OOXML (Office Open XML) file
- opengl绘制三维人物luweiqi
- 从​程序员到大型分布式架构师,自己到底位于哪里(一)
- 最详细的链路层讲解,这一篇就够了