VB.net 2010 视频教程 VB.net 2010 视频教程 python基础视频教程
SQL Server 2008 视频教程 c#入门经典教程 Visual Basic从门到精通视频教程
当前位置:
首页 > 编程开发 > 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){
        }
    }
相关教程