zoukankan      html  css  js  c++  java
  • 面向对象(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());
    		}
    	}
    }
    
  • 相关阅读:
    存储过程
    Java抽象类与接口的区别
    Spring资源
    30分钟搞定后台登录界面(103个后台PSD源文件、素材网站)
    单例模式(Singleton)的同步锁synchronized
    常用快捷键大全
    设计模式学习总结(一)——设计原则与UML统一建模语言
    git命令
    Test测试方法
    oracle表分区
  • 原文地址:https://www.cnblogs.com/geqianLee/p/12981538.html
Copyright © 2011-2022 走看看