面向对象第一部

当前位置:

首页 > 编程开发 > Java教程 >

面向对象第一部

创建及实例化对象

public class Item {
    //类属性
    String name; //姓名
    int price; //价格
	
    //实例化对象
    public static void main(String[] args) {
        Item xuePing =  new Item();
        xuePing.name = "血瓶";
        xuePing.price = 50;      

        Item caoXie =  new Item();
        caoXie.name = "草鞋";
        caoXie.price = 300;    
    }
}

当一个变量被声明在类下面，变量就叫做字段或者属性、成员变量、Field，其作用域就是从其声明的位置开始的整个类
属性的类型可以是基本属性，比如int整数，float 浮点数也可以是类类型，比如String 字符串
属性名称一般为小写，当为多个单词时后面单词首字母大写
new Item() 代表创建对象，而 Item xuePing = new Item() 代表引用xuePing指向对象，xuePing这个变量是Item类型

对象方法

public class Hero {
    String name; //姓名   
    float hp;//血量 
    float armor; //护甲    
    int moveSpeed; //移动速度
 
    //获取护甲值，返回值为float类型
    float getArmor(){
        return armor;
    }
     
    //回血
    void recovery(float blood){
        hp = hp + blood;
    }
    
    //增加移动速度，具有方法参数
    void addSpeed(int speed){
        //在原来的基础上增加移动速度
        moveSpeed = moveSpeed + speed;
    }
    
    public static void main(String[] args){
        Hero garen = new Hero();
        garen.name = "盖伦";
        garen.moveSpeed = 350;
        garen.addSpeed(100);
    }
     
}

方法主要用于表明对象功能，通常用函数表示
方法函数中可以有返回值，返回值类型记得与函数开头保持一致；也可以有方法参数
- 如果一个变量，是声明在一个方法上的，就叫做参数，参数的作用域为该方法内的所有代码
声明在方法内的变量，叫做局部变量，其作用域在声明开始的位置，到其所处于的块结束位置

继承

//Armor类继承了Item类及其属性
public class Armor extends Item {
	int ac;//护甲等级
	
    //实例化对象
    public static void main(String[] args) {
        Armor buJia =  new Armor();
        buJia.name = "布甲";
        buJia.price = 300;  
        buJia.ac = 15;
        System.out.println(buJia.name);
        System.out.println(buJia.ac);

        Armor suoZiJia =  new Armor();
        suoZiJia.name = "锁子甲";
        suoZiJia.price = 500; 
        suoZiJia.ac = 40;
        System.out.println(suoZiJia.name);
        System.out.println(suoZiJia.ac);
    }
}

继承主要解决共性抽取
Armor通过继承Item类，除了自己设计的ac属性，也具备了name和price属性
子类可以拥有父类中的内容，也可以有自己的内容
Java 继承的三个特点：
- Java语言是单继承的
- Java语言可以多级继承
- 一个子类的父类是唯一的，但是一个父类可以拥有很多个子类

方法重载

public class Support extends Hero {
    
    //heal方法名一样，但参数列表不同
	public void heal(){
		System.out.println(name + "提供治疗");
	}

	//可变数量的参数，可使用操作数组的方式处理参数heros
	public void heal(Hero...heros){
		for (int i = 0; i < heros.length; i++){
			System.out.println(name + "对" + heros[i].name + "进行了一次治疗 " + "血量为：" + heros[i].hp);
		}	
	}
    
	public void heal(Hero h, float hp){
		System.out.println(h.name + "加血量为：" + hp + "血量为：" + (h.hp+hp));
	}
    
	public static void main(String[] args){
		Hero h1  = new Hero();
		h1.name = "盖伦";
		h1.hp = 50;
		Hero h2 = new Hero();
		h2.name = "提莫";
		h2.hp = 40;
		Support h = new Support();
		h.name = "奶妈";
        //调用方法时，根据传递的参数类型以及数量，自动调用对应的方法
		h.heal();
		h.heal(h1, h2);
		h.heal(h1, 20);
		h.heal(h2, 30);
	}
}

方法的重载指的是方法名一样，但是参数类型不一样
采用可变数量的参数时只需要设计一个方法，public void attack(Hero ... heros) 即可代表上述所有的方法，在方法里使用操作数组的方式处理参数heros
在调用方法的时候，会根据传递的参数类型以及数量，自动调用对应的方法

构造方法

public class Hero {
    String name;
    float hp;
    
    // 方法名和类名一样（包括大小写）
    // 没有返回类型
    public Hero() {
        System.out.println("实例化一个对象的时候，必然调用构造方法");
    }
    
    //有参的构造方法
    //上述默认的无参的构造方法就失效了
    //有参的构造方法可以简化类的编写
    public Hero(String heroname){  
        name = heroname;
    }
    
    //当没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数和方法体，即
    //public Hero(){}
    
    public static void main(String[] args) {
        //实例化一个对象的时候，必然调用构造方法
        Hero garen =  new Hero("盖伦");  
        Hero h = new Hero();//有参时此构造方法失效
    }
}

构造方法是专门用来创建对象的方法，当我们通过关键字new创建对象时，其实就是在调用构造方法
构造方法的名称必须和所在类名称完全一样（包括大小写）
构造方法不能return一个具体返回值，所以构造方法不要写返回值类型，连void都不写
如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数和方法体
一旦编写至少一个构造方法，那么编译器将不再赠送
构造方法也可以进行重载

继承中的构造方法

public class Hero {
    public Hero(){
        System.out.println("父类无参构造");
    }
    
    public Hero(int num){
        System.out.println("父类有参构造");
    }
}
//////////////////////////////////////
public class Support extends Hero{
    public Support(){
    	//当未调用父类构造方法时默认隐含super()
        //super();
        super(20);//根据有参无参调用父类不同的构造方法
        System.out.println("子类构造方法");
    }    
    public static void main(String[] arags){
  		Support h = new Support();
    }
}

子类构造方法中有一个默认隐含的 super() 调用，所以先调用父类构造，后执行子类构造
子类构造可以通过super关键字来调用父类重载构造
super的父类构造调用必须是子类构造方法的第一个语句，即不能一个子类构造调用多次super构造
- super关键字的用法：在子类成员方法中访问父类成员变量或成员方法，在子类构造方法中访问父类构造方法

private关键字

public class Hero {
	String name; //姓名   
    private float hp;//血量
    private float armor; //护甲    
    int moveSpeed; //移动速度
    
    //向armor设置数值
    public void setArmor(float num){
    	if(num < 0)
        	System.out.println("数据不合理");
        else
        	armor = num;
    }
    //获取成员数据，返回值为float类型
    public float getArmor(){
        return armor;
    }
     
    //向hp设置数值
    public void setHp(float num){
        if(num < 0)
        	System.out.println("数据不合理");
        else
        	hp = num;
    }
    
    //获取成员数据，返回值为float类型
    public float getHp(){
    	return hp;
    }
}

///////////////////////////////////////////////////////////

//Support继承Hero同时，对成员变量进行了保护
public class Support extends Hero {
    
	//可变数量的参数，使用操作数组的方式处理参数heros
	public void heal(Hero...heros){
		for (int i = 0; i < heros.length; i++){
			System.out.println(name + "对" + heros[i].name + "进行了一次治疗 " + "血量为：" + heros[i].getHp());
		}	
	}
	public void heal(Hero h, float hp){
		System.out.println(h.name + "加血量为：" + hp + "血量为：" + (h.getHp()+hp));
	}
	public static void main(String[] args){
		Hero h1  = new Hero();
		h1.name = "盖伦";
		h1.setHp(50);
		Hero h2 = new Hero();
		h2.name = "提莫";
		h2.setHp(40);
		Support h = new Support();
		h.name = "奶妈";
		h.heal(h1, h2);
		h.heal(h1, 20);
		h.heal(h2, 30);
	}
}

private关键字可以将需要保护的成员变量进行修饰。
一旦使用private进行修饰，那么本类中仍然可以随意访问，但超出本类范围之外就不能随意访问。
需要间接访问private成员变量，即定义一对Getter/Setter方法，命名规则为 setXxx 或 getXxx 。对于Getter来说不能有参数，返回值类型和成员变量对应；对于Setter来说不能有返回值，参数类型和成员变量对应。

this关键字

this即代表当前对象（通过谁调用方法，谁就是this）
当方法的局部变量和类的成员变量重名时，根据就近原则，优先使用局部变量，如果需要访问本类中的成员变量可以通过 this.成员变量 访问
```
//通过this访问属性
public void setName(String name){
    //name代表的是参数name
    //this.name代表的是属性name
    this.name = name;
}
```
在本类成员方法中，调用另一个成员方法，可以使用 this.成员方法

在本类构造方法中，调用另一个构造方法，可以使用 this(...)

此调用也必须是构造方法的第一个语句，且super和 this两种构造调用不能同时使用

public class Hero{
    public Hero(){
       //super();//同时调用会报错，
        this(12);//可以通过this()调用有参构造方法
       // this(1, 2);//同时调用时会报错，即必须是构造方法的第一个语句
    }
    public Hero(int i){
        this(1, 2);
    }
     public Hero(int i, int j){
    }
}

栏目列表