栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Java 面向对象 (1)

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Java 面向对象 (1)

定义
类

所有使用类定义的变量都是引用变量,它们将会引用到类的对象

[修饰符] class 类名
{
    0 ~ n 个成员变量......
    0 ~ n 个方法......
    0 ~ n 个构造器......
}
  • 修饰符
    • public 、final 、abstract
    • 或省略
  • 类名
    • 一个合法的标识符
    • 由有意义的英文单词连缀而成
    • 不得有分隔符
    • 每个单词首字母大写
    • 其他皆小写
  • 类的三个基本成员
    • 成员变量
    • 方法
    • 构造器
static

static 修饰的成员不能访问没有 static 修饰的成员

静态成员不能访问非静态成员

因为静态成员的作用域比非静态成员的作用域大,完全可能出现静态成员已经初始化完成,而非静态成员还不曾初始化的情况,如果允许静态成员访问非静态成员,将引起大量错误

  • static 修饰的成员属于这个类本身,而不属于这个类的实例

    • 类相关

    • 类变量 (静态变量)

    • 类方法 (静态方法)

  • 没有 static 修饰的成员属于这个类的实例,而不属于这个类

    • 实例相关
    • 实例变量 (非静态变量)
    • 实例方法 (非静态方法)
  • 调用方式

    • 类.类变量
    • 类.类方法
    • 实例.类变量
    • 实例.类方法
    • 实例.实例变量
    • 实例.实例方法
成员变量

对象的作用:

1. 访问实例变量

[修饰符] 类型 成员变量名 [ = 默认值 ]
  • 修饰符
    • public 、protected 、private (最多只能出现其一)
    • final 、static (可与上面组合)
    • 或省略
  • 类型
    • 基本类型
    • 引用类型
  • 成员变量名
    • 一个合法的标识符
    • 由有意义的英文单词连缀而成
    • 不得有分隔符
    • 第一个单词首字母小写
    • 后面每个单词首字母大写
    • 其他皆小写
  • 可以指定默认值
方法

对象的作用:

2. 调用实例方法

[修饰符] 返回值类型 方法名(0 ~ n 个形参类型 形参名)
{
    //0 ~ n 个可执行语句
}
  • 修饰符
    • public 、protected 、private (最多只能出现其一)
    • final 、abstract (最多只能出现其一)
    • static (可与上面组合)
    • 或省略
  • 返回值类型
    • void
    • 基本类型 + return
    • 引用类型 + return
  • 方法名
    • 一个合法的标识符
    • 与成员变量名命名规则相同
    • 通常建议以英文动词开头
  • 形参列表
    • 英文逗号 , 隔开
    • 谁调用方法
    • 谁赋值形参
构造器

定义一个类,就是为了重复创建该类的实例对象

[修饰符] 构造器名(0 ~ n 个:形参类型  形参名)
{
    //0 ~ n 个可执行语句
}
  • 修饰符
    • public 、protected 、private(最多只能出现其一)
    • 或省略
  • 构造器名
    • 必须和类名相同
  • 形参列表
    • 和定义方法形参列表的格式完全相同
  • 构造器不能声明返回值类型
    • Java 通过 new 关键字来调用构造器
    • 并返回该类的实例对象
    • 即构造器的返回值类型总是当前类
    • 但这种返回机制是隐式的
    • 无须使用 return 语句显式返回
    • 因此不要显式声明返回类型为该类类型
    • 也不要使用 void 声明没有返回值
    • 如果声明了返回值类型或有 void 声明
    • 将被当作一个方法来处理
  • 构造器是一个类创建对象的根本途径
    • 如果没有为一个类编写构造器
    • 系统会为该类提供一个默认的构造器
对象的 this 引用

this 关键字可以代表任何对象,其最大的作用也基于此:

让类中的一个方法访问该类中的另一个方法或成员变量

方法中

引用调用该方法的对象

public class HelloWorld
{
       public void A()   
	   {
	          System.out.println("a");
	   }
	   
	   public void B()       
	   {
	          HelloWorld h = new HelloWorld();
			  h.A();
			  
			  
	          System.out.println("b");
	   }
	 
       public static void main(String[] args)
       {	 
	          HelloWorld h1 = new HelloWorld();
			  h1.B();
			   
       }
}





public class HelloWorld
{
       public void A()   
	   {
	          System.out.println("a");
	   }
	   
	   public void B()       
	   {
			  this.A();
              
			  
	          System.out.println("b");
	   }
	 
       public static void main(String[] args)
       {	 
	          HelloWorld h1 = new HelloWorld();
			  h1.B();
			  		 
	  }
}
  • this 关键字可以省略

  • static 修饰的方法中使用 this 关键字时:

    • 类方法可以由类本身来调用

    • this 将无法指向合适的对象

    • 类方法中不能使用 this 引用

    • 所以类方法不能直接访问实例方法

不可省略
public class HelloWorld
{
       public int a = 18;        
	    
	   public void A()  
       {
	          int a  = 0;           //局部变量和成员变量同名
			  
              System.out.println(a);
              System.out.println(this.a);			  
			  
	   } 
	   
       public static void main(String[] args)
       {	 
			  HelloWorld h = new HelloWorld();
			  h.A();
		      
	   }
}
  • 大部分时候,实例方法访问其他方法、成员变量时可以省略 this
  • 如果方法里有个局部变量和成员变量同名
  • 程序又需要在该方法中访问这个被覆盖的成员变量
  • 则必须显式使用 this 前缀
主调陷阱

Java 有一个让人极易混淆的语法——允许使用实例对象来调用 static 修饰的成员变量、方法——但在底层机制中还是由该实例对象所属的类本身作为主调者来调用

public class HelloWorld
{
       public void A()   
	   {
	          System.out.println("a");
	   }
	 
       public static void main(String[] args)
       {	 
	          A();
			  
	   }
}




public class HelloWorld
{
    private static void a()
	{
		System.out.println(1);
	}
	private void b()
	{
		System.out.println(2);
	}
	
	public static void main(String[] args)
	{
		   HelloWorld h = null;
		   
        
           h.a();
		   h.b();
		   
	 }
}
  • 如果调用 static 修饰的成员时省略了前面的主调
    • 默认使用类作为主调
  • 如果调用没有 static 修饰的成员时省略了前面的主调
    • 默认使用 this 作为主调
构造器中

引用该构造器正在初始化的对象

public class HelloWorld
{
       public int a;        
	    
	   public HelloWorld()  
       {
	          int a  = 0;     //局部变量和成员变量同名
			
			  this.a = 18;    
			  
	   } 
	   
       public static void main(String[] args)
       {	 
	          System.out.println(new HelloWorld().a);
		      
	   }
}
  • 与实例方法类似
  • 大部分时候,构造器访问其他方法、成员变量时可以省略 this
  • 如果构造器里有个局部变量和成员变量同名
  • 程序又需要在构造器中访问这个被覆盖的成员变量
  • 则必须显式使用 this 前缀
this 作为返回值

可以像访问普通引用变量一样来访问 this 引用

public class HelloWorld
{
       public int a;        
	    
	   public HelloWorld A()  
       {
	           a++;
               
           
			   return this;
               
	   } 
	   
       public static void main(String[] args)
       {	 
			  HelloWorld h = new HelloWorld();
			  h.A()
               .A()
               .A()
               .A()
               .A();   
			  System.out.println(h.a);
		      
	   }
}

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/970390.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号