JAVA基础：引用、函数重载、this、传参、访问修饰符、类属性、类方法、初始化、单例模式、枚举类型

LMNNNN

于 2019-03-26 21:22:07 发布

阅读量140

点赞数

分类专栏： how2j

how2j 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

来源：how2j
引用
引用的概念，如果一个变量的类型是类类型，而非基本类型，那么该变量又叫做引用。
个人理解：java的引用类似于c++的指针，java函数只存在值传递
new Hero();
代表创建了一个Hero对象
但是也仅仅是创建了一个对象，没有办法访问它
为了访问这个对象，会使用引用来代表这个对象
Hero h = new Hero();
h这个变量是Hero类型，又叫做引用
=的意思指的h这个引用代表右侧创建的对象
“代表” 在面向对象里，又叫做“指向”
函数重载
方法的重载指的是方法名一样，但是参数类型、个数、顺序不一样

可变数量的参数

public class ADHero extends Hero {
 
    public void attack() {
        System.out.println(name + " 进行了一次攻击 ，但是不确定打中谁了");
    }
 
    // 可变数量的参数
    public void attack(Hero... heros) {
        for (int i = 0; i < heros.length; i++) {
            System.out.println(name + " 攻击了 " + heros[i].name);
 
        }
    }
 
    public static void main(String[] args) {
        ADHero bh = new ADHero();
        bh.name = "赏金猎人";
 
        Hero h1 = new Hero();
        h1.name = "盖伦";
        Hero h2 = new Hero();
        h2.name = "提莫";
 
        bh.attack(h1);
        bh.attack(h1, h2);
 
    }
 
}

this
this这个关键字，相当于普通话里的“我”
this即代表当前对象

通过this关键字访问对象的属性

public class Hero {
     
    String name; //姓名
     
    float hp; //血量
     
    float armor; //护甲
     
    int moveSpeed; //移动速度
 
    //参数名和属性名一样
    //在方法体中，只能访问到参数name
    public void setName1(String name){
        name = name;
    }
     
    //为了避免setName1中的问题，参数名不得不使用其他变量名
    public void setName2(String heroName){
        name = heroName;
    }
     
    //通过this访问属性
    public void setName3(String name){
        //name代表的是参数name
        //this.name代表的是属性name
        this.name = name;
    }
     
    public static void main(String[] args) {
        Hero  h =new Hero();
         
        h.setName1("teemo");
        System.out.println(h.name);
         
        h.setName2("garen");
        System.out.println(h.name);    
         
        h.setName3("死歌");
        System.out.println(h.name);    
    }
     
}

如果要在一个构造方法中，调用另一个构造方法，可以使用this()

public class Hero {
        
    String name; //姓名
        
    float hp; //血量
        
    float armor; //护甲
        
    int moveSpeed; //移动速度
        
    //带一个参数的构造方法
    public Hero(String name){
        System.out.println("一个参数的构造方法");
        this.name = name;
    }
      
    //带两个参数的构造方法
    public Hero(String name,float hp){
        this(name);
        System.out.println("两个参数的构造方法");
        this.hp = hp;
    }
 
    public static void main(String[] args) {
        Hero teemo =  new Hero("提莫",383);
         
        System.out.println(teemo.name);
         
    }
      
}

传参
变量有两种类型基本类型和类类型
参数也是变量，所以传参分为基本类型传参和类类型传参
基本类型传参，在方法内，无法修改方法外的基本类型参数
类类型又叫引用，引用传参使形参和实参指向同一个对象，对该对象进行操作
包
把比较接近的类，规划在同一个包下
使用同一个包下的其他类，直接使用即可
但是要使用其他包下的类，必须import
访问修饰符
成员变量有四种修饰符
private 私有的
package/friendly/default 不写
protected 受保护的
public 公共的

类之间的关系：
类和类之间的关系有如下几种:
以Hero为例
自身：指的是Hero自己
同包子类：ADHero这个类是Hero的子类，并且和Hero处于同一个包下
不同包子类：Support这个类是Hero的子类，但是在另一个包下
同包类： GiantDragon 这个类和Hero是同一个包，但是彼此没有继承关系
其他类：Item这个类，在不同包，也没有继承关系的类
在这里插入图片描述
private 私有的：
自身：是可以访问的
同包子类：不能继承
不同包子类：不能继承
同包类：不能访问
其他包类：不能访问
package/friendly/default 不写：

在这里插入图片描述
protected 受保护的：

public 公共的：

总结：

在这里插入图片描述常用：

属性通常使用private封装起来
方法一般使用public用于被调用
会被子类继承的方法，通常使用protected
package用的不多，一般新手会用package,因为还不知道有修饰符这个东西

类属性
当一个属性被static修饰的时候，就叫做类属性，又叫做静态属性
当一个属性被声明成类属性，那么所有的对象，都共享一个值
与对象属性对比：
不同对象的对象属性的值都可能不一样。
比如盖伦的hp 和提莫的hp 是不一样的。
但是所有对象的类属性的值，都是一样的

类属性：
类属性：又叫做静态属性
对象属性：又叫实例属性，非静态属性
如果一个属性声明成类属性，那么所有的对象，都共享这么一个值
给英雄设置一个类属性叫做“版权" (copyright), 无论有多少个具体的英雄，所有的英雄的版权都属于 Riot Games公司。

访问类属性：
访问类属性有两种方式

对象.类属性 teemo.copyright
类.类属性 Hero.copyright

类方法
类方法：又叫做静态方法
对象方法：又叫实例方法，非静态方法
访问一个对象方法，必须建立在有一个对象的前提的基础上
访问类方法，不需要对象的存在，直接就访问

调用类方法：
和访问类属性一样，调用类方法也有两种方式

对象.类方法 garen.battleWin();
类.类方法 Hero.battleWin();

**属性初始化 **
对象属性初始化有3种

声明该属性的时候初始化
构造方法中初始化
初始化块

对象属性初始化：

package charactor;

public class Hero {
	public String name = "some hero"; //声明该属性的时候初始化 
	protected float hp;
	float maxHP;
	
	{
		maxHP = 200; //初始化块
	}	
	
	public Hero(){
		hp = 100; //构造方法中初始化
		
	}

类属性初始化有2种

声明该属性的时候初始化
静态初始化块

类属性初始化：

public class Hero {
    public String name;
    protected float hp;
    float maxHP;
     
    //物品栏的容量
    public static int itemCapacity=8; //声明的时候 初始化
     
    static{
        itemCapacity = 6;//静态初始化块 初始化
    }
     
    public Hero(){
         
    }
     
    public static void main(String[] args) {
        System.out.println(Hero.itemCapacity);
    }
     
}

单例模式
单例模式又叫做 Singleton模式，指的是一个类，在一个JVM里，只有一个实例存在。
饿汉式单例模式：
GiantDragon 应该只有一只，通过私有化其构造方法，使得外部无法通过new 得到新的实例。
GiantDragon 提供了一个public static的getInstance方法，外部调用者通过该方法获取12行定义的对象，而且每一次都是获取同一个对象。从而达到单例的目的。
这种单例模式又叫做饿汉式单例模式，无论如何都会创建一个实例

package charactor;
 
public class GiantDragon {
 
    //私有化构造方法使得该类无法在外部通过new 进行实例化
    private GiantDragon(){
         
    }
 
    //准备一个类属性，指向一个实例化对象。 因为是类属性，所以只有一个
 
    private static GiantDragon instance = new GiantDragon();
     
    //public static 方法，提供给调用者获取12行定义的对象
    public static GiantDragon getInstance(){
        return instance;
    }
     
}

调用：

package charactor;
 
public class TestGiantDragon {
 
    public static void main(String[] args) {
        //通过new实例化会报错
//      GiantDragon g = new GiantDragon();
         
        //只能通过getInstance得到对象
         
        GiantDragon g1 = GiantDragon.getInstance();
        GiantDragon g2 = GiantDragon.getInstance();
        GiantDragon g3 = GiantDragon.getInstance();
         
        //都是同一个对象
        System.out.println(g1==g2);
        System.out.println(g1==g3);
    }
}

懒汉式单例模式：
懒汉式单例模式与饿汉式单例模式不同，只有在调用getInstance的时候，才会创建实例

package charactor;
 
public class GiantDragon {
  
    //私有化构造方法使得该类无法在外部通过new 进行实例化
    private GiantDragon(){       
    }
  
    //准备一个类属性，用于指向一个实例化对象，但是暂时指向null
    private static GiantDragon instance;
      
    //public static 方法，返回实例对象
    public static GiantDragon getInstance(){
        //第一次访问的时候，发现instance没有指向任何对象，这时实例化一个对象
        if(null==instance){
            instance = new GiantDragon();
        }
        //返回 instance指向的对象
        return instance;
    }
      
}

饿汉式是立即加载的方式，无论是否会用到这个对象，都会加载。
如果在构造方法里写了性能消耗较大，占时较久的代码，比如建立与数据库的连接，那么就会在启动的时候感觉稍微有些卡顿。

懒汉式，是延迟加载的方式，只有使用的时候才会加载。并且有线程安全的考量
使用懒汉式，在启动的时候，会感觉到比饿汉式略快，因为并没有做对象的实例化。但是在第一次调用的时候，会进行实例化操作，感觉上就略慢。

枚举类型
枚举enum是一种特殊的类(还是类)，使用枚举可以很方便的定义常量
比如设计一个枚举类型季节，里面有4种常量
public enum Season {
SPRING,SUMMER,AUTUMN,WINTER
}
一个常用的场合就是switch语句中，使用枚举来进行判断

public class HelloWorld {
    public static void main(String[] args) {
        Season season = Season.SPRING;
        switch (season) {
        case SPRING:
            System.out.println("春天");
            break;
        case SUMMER:
            System.out.println("夏天");
            break;
        case AUTUMN:
            System.out.println("秋天");
            break;
        case WINTER:
            System.out.println("冬天");
            break;
        }
    }
}

借助增强型for循环，可以很方便的遍历一个枚举都有哪些常量

public class HelloWorld {
    public static void main(String[] args) {
        for (Season s : Season.values()) {
            System.out.println(s);
        }
    }
}

LMNNNN

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA基础：引用、函数重载、this、传参、访问修饰符、类属性、类方法、初始化、单例模式、枚举类型

引用引用的概念，如果一个变量的类型是类类型，而非基本类型，那么该变量又叫做引用。个人理解：java的引用类似于c++的指针，java函数只存在值传递new Hero();代表创建了一个Hero对象但是也仅仅是创建了一个对象，没有办法访问它为了访问这个对象，会使用引用来代表这个对象Hero h = new Hero();h这个变量是Hero类型，又叫做引用=的意思指的h这个引用代...
复制链接

扫一扫