面对对象（2），
面对对象（2），
面向对象（2）
类属性
-
当一个属性被static修饰的时候，就叫做类属性，又叫做静态属性，当一个属性被声明成类属性，那么所有的对象，都共享一个值
-
不同对象的对象属性的值都可能不一样；但是所有对象的类属性的值，都是一样的
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公司所有";
System.out.println(garen.name);
//System.out.println(garen.copyright);
System.out.println(Hero.copyright);
Hero teemo = new Hero();
teemo.name = "提莫";
System.out.println(teemo.name);
System.out.println(teemo.copyright);
}
}
-
访问类属性：对象.类属性 或者 类.类属性（推荐后者）
-
如果一个属性，不同的对象不一样，比如name，这样的属性就应该设计为对象属性，因为它是跟着对象走的
-
如果一个属性，所有的对象都共享，那么就应该设计为类属性。类属性不会因为对象的不同而取不同的值。 这样的属性，就适合设计为类属性
类方法
-
类方法： 又叫做静态方法；对象方法： 又叫实例方法，非静态方法
-
访问一个对象方法，必须建立在有一个对象的前提的基础上；访问类方法，不需要对象的存在，直接就访问
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 garen = new Hero();
garen.name = "盖伦";
//必须有一个对象才能调用对象方法
garen.die();
Hero teemo = new Hero();
teemo.name = "提莫";
//无需对象，直接通过类调用
Hero.battleWin();
//teemo.battlewin();
}
}
-
调用类方法：对象.类方法 或者 类.类方法（推荐后者）
-
如果在某一个方法里，调用了对象属性，那么这个方法，就必须设计为对象方法
-
如果一个方法，没有调用任何对象属性，那么就可以考虑设计为类方法
-
类方法（静态方法）不能直接访问非静态属性，因为在内存中是现有静态内容后有非静态内容
-
静态方法中不能用this关键字，因为this代表当前对象，通过谁调用的方法谁就是对象
静态代码块
-
静态代码块格式：static{``}
-
静态代码块的特点：当第一次用到本类时，静态代码块执行唯一一次
静态内容总优先于非静态，所以静态代码块比构造方法先执行
package charactor;
public class Hero {
//静态代码块
static{
System.out.println("静态代码块执行");
}
public Hero{
System.out.println("构造方法执行");
}
public static void main(String[] args) {
Hero one = new Hero();//静态代码块和构造方法均执行
Hero two = new Hero();//仅有构造方法执行
}
}
-
静态代码块的用途：用来一次性地对静态成员变量进行赋值
抽象方法和抽象类
-
在类中声明一个方法，这个方法没有实现体，是一个“空”方法，这样的方法就叫抽象方法，使用修饰符 abstract
-
抽象方法所在的类必须是抽象类，同样用 abstract修饰
- 抽象类可以没有抽象方法，只要保证抽象方法所在的类是抽象类即可
- 没有抽象方法的抽象类也不能直接创建对象，在一些特殊场景下有用途
-
抽象类不能直接创建对象，必须用一个子类继承抽象父类
-
子类必须覆盖重写抽象父类中的所有抽象方法
覆盖重写：子类去掉抽象方法的 abstract关键字，然后补上方法体大括号
//抽象父类
public abstract class Hero {
String name; //姓名
float hp;//血量
int moveSpeed; //移动速度
//定义抽象方法
public abstract void attack();
}
////////////////////////////////////
//抽象子类
public class ADHero extends Hero {
@Override//覆盖重写
public void attack(){
System.out.println("进行物理攻击");
}
public static void main(String[] args){
ADHero h1 = new ADHero();
h1.attack();
}
}
-
当子类没有重写覆盖抽象父类的所有方法，则该子类也应该为抽象类
//抽象父类
public abstract class Hero {
//String name; //姓名
float hp;//血量
int moveSpeed; //移动速度
//定义抽象方法
public abstract void attack();
public abstract void rename(String name);
}
////////////////////////////
//子类也是抽象类
public abstract class ADHero extends Hero {
@Override//覆盖重写
public void attack(){
System.out.println("进行物理攻击");
}
// public abstract void rename(String name);未进行覆盖重写
}
/////////////////////////////
public class H1 extends ADHero{
@Override
public void rename(String name){
System.out.println("姓名是" + name);
}
public static void main(String[] args){
// ADHero garen = new ADHero;//ADhero仍为抽象类不能直接创建，会报错
H1 garen = new H1();
garen.attack();
garen.rename("garen");
}
}
ArrayList 集合
-
ArrayList是针对对象数组的一个包，即对象可存放于数组中
-
ArrayList<E> 中代表泛型，即在集合中的所有元素都是统一类型，泛型只能是引用类型不能是基本类型
-
对于ArrayList合集，直接打印得到的是[内容]，而不是地址值
-
若希望向ArrayList合集中存储基本数据类型，必须使用基本类型对应的包装类
byte-->Byte short-->Short int-->Integer long-->Long
float-->Float double-->Double char-->Character boolean-->Boolen
package arrayList;
import java.util.ArrayList;
import java.util.Random;
public class DemoArrayList {
public static void main(String[] args){
//创建一个ArrayList合集
//集合名称为listB，集合内部都是int类型的数据
//利用包装类导入基本类型
ArrayList<Integer> listB = new ArrayList<>();
for (int i=1; i <= 6; i++){
Random random = new Random();
int num = random.nextInt(33) + 1;//产生1-33随机数
listB.add(num);
}
System.out.println(listB);
}
}
-
常用方法：
-
.add(E)：向集合内添加一些数据,参数类型与泛型一致
-
.get(index)：从集合中获取元素，参数是索引编号，返回值是对应位置的元素
-
.remove(index)：从集合中删除元素，参数是索引编号，返回值是被删掉的元素
-
.size()：获取集合尺寸长度，返回值是集合中包含的元素个数
package arrayList;
public class Hero {
String name; //姓名
private float hp;//血量
int moveSpeed; //移动速度
public Hero(String name, float hp, int moveSpeed){
this.name = name;
this.hp = hp;
this.moveSpeed = moveSpeed;
}
public void setName(String name){
this.name = name;
}
public void setHp(float num){
if(num < 0)
System.out.println("数据不合理");
else
hp = num;
}
public void setMoveSpeed(int num){
if(num < 0)
System.out.println("数据不合理");
else
moveSpeed = num;
}
public String getName(){
return name;
}
public float getMoveSpeed(){
return moveSpeed;
}
public float getHp(){
return hp;
}
}
//////////////////////////////////////////////
package arrayList;
import java.util.ArrayList;
public class HeroList {
//将对象存入集合中
public static void main(String[] args){
ArrayList<Hero> list = new ArrayList<>();
Hero garen = new Hero("garen", 50, 100);
Hero temmo = new Hero("temmo", 40, 80);
list.add(garen);
list.add(temmo);
//遍历集合
for (int i=0; i < list.size(); i++){
Hero hero = list.get(i);
System.out.println("名字是" + hero.getName() +
"血量为" + hero.getHp() + "移动速度是" + hero.getMoveSpeed());
}
}
}
相关文章
暂无相关文章
当一个属性被static修饰的时候，就叫做类属性，又叫做静态属性，当一个属性被声明成类属性，那么所有的对象，都共享一个值
-
不同对象的对象属性的值都可能不一样；但是所有对象的类属性的值，都是一样的
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公司所有"; System.out.println(garen.name); //System.out.println(garen.copyright); System.out.println(Hero.copyright); Hero teemo = new Hero(); teemo.name = "提莫"; System.out.println(teemo.name); System.out.println(teemo.copyright); } }
访问类属性：对象.类属性 或者 类.类属性（推荐后者）
如果一个属性，不同的对象不一样，比如name，这样的属性就应该设计为对象属性，因为它是跟着对象走的
如果一个属性，所有的对象都共享，那么就应该设计为类属性。类属性不会因为对象的不同而取不同的值。 这样的属性，就适合设计为类属性
类方法： 又叫做静态方法；对象方法： 又叫实例方法，非静态方法
访问一个对象方法，必须建立在有一个对象的前提的基础上；访问类方法，不需要对象的存在，直接就访问
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 garen = new Hero();
garen.name = "盖伦";
//必须有一个对象才能调用对象方法
garen.die();
Hero teemo = new Hero();
teemo.name = "提莫";
//无需对象，直接通过类调用
Hero.battleWin();
//teemo.battlewin();
}
}
调用类方法：对象.类方法 或者 类.类方法（推荐后者）
如果在某一个方法里，调用了对象属性，那么这个方法，就必须设计为对象方法
如果一个方法，没有调用任何对象属性，那么就可以考虑设计为类方法
类方法（静态方法）不能直接访问非静态属性，因为在内存中是现有静态内容后有非静态内容
静态方法中不能用this关键字，因为this代表当前对象，通过谁调用的方法谁就是对象
静态代码块格式：static{``}
静态代码块的特点：当第一次用到本类时，静态代码块执行唯一一次
静态内容总优先于非静态，所以静态代码块比构造方法先执行
package charactor;
public class Hero {
//静态代码块
static{
System.out.println("静态代码块执行");
}
public Hero{
System.out.println("构造方法执行");
}
public static void main(String[] args) {
Hero one = new Hero();//静态代码块和构造方法均执行
Hero two = new Hero();//仅有构造方法执行
}
}
静态代码块的用途：用来一次性地对静态成员变量进行赋值
在类中声明一个方法，这个方法没有实现体，是一个“空”方法，这样的方法就叫抽象方法，使用修饰符 abstract
抽象方法所在的类必须是抽象类，同样用 abstract修饰
- 抽象类可以没有抽象方法，只要保证抽象方法所在的类是抽象类即可
- 没有抽象方法的抽象类也不能直接创建对象，在一些特殊场景下有用途
抽象类不能直接创建对象，必须用一个子类继承抽象父类
子类必须覆盖重写抽象父类中的所有抽象方法
覆盖重写：子类去掉抽象方法的 abstract关键字，然后补上方法体大括号
//抽象父类
public abstract class Hero {
String name; //姓名
float hp;//血量
int moveSpeed; //移动速度
//定义抽象方法
public abstract void attack();
}
////////////////////////////////////
//抽象子类
public class ADHero extends Hero {
@Override//覆盖重写
public void attack(){
System.out.println("进行物理攻击");
}
public static void main(String[] args){
ADHero h1 = new ADHero();
h1.attack();
}
}
当子类没有重写覆盖抽象父类的所有方法，则该子类也应该为抽象类
//抽象父类
public abstract class Hero {
//String name; //姓名
float hp;//血量
int moveSpeed; //移动速度
//定义抽象方法
public abstract void attack();
public abstract void rename(String name);
}
////////////////////////////
//子类也是抽象类
public abstract class ADHero extends Hero {
@Override//覆盖重写
public void attack(){
System.out.println("进行物理攻击");
}
// public abstract void rename(String name);未进行覆盖重写
}
/////////////////////////////
public class H1 extends ADHero{
@Override
public void rename(String name){
System.out.println("姓名是" + name);
}
public static void main(String[] args){
// ADHero garen = new ADHero;//ADhero仍为抽象类不能直接创建，会报错
H1 garen = new H1();
garen.attack();
garen.rename("garen");
}
}
ArrayList是针对对象数组的一个包，即对象可存放于数组中
ArrayList<E> 中
-
对于ArrayList合集，直接打印得到的是[内容]，而不是地址值
-
若希望向ArrayList合集中存储基本数据类型，必须使用基本类型对应的包装类
byte-->Byte short-->Short int-->Integer long-->Long
float-->Float double-->Double char-->Character boolean-->Boolen
package arrayList; import java.util.ArrayList; import java.util.Random; public class DemoArrayList { public static void main(String[] args){ //创建一个ArrayList合集 //集合名称为listB，集合内部都是int类型的数据 //利用包装类导入基本类型 ArrayList<Integer> listB = new ArrayList<>(); for (int i=1; i <= 6; i++){ Random random = new Random(); int num = random.nextInt(33) + 1;//产生1-33随机数 listB.add(num); } System.out.println(listB); } }
常用方法：
-
.add(E)：向集合内添加一些数据,参数类型与泛型一致 -
.get(index)：从集合中获取元素，参数是索引编号，返回值是对应位置的元素 -
.remove(index)：从集合中删除元素，参数是索引编号，返回值是被删掉的元素 -
.size()：获取集合尺寸长度，返回值是集合中包含的元素个数
package arrayList;
public class Hero {
String name; //姓名
private float hp;//血量
int moveSpeed; //移动速度
public Hero(String name, float hp, int moveSpeed){
this.name = name;
this.hp = hp;
this.moveSpeed = moveSpeed;
}
public void setName(String name){
this.name = name;
}
public void setHp(float num){
if(num < 0)
System.out.println("数据不合理");
else
hp = num;
}
public void setMoveSpeed(int num){
if(num < 0)
System.out.println("数据不合理");
else
moveSpeed = num;
}
public String getName(){
return name;
}
public float getMoveSpeed(){
return moveSpeed;
}
public float getHp(){
return hp;
}
}
//////////////////////////////////////////////
package arrayList;
import java.util.ArrayList;
public class HeroList {
//将对象存入集合中
public static void main(String[] args){
ArrayList<Hero> list = new ArrayList<>();
Hero garen = new Hero("garen", 50, 100);
Hero temmo = new Hero("temmo", 40, 80);
list.add(garen);
list.add(temmo);
//遍历集合
for (int i=0; i < list.size(); i++){
Hero hero = list.get(i);
System.out.println("名字是" + hero.getName() +
"血量为" + hero.getHp() + "移动速度是" + hero.getMoveSpeed());
}
}
}
相关文章
- 暂无相关文章
用户点评