Java中面向对象中的一些关键字的使用细节

墨殇离陌

已于 2022-07-05 22:33:55 修改

阅读量140

点赞数

分类专栏： Java 文章标签： java 面向对象

于 2022-07-05 22:33:27 首次发布

本文链接：https://blog.csdn.net/qq_36191374/article/details/125629521

版权

Java 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

四种访问权限修饰符

Java权限修饰符public、protected、（缺省）、private置于类的成员定义前，用来限定对象对该类成员的访问权限。

修饰符	类内部	同一个包	不同包的子类	同一个工程
private	yes
(缺省)	yes	yes
protected	yes	yes	yes
public	yes	yes	yes	yes

类中属性的使用

属性（成员变量） vs 局部变量
1.相同点：

	1.1  定义变量的格式：数据类型  变量名 = 变量值

```
	1.2 先声明，后使用
```

	1.3 变量都有其对应的作用域

2.不同点：
2.1 在类中声明的位置的不同
属性：直接定义在类的一对{}内
局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
2.2 关于权限修饰符的不同
属性：可以在声明属性时，指明其权限，使用权限修饰符。
常用的权限修饰符：private、public、缺省、protected —>封装性
局部变量：不可以使用权限修饰符。
2.3 默认初始化值的情况：

属性：类的属性，根据其类型，都有默认初始化值。
整型（byte、short、int、long）：0
浮点型（float、double）：0.0
字符型（char）：0 （或’\u0000’）
布尔型（boolean）：false

引用数据类型（类、数组、接口）：null

局部变量：没有默认初始化值。

意味着，我们在调用局部变量之前，一定要显式赋值。

特别地：形参在调用时，我们赋值即可。

2.4 在内存中加载的位置：

属性：加载到堆空间中（非static）
局部变量：加载到栈空间

JavaBean

JavaBean是一种Java语言写成的可重用组件。

所谓javaBean，是指符合如下标准的Java类：

类是公共的
有一个无参的公共的构造器
有属性，且有对应的get、set方法

用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP 页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。

public class JavaBean {
private String name; // 属性一般定义为private
private int age;
public JavaBean() {
	}
public int getAge() {
	return age;
	}
public void setAge(int a) {
	age = a;
	}
public String getName() {
	return name;
	}
public void setName(String n) {
	name = n;
	}
}

匿名对象

1.理解：我们创建的对象，没有显式的赋给一个变量名。即为匿名对象

2.特征：匿名对象只能调用一次。
3.使用：如下

public class InstanceTest {
	public static void main(String[] args) {
		Phone p = new Phone();
//		p = null;
		System.out.println(p);
		
		p.sendEmail();
		p.playGame();		
		//匿名对象
//		new Phone().sendEmail();
//		new Phone().playGame();
		
		new Phone().price = 1999;
		new Phone().showPrice();//0.0
		
		//**********************************
		PhoneMall mall = new PhoneMall();
//		mall.show(p);
		//匿名对象的使用
		mall.show(new Phone());		
	}
}
class PhoneMall{
	public void show(Phone phone){
		phone.sendEmail();
		phone.playGame();
	}	
}
class Phone{
	double price;//价格	
	public void sendEmail(){
		System.out.println("发送邮件");
	}
	public void playGame(){
		System.out.println("玩游戏");
	}	
	public void showPrice(){
		System.out.println("手机价格为：" + price);
	}	
}

this

this关键字的使用：
1.this可以用来修饰、调用：属性、方法、构造器
2.this修饰属性和方法：
    this理解为：当前对象  或 当前正在创建的对象
 2.1  在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是，通常情况下，我们都选择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
 2.2 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。
  但是，通常情况下，我们都选择省略"this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式
的使用"this.变量"的方式，表明此变量是属性，而非形参。 
3. this调用构造器
  	 ① 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器
     ② 构造器中不能通过"this(形参列表)"方式调用自己
     ③ 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)"
     ④ 规定："this(形参列表)"必须声明在当前构造器的首行
     ⑤ 构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器

继承性

一、继承性的好处：
  ① 减少了代码的冗余，提高了代码的复用性
  ② 便于功能的扩展
  ③ 为之后多态性的使用，提供了前提
  
二、继承性的格式： 
     class A extends B{}
     A:子类、派生类、subclass
     B:父类、超类、基类、superclass    
     2.1体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。
     	特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。
     只有因为封装性的影响，使得子类不能直接调用父类的结构而已。
     2.2 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。
     子类和父类的关系，不同于子集和集合的关系。
     extends：延展、扩展
 
三、Java中关于继承性的规定：
  	 1.一个类可以被多个子类继承。
     2.Java中类的单继承性：一个类只能有一个父类
     3.子父类是相对的概念。
     4.子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类
     5.子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法   
     
四、 1. 如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类
     2. 所有的java类（除java.lang.Object类之外）都直接或间接的继承于java.lang.Object类
     3. 意味着，所有的java类具有java.lang.Object类声明的功能。

super

super关键字的使用
  1.super理解为：父类的
  2.super可以用来调用：属性、方法、构造器
  3.super的使用：调用属性和方法 
    3.1 我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用
    父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
    3.2 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的
    使用"super.属性"的方式，表明调用的是父类中声明的属性。
    3.3 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。 
  4.super调用构造器
  	4.1  我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
    4.2 "super(形参列表)"的使用，必须声明在子类构造器的首行！
    4.3 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一，不能同时出现
    4.4 在构造器的首行，没有显式的声明"this(形参列表)"或"super(形参列表)"，则默认调用的是父类中空参的构造器：super()
    4.5 在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器

this和super的区别

	区别点	this	super
1	访问属性	访问本类中的属性，如果本类没有此属性则从父类中继续查找	直接访问父类中的属性
2	调用方法	访问本类中的方法，如果本类没有此方法则从父类中继续查找	直接访问父类中的方法
3	调用构造器	调用本类构造器，必须放在构造器的首行	调用父类构造器，必须放在子类构造器的首行

static

static关键字的使用
  
  1.static:静态的
  2.static可以用来修饰：属性、方法、代码块、内部类
  
  3.使用static修饰属性：静态变量（或类变量）
  	3.1 属性，按是否使用static修饰，又分为：静态属性  vs 非静态属性(实例变量)
  	实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的
非静态属性时，不会导致其他对象中同样的属性值的修改。
     静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。
  	3.2 static修饰属性的其他说明：
  		  ① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
           ② 静态变量的加载要早于对象的创建。
           ③ 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。          
           ④	 类变量 	实例变量
           类	 yes		no
          对象	yes		   yes
          
       3.3 静态属性举例：System.out; Math.PI;
  
  4.使用static修饰方法：静态方法
  		① 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
  		②			静态方法	非静态方法
           类		yes		no
           对象		yes		yes
  		③ 静态方法中，只能调用静态的方法或属性
         非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
  
  5. static注意点：
     5.1 在静态的方法内，不能使用this关键字、super关键字
     5.2 关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。
     
  6. 开发中，如何确定一个属性是否要声明为static的？
 		> 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
  		> 类中的常量也常常声明为static
  
     开发中，如何确定一个方法是否要声明为static的？
     	> 操作静态属性的方法，通常设置为static的
       > 工具类中的方法，习惯上声明为static的。 比如：Math、Arrays、Collections

final

final:最终的  
  1. final可以用来修饰的结构：类、方法、变量  
  2. final 用来修饰一个类:此类不能被其他类所继承。
           比如：String类、System类、StringBuffer类  
  3. final 用来修饰方法：表明此方法不可以被重写
  			比如：Object类中getClass(); 
  4. final 用来修饰变量：此时的"变量"就称为是一个常量
  	    4.1 final修饰属性：可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化
  		4.2 final修饰局部变量：
            尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值
            以后，就只能在方法体内使用此形参，但不能进行重新赋值。            
   static final 用来修饰属性：全局常量

abstract

abstract关键字的使用
  1.abstract:抽象的
  2.abstract可以用来修饰的结构：类、方法
  
  3. abstract修饰类：抽象类
  		> 此类不能实例化
       > 抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
       > 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作
  
  4. abstract修饰方法：抽象方法
  		> 抽象方法只有方法的声明，没有方法体
  		> 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
       > 若子类重写了父类中的所有的抽象方法后，此子类方可实例化
         若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰

interface

接口的使用
  1.接口使用interface来定义
  2.Java中，接口和类是并列的两个结构
  3.如何定义接口：定义接口中的成员
  		
  		3.1 JDK7及以前：只能定义全局常量和抽象方法
  			>全局常量：public static final的.但是书写时，可以省略不写
  			>抽象方法：public abstract的
  			
  		3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法（略）
  
  4. 接口中不能定义构造器的！意味着接口不可以实例化
  
  5. Java开发中，接口通过让类去实现(implements)的方式来使用.
     如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
     如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
     
  6. Java类可以实现多个接口   --->弥补了Java单继承性的局限性
    格式：class AA extends BB implements CC,DD,EE
    
  7. 接口与接口之间可以继承，而且可以多继承
  
  *******************************
  8. 接口的具体使用，体现多态性
  9. 接口，实际上可以看做是一种规范