您现在的位置是:网站首页>javajava

java的类和对象基础

deling2019年3月28日java366人已围观

简介java的类和对象基础!内容点:1.java 类与对象的引用, 2.构造方法, 3.方法的继承 4.this关键字 5.类和对象的传参 6.访问修饰符 7.类属性 8.类方法 9.单例模式 10.枚举

1.java 类与对象的引用


对象:是特定类型的数据,看得到,摸得着的是对象

类:是一个虚拟的模版,抽象的概念

属性:静态特征,比如:名字 性别等  

方法: 能做什么动作等行为  例如 :跑,吃,睡等

类 实例化 对象

类名 对象名  = new 构造方法名();
对象名.属性;
对象名.方法();

引用的概念: 如果一个变量的类型是 类类型,而非基本类型,那么该变量又叫做引用。
引用和指向:
Scan sc = new Scan(); new 代表创建了一个Scan对象,sc这个变量是Scan类型,又叫做引用 =的意思指的h这个引用代表右侧创建的对象 “代表” 在面向对象里,又叫做“指向”;

引用 sc 指向 Scan对象;

多个引用,一个对象:
将多个引用指向同一个对象

public class Scan {
    public static void  main(String []args){        
    Scan sc = new Scan();        
    Scan h1 = sc;  
        Scan h2 = sc ;
        Scan h3 =h1;
    }
}

多个对象,一个引用

没有任何控制和访问该对象时,那么该对象就变得没有意义!

public class Scan {    
public static void  main(String []args){
        Scan sc = new Scan();
             sc = new Scan();
    }
}

2.构造方法

构造方法与类同名,且没有返回值!
实例化一个对象的时候必须调用构造方法

格式:

public 构造方法名(){   
 //初始化代码
 }

参数列表 可加参数,也可以不加参数
只能在对象实例化的时候调用!构造方法也能重载!

例如:

public class Hero {
		String name;		
		float hp;		
		float armor;		
		int moveSpeed;		
		/*
		 * 无参构造方法
		 */
		public Hero(){
			System.out.println("这是无参构造方法!");
		}		/*
		 * 带参构造方法,重载无参构造方法
		 */
		public Hero(String name,float hp,int moveSpeed,float armor) {			
		/*
			 * 参数赋值给属性
			 */
			this.name=name;			
			this.hp=hp;			
			this.moveSpeed=moveSpeed;			
			this.armor=armor;           
		}		
	public static void main(String[] args) {		
	// TODO Auto-generated method stub
		Hero h = new  Hero();  // 无参构造方法 实例化对象
		Hero h1 =new Hero("提莫",15.5f,156,15.1f);  // 带参构造方法实例化对象
		System.out.print("英雄名字:"+h1.name+",英雄血量:"+h1.hp+",英雄移动速度:"+h1.moveSpeed+",英雄护甲:"+h1.armor);
	}
}

注意: 如果我们当没有指定构造方法时,系统会自动添加无参的构造方法,但是一旦提供了一个有参的构造方法 同时又没有显示的提供一个无参的构造方法 那么默认的无参的构造方法,就"木有了"!

3.方法的继承
例如:一部手机有name(名字) 和 price(价格),还有weight(重量)也是手机的一种,在设计类的时候可以让手机的重量来继承手机(Item),从而继承手机的重量!

手机类:

public class ItemS {
    String name;   //  名字
    int price;    //  价格}

重量类:

public class Phone  extends  ItemS{
        double weight;  //  额外手机重量
    public  static  void  main(String []args){       
    Phone p =new Phone();
        p.name  = "小米";
        p.price = 3298;
        p.weight=188.5;        
        System.out.println("手机的名字:"+p.name+"价格:"+p.price+("元")+"重量:"+p.weight+("mm"));
    }
}

this关键字

this 在类中就是代表当前对象本身,可以通过this关键字完成当前对象的成员属性,成员方法和构造方法的调用。

什么时候用this 关键字?

当定义类中的方法时,如果需要要调用该类对象,就可以使用this,也就是,但凡在本类功能内部使用到了本类对象!都用this表示,至于代表那个对象,就看其所在功能被那个对象调用,这样就知道谁在参与运算!
调用构造方法用this(参数),

this(参数)  

注意:构造方法必须要有this,而返回类型的方法可要可不要!

调用返回类型的方法

this.方法名(参数) ,this可要可不要。

例如:

public class Hero {		
String name;		
float hp;		
float armor;		
int moveSpeed;		
		/*
		 * 构建一个跑的方法
		 */
		public void run(String name){
			System.out.println(name+"快跑!");
		}		/*
		 * 无参构造方法
		 */
		public Hero(){
			System.out.println("这是无参构造方法!");
		}		/*
		 * 带参构造方法,重载无参构造方法
		 */
		public Hero(String name,float hp,int moveSpeed,float armor) {			/*
			 * 参数赋值给属性
			 */
			this.run(name); // 调用上面方法中的跑方法
			this.name=name; // 调类中的属性
			this.hp=hp;      // 调类中的属性
			this.moveSpeed=moveSpeed; // 调类中的属性
			this.armor=armor;          // 调类中的属性
		}		
	public static void main(String[] args) {		
	// TODO Auto-generated method stub
		Hero h = new  Hero();  // 无参构造方法 实例化对象
		Hero h1 =new Hero("提莫",15.5f,156,15.1f);  // 带参构造方法实例化对象
		System.out.print("英雄名字:"+h1.name+",英雄血量:"+h1.hp+",英雄移动速度:"+h1.moveSpeed+",英雄护甲:"+h1.armor);
	}
}

例如2:

public class Hero1 {
	String name; //姓名
    
    float hp; //血量
        
    float armor; //护甲
        
    int moveSpeed; //移动速度
    public Hero1(String name) {
    	System.out.println("一个带参的构造方法");    	
    	this.name = name;         // 调用类中的属性name
    }    /*
            * 重载上面的类,并添加参数二
     */
    public Hero1(String name,float hp) {    	
        this(name);              // 调用方法         
    	this.hp=hp;               // 调用属性
    	System.out.println("两个个带参的构造方法 ");
    }    /*
     	* 重载上面的类,并添加参数三
     */
    public Hero1(String name,float hp,float armor) {    	
        this(name,hp);          //调用方法
    	this.armor=armor;        // 调用属性
    	System.out.println("三个带参的构造方法");
    }    /*
     * 重载上面的类,并添加参数四
     */
    public Hero1(String name,float hp,float armor,int moveSpeed) {    	
    this(name,hp,armor);      // 调用方法
    	this.moveSpeed=moveSpeed;  // 调用属性
    	System.out.println("四个带参的构造方法");
    }	
    public static void main(String[] args) {		
    // TODO Auto-generated method stub
		Hero1 h = new Hero1("提莫",338.1f,15.5f,156); // 实例化对象传参
		/*
		 * 打印输出
		 */
		System.out.print("英雄名字:"+h.name+",英雄血量:"+h.hp+",英雄移动速度:"+h.moveSpeed+",英雄护甲:"+h.armor);
	}

}

4.类和对象的传参
参数也是变量分为:

  • 基本类型传参

  • 类类型传参

基本类型传参: 在方法内,无法修改方法外的基本类型参数

5.访问修饰符

成员变量有四种修饰符:

private 私有的

package/friendly/default   默认

protected 受保护的

public 公共的

javaprivate.jpg

类之间的关系:
自身:本身的这个类
同包子类:子类和父类在同一个包下
不同包类:子类和父类不在同一个包下
同包类:同一个包下,但彼此没有继承关系
其他类:在不同包中,也没有继承关系

private : 私有的,只能在类的本类中访问,其他类中不能被访问

package/friendly/default: 这个可以不用写,这个有在同一个包下访问和继承,不同包下不能访问和继承

protected:   受保护的 自己可以访问,同包子类可以继承,不同包子类可以继承,同包类可以访问,不同包类不能访问,

public: 公共的修饰符,任何地方都能被使用

那么什么情况该用什么修饰符呢?

  1. 属性通常使用private封装起来

  2. 方法一般使用public用于被调用

  3. 会被子类继承的方法,通常使用protected

  4. package用的不多,一般新手会用default,因为还不知道有修饰符这个东西

作用范围最小原则

简单说,能用private就用private,不行就放大一级,用package,再不行就用protected,最后用public。 这样就能把数据尽量的封装起来,没有必要露出来的,就不用露出来了

6.类属性
当一个属性被static修饰的时候,就叫做类属性,又叫做静态属性
例如:static String name;

当一个属性被声明成类属性,那么所有的对象,都共享一个值
例如:一家游戏公司,创建出多个游戏,但是多个游戏的版权都属于这个家游戏公司!

类属性与对象属性对比: 不同对象的 对象属性 的值都可能不一样。

但是所有对象的类属性的值,都是一样的

类属性的初始化:

  1. 声明该属性的时候初始化

  2. 静态初始化块

对象属性的初始化:

  1. 声明该属性的时候初始化

  2. 构造方法中初始化

  3. 初始化块

对象属性初始化中三种反式的顺序:
先执行声明属性的初始化时,然后初始化块,最后执行构造方法中的初始化

类属性:静态属性,多个对象,同一个值。
对象属性:实例属性,多个对象,值也不同。

访问类属性的两种方法:
1.对象.类属性
2.类.类属性 建议使用第二种类.类属性的方法!

7.类方法
类方法:静态方法
对象方法:实例方法,非静态方法
对象方法和类方法的区别:
访问一个对象方法,必须建立在有一个对象为前提的基础之上
例如:对象名.对象方法 访问一个类方法,是可以直接用类访问! 例如:类.类方法

注意; 如果这个方法访问了对象属性,那么这个方法是对象方法,反之这个方法没有访问对象属性,那么这个方法可以是类方法!

类方法的调用的两种方法:

  1. 对象名.类方法

  2. 类.类方法

和类属性一样推荐第二种!
注意: 在类方法中,不能直接调用对象方法,因为对象方法是要建立在一个对象为前提的基础之上!


8.单例模式
目的:使类的一个对象成为该类系统中的唯一实例
实现单例模式的三要素:

1.私有的构造方法

2.私有静态属性指向实例对象

3.提供一个静态的公有方法用于创建、获取静态私有对象,返回第二步的静态属性

饿汉式

例如:

package charactor;public class GiantDragon {
	//私有化构造方法使得该类无法在外部通过new 进行实例化	
	private GiantDragon() {
		
	}
	//创建一个类属性,指向一个实例化对象。 因为是类属性,所以只有一个	
	private static GiantDragon instance = new GiantDragon();
	
	//创建一个静态方法,等待别人来调用这个饿汉式方法	
	public static GiantDragon getInstance(){        
	return instance;
    }

}

懒汉式
懒汉式单例模式与饿汉式单例模式不同,只有在调用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;
    }
      
}

饿汉式和懒汉式的区别:
饿汉式:是立即加载的方式,无论是否会用到这个对象,都会加载。

懒汉式: 是延迟加载的方式,只有使用的时候才会加载。

单例模式的优缺点:

优点:
1.在内存中只有一个对象,节省内存空间
2.避免频繁的创建销毁对象,提高性能
3.避免对共享资源的多重占用

缺点:
1.扩展比较困难
2.如果实例化后的对象长期不利用,系统将默认为垃圾进行回收,造成对象状态

实用的场景:
1.创建对象时占用资源过多,但同时又需要用到该类对象
2.对系统内资源要求统一读写,如配置信息
3.当多个实例存在可能引起逻辑。

9.枚举

枚举enum是一种特殊的类(还是类),使用枚举可以很方便的定义常量。
常量一般都是大写,一个常用的场合就是switch语句中,使用枚举来进行判断。
枚举的好处:范围死死的锁在你想要的范围内

例如:

package com.Hello; 	
enum Season1 {
	 SPRING,SUMMER,AUTUMN,WINTER
}
public class Hello {	
public static void main(String[] args) {
		//使用增强for循环,遍历出枚举中的所有值
		System.out.println("枚举中的所有值:");
			for(Season1 s:Season1.values()) {
			System.out.println(s);
		}		
		// TODO Auto-generated method stub
		
		Season1 season =Season1.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;
		}
		
	}

}

例2

枚举类:

public enum HeroType{
    TANK,WIZARD,ASSASSIN,ASSIST,WARRIOR,RANGED ,PUSH,FARMING,

}

运行类:

public class Hy {	
public static void main(String[] args) {		
// TODO Auto-generated method stub
		HeroType hy = HeroType.TANK;
		System.out.println("用for的增强循环输出所有的值:");		
		for(HeroType h:HeroType.values()) {
			System.out.println(h);
		}		
		switch(hy) {		
		case TANK:
			System.out.println("这个英雄为坦克!");			
			break;		
		case WIZARD:
			System.out.println("这个英雄是法师!");			
			break;		
		case ASSASSIN:
			System.out.println("这个英雄是刺客!");			
			break;		
		case ASSIST :
			System.out.println("这个英雄是辅助!");			
			break;		
		case WARRIOR:
			System.out.println("这个英雄是近战!");			
			break;		
		case RANGED:
			System.out.println("这个英雄是远程!");			
			break;		
		case PUSH:
			System.out.println("这个英雄是推进!");			
			break;		
		case FARMING:
			System.out.println("这个英雄是打野!");
		}

	}

}


Tags: java

很赞哦! (13)

上一篇: 无

下一篇: 无

留言

来说点儿什么吧...

您的姓名: *

选择头像: *

留言内容:

    2019年2月25日 13:35嘿嘿

    2019年2月26日 13:20ok

    可以可以!

    2019年3月18日 09:2311

    1

    2019年3月28日 09:24www.ikeguang.com

    可以可以

    2019年5月29日 18:47qwe

    666

    2019年5月30日 16:52BlankYk

    he,tui~

    2019年5月30日 17:04123

    321

    2019年6月26日 10:02周树人

    厉害厉害

    2019年6月26日 10:34sdlakrj

    sdaag

    2019年6月29日 15:31sdagafdbaf

    dgafdgdfh

    站长回复:你这是什么什么高级语言,我表示看不懂哈哈

    2019年7月6日 16:37啦啦

    写的真好!谢谢博主

    站长回复:谢谢!

    2019年8月14日 12:35傻傻

    厉害 小林

    2019年9月11日 20:05sdfw

    fgbhjksdgjdfhag

    2019年9月11日 22:18baba

    keke tui