Java面对对象（4）

static

1.概念

java类的运行包括类加载和实例化，静态成员（静态代码块，静态属性和静态方法）会被初始化。静态成员不属于某个对象，仅属于静态成员所在的类。

2.静态成员变量

属于其所在类，被类中的所有实例共享。可以通过类直接访问和类的实例访问。

2.1 实例

2.11 代码

public class Bank {
        //        群感成员变量，总钱数
        private static int count = 50000;

        public static void main(String[] args) {
            //实例化 10个 Bank 对象
            for (int i = 0; i < 10; i++) {

                Bank bank = new Bank();
                //每次取款1000元，类的实例调用静态成员属性
                bank.count = bank.count - 1000;
                System.out.println("当前银行总钱数 =" + Bank.count);
            }
        }
    }

2.12 运行结果

注释： 静态成员变量仅初始化一次，所有的实例都可以访问此静态成员变量，可以直接通过类名访问

3.静态方法

被static修饰的方法称静态方法可以通过类名直接访问。不能访问非静态的成员

3.1 实例

3.11 代码

 public class MathUtils{
        //计算平方
        public static double square(double num) {
            return num * num;
        }
        public static void main(String[] args){
        double num=9.6;
        double result=MathUtils.square(num);
        System.out.println(num+"的平方="+result);
        }
    }

3.12 运行结果

注释：静态方法中不能访问实例成员，由于类需要先进行加载，类加载时会为静态的成员开辟内存空间，而实例成员在类的实例化阶段才被创建，所以当类加载时静态的成员已经被创建，而此时并不存在实例成员，因此不能在静态方法中访问非静态成员。反之，可以在实例方法中访问静态成员。

4. 静态代码块

4.1 实例

4.11 代码

public class StaticBlock {
// 第一个静态代码块
static{
       System.out.println("---第一个静态代码块---");
      }
// 第二个静态代码块
static{
       System.out.println("---第二个静态代码块---");
       }
// 第三个静态代码块
static{
       System.out.println("---第三个静态代码块 ---");
       }
public static void main(String[] args){
        System.out.println("---main()方法被执行了---");
        }
    }

4.12 运行结果

包

1.自定义包的语法

package <包名>
//注意：声明一个包的语句必须写在类中的第一行

1.1实例

package com.java.oriented.dato.figure//使用package关键字声明包
public class Hero{
//类中的相关操作
}

2 包的导入语法

import <包名> <类名>
import Java.util.*;//导入 Java.util包中所有的类
import java.util.ArrayList;//导入 Java.util包中的ArrayList类

2.1实例

package com jaya orientod.dota.scene;
//Tree类	
 public class Tree {
 public void clear(){
// 具体业务逻辑
     }
}
//英雄类
 package com.java oriented. dota.figure;
//由于 Tree 类与 Hero 类不在同一个包中，所以需要使用 import 关键字导入包
 import com.java.oriented.dota.scene.Tree;
 public class Hero {
// 英雄吃树方法
 public void eatTree(Tree tree){
//调用树对象的clear()方法，吃掉的树在地图中消失
 tree.clear();
     }
 }

继承

通过继承原有类派生出的子类进行而构造出更为复杂的子类。子类既有新定义的行为特征，又继承了原有类的行为特征。
父类与子类存在着包含与包含的关系，是一种is-a关系。
子类除了可以沿用父类的特征和行为外。
通过继承可大幅度地提高代码的复用性，减少代码量，便于程序的后期维护。

1.语法

<修饰符> class 子类名  [extends 父类名] {
//类定义部分
}

2.实例

2.1代码

//父类
public class Weapon {
    String name;//武器名
    int attackValue;//攻击值
    //构造方法
    public Weapon(String name, int attackValue){
        System.out.println("--执行武器父类Weapon的构造方法--");
        this.name=name;
        this.attackValue=attackValue;
    }

    //攻击方法
    public void attack(){
        System.out.println("武器名："+name+"\t"+"攻击值："+attackValue);
    }
}


//子类
public class Spear extends Weapon{
    public Spear(String name,int attackValue){
        super(name,attackValue);
    }
}


public class Sword extends Weapon{
    public Sword(String name,int attackValue){
       super(name,attackValue);
    }
}

//测试类
public class ExtendsTest {
       public static void main(String[] args){
           Sword word = new Sword("圣剑",300);
           word.attack();
           Spear spear = new Spear("长矛",250);
           spear.attack();
       }
}

2.2运行结果

2.2运行结果

注意 ：Java中的继承为单继承，即一个子类只能有一个直接的父类

重载和重写

是指一个类中的多个方法可以具有相同的方法名，但具有不同的参数和不同定义重写就是在子类方法，重写父类方法，重写的方法和被重写的方法名称，参数例表和返回类型。可以通过父类的引用指向子类对象，而在运行时，则通过父类所指向的子类对象，调用子类中重写父类的方法

1.重载

1.实例

1.1代码

public class Book {
    //定义3个同名方法
    public float getPrice(){
        return 100;
    }
    public float getPrice(int page){
        //根据图书页数计算该书价格
        return (float) (page*0.1);
    }
    public float getPrice( int page,float discount){
        return (float) (page*discount);
    }
    public static void main(String[] args){
        Book book = new Book();
        System.out.println("default图书价格"+book.getPrice()+"元");
        System.out.println("根据页数计算图书价格"+book.getPrice(268)+"元");
        System.out.println("根据页数和折扣计算图书价格"+book.getPrice(360,0.2f)+"元");
    }
}

1.2运行结果

2.重载

2.实例

2.1代码

//父类
public class Bird {
    //Bird类的fly()方法
    public void fly(){
        System.out.println("我在蓝天白云间自由地飞翔......");
    }
}

//子类
public class Ostrich extends Bird{
    public void fly(){
        System.out.println("我只能在陆地上拍拍翅膀奔跑...");
    }
    //捕食方法
    public void prey(){
        //在捕食中调用fly()方法
        fly();
        System.out.println("执行捕食方法");
    }
    public static void main(String[] args){
        //创建Ostrich对象
        Ostrich ostrich = new Ostrich();
        ostrich.prey();//调用ostrich对象的prey()方法
    }
}

2.2运行结果

多态

是指同一操作作用于不同的对象，可以有不同的解释，以致产生不同的执行结果。