Java基础(6)- 面向对象解析

java面向对象

对象

知识点

• java 的方法参数是按值调用，是参数的一份拷贝
• 封装
  • 使用private将 属性值/方法 隐藏,外部只能调用 get,set方法/非private 的接口 获取
• 重载
  • 方法调用时，同名函数 根据参数来自动选择（返回类型不是方法名的一部分）
• 不显式声明构造器 会提供默认的无参构造器
• 初始化数据方法
  • 构造器赋值
  • 声明中赋值
  • 初始化块
• 初始化顺序
  • 赋值 ->静态块->构造器

demo

    public class Hero extends People{
        //赋值语句先于构造器执行
        private String skill = "none";
        //静态 不可变 公用常量
        public static final String FLY = "Hero can fly";
        //类构造器
        public Hero(String name, int age){
            this.setName(name);;
            this.setAge(age);
        }
        public Hero(String name, int age,String skill){
            //调用另外一个构造器
            this(name,age);
            this.setSkill(skill);
        }
        //get 方法 不应该返回对象引用，会出现数据的封装性破坏，如需返回对象，则返回一个拷贝对象
        //域访问器
        public String getSkill() {
            return skill;
        }
        //域更改器
        public void setSkill(String skill) {
            this.skill = skill;
        }
        public void changeValue(Hero h){
            h.setName("change");
        }
        public static void main(String[] args) {
            Hero h1 = new Hero("Saber",20);
            Hero h2 = new Hero("Archer",20);
            h1.changeValue(h2);
            System.out.println(h2.getName());
        }
    }

抽象类

    public abstract class FateHero extends Hero {
        private String hope = "圣杯";
        public FateHero(String name, int age) {
            super(name, age);
        }
        public FateHero(String name, int age,String skill){
            //调用另外一个构造器
            super(name,age,skill);
        }

        public abstract void sayWantSomething();
        public String getHope() {
            return hope;
        }
        public void setHope(String hope) {
            this.hope = hope;
        }

    }

继承

• 多态:
  • 一个变量能指向多种实际类型
• 动态绑定:
  • 在运行时能够自动选择调用哪个方法（父类的方法被子类覆盖时能正确运行子类的方法）
• 不允许继承 就可以用final 修饰class

    //子类
    public class Master extends People {
        private Hero hero = null;

        public Hero getHero() {
            return hero;
        }
        public void setHero(Hero hero) {
            this.hero = hero;
        }

        public static void main(String[] args) {
            //继承了父类的方法和属性
            Master m = new Master();
            m.setAge(11);
            m.setName("NoName");
        }
    }
    //父类
    public class People {
        private String name;
        private int age;
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
    }

接口

• 利用java的多态性,使用接口定义一个对象 可以便于更换实现类

• 封装实现类的方法

  public interface IFight {
      public void fight();
      public void runAway();
  }
  
  public class FigthWithTest implements IFight{
      private Hero hero = null;
      public FigthWithTest(Hero hero){
          this.hero = hero;
      }
      @Override
      public void fight() {
          System.out.println(hero.getName() +"试探性的与敌方交手");
      }
  
      @Override
      public void runAway() {
          System.out.println(hero.getName() +"立即撤退，没必要暴露太多能力");
      }
  
      public Hero getHero() {
          return hero;
      }
  
      public void setHero(Hero hero) {
          this.hero = hero;
      }
  
  }