Java之static关键字、block、封装javaBean、package、import、extends以及四种修饰符的初步了解

最新推荐文章于 2023-03-24 17:34:09 发布
最新推荐文章于 2023-03-24 17:34:09 发布
阅读量179 收藏
点赞数
分类专栏： Java 文章标签： Java 编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45801172/article/details/102762054
版权

this关键字

定义

​ 在类的方法定义中使用this关键字代表使用该方法的引用.

​ this即"自己",代表对象本身,谁调用代表谁.在成员方法中或构造器中隐式的传递.

this的两种用法

  1. 构造器中

    1. 作用:可以调用本类中的其他构造器
    2. 具体用法可参照2.2的中的代码

  2. 成员变量与局部变量

    1. 作用:当成员变量与局部变量同名时,可以采用this关键字代指当前对象的属性(即成员变量)

    2. 具体用法:

      public class Computer01 {
	public String brand;
	public double price;
	public String color;
    //this的用法:代指当前对象的属性值 
	public Computer01(String brand,double price){
		this.brand=brand;//this.brand是当前对象的属性名,brand是传入值(局部变量)
		this.price=price;
		System.out.println("带参构造器1");
	}
	public Computer01(String brand,double price,String color){
		this(brand,price);    //this的用法:调用构造器1
		this.color=color;
		System.out.println("带参构造器2");
	}		
}

注意事项

  1. this在构造器中只能放在首行
  2. 利用this关键字可以避免属性和形参 局部变量同名,发生就近原则.
    1. 就近原则:在此例中就是当局部变量与成员变量中就会先找局部变量.
  3. this([实参列表]):可以调用其他构造器
  4. this可以看做是一个变量,它的值是当前对象的引用
  5. this不能出现在被static修饰的内容中
    1. 因为this代表对象的引用,而static是在类加载的时候而此时对象还未创建.
  6. 构造方法不能相互调用,此时会造成类似死循环的效果,会报错.
  7. 当只有成员变量时,默认省略了this关键字.

static关键字

含义

​ 在类中，用 static 声明的成员变量为静态成员变量，它为该类的公用变量，在第一次使用时被初始化，对于该类的所有对象来说，static 成员变量只有一份。凡是静态的都是属于类的，与对象无关的，先于对象存在的。可用于修饰属性、方法、块。

解释:

  1. static声明的修饰的成员变量、成员方法、块都是静态成员变量、成员方法、块。
  2. 静态在第一次使用的时候(即类加载时)就被初始化,先于对象存在。

调用方式(两种)

  1. 类名.静态属性|方法名();
  2. 对象.静态属性|方法名();

注意:

  1. 静态方法只能使用静态内容;即被static修饰的方法只能使用被static修饰的内容
  2. 类的所有对象都共用静态的内容
  3. 静态内容在类的第一次加载时就被初始化
  4. 非静态内容可以使用非静态内容也可以使用静态内容
public class StaticDemo01 {
	static int id=5;//静态
	int age=10;//成员变量
		public static void main(String[] args) {
		//类中,静态变量与成员变量的使用区别	
			System.out.println(StaticDemo01.id);//可以省略类名 5
			System.out.println(id);//与上行一致 5
//			System.out.println(age);//不能直接使用成员变量,必须跟随对象使用
			StaticDemo01 staticDemo01=new StaticDemo01();
			System.out.println(staticDemo01.age);//这个就可以使用了 10
		
		//也可以采用对象.类变量 获取类变量 的值
			System.out.println(staticDemo01.id);//5
			//此行时,id=5,age=10;
			staticDemo01.change();
			
			System.out.println(id);//7
			System.out.println(staticDemo01.age);//15		
			//局部变量的使用
			String name="";
			System.out.println(name);				
		}
		//创建一个方法
		public void change(){
			id++;//6
			age+=5;//11
			StaticDemo01 staticDemo01=new StaticDemo01();
			id++;//7
			staticDemo01.age+=2;//11
			System.out.println(id+"---"+staticDemo01.age);//7 12
			System.out.println(id+"---"+this.age);//7 11
		}	
}

block块

分类

  1. {}定义在方法中 ->局部代码块|普通语句块 执行时间:方法调用时
  2. {}定义在类中方法外 ->构造块 执行时间:创建对象的时候
  3. static{}定义在类中方法外 ->静态 执行时间:类第一次加载的时候

其执行顺序如下 static -> main主方法 ->构造块 ->构造块

示例

public class BlockDemo01 {
	static int a=45;
	int b=30;
	public static void main(String[] args) {
		System.out.println("主方法");
		BlockDemo01 b12=new BlockDemo01();
	}
	//类中方法外
	{
		System.out.println("构造块2");
		System.out.println(a);
		/*
		 * 创建对象分为三步(在堆中)
		 * 	一是开辟空间,携带属性进入(如果没有值,则携带默认值,有值就是值本省)
		 * 	在第一步的时候,已经携带属性b=3进入内存中,执行构造块
		 * 	二是采用构造器初始化变量(第一次赋值)
		 * 	三是返回内存中的位置 
		 */
		System.out.println(b);
	}
	{
		System.out.println("构造块3");
	}
	{
		System.out.println("构造块4");
	}
	static{
		System.out.println("静态块1");
		System.err.println(a);
		//由于静态是在对象创建之前,所以无法使用b
//		System.out.println(b);
		BlockDemo01 b12=new BlockDemo01();
		System.out.println(b12.b);
	}
	static{
		System.out.println("静态2");
	}
	static{
		System.out.println("静态3");
	}
}

封装javaBean

​ 封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和行为（或方法）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。

优点：

​ A:隐藏实现细节，提供公共的访问方式

​ B:提高代码的复用性

​ C:提高代码的安全性

注意：私有是封装，不能说封装是私有,封装不仅仅表示为私有。私有只是封装的一种体现，方法是封装的一种体现。

javaBean编码规则：

  1. javaBean 必须声明为 public class，这样才能够被外部所访问；
  2. 一个 JavaBean中至少存在一个无参构造方法
  3. 类中所有的属性都必须封装，即：使用 private 声明；
  4. 为封装的私有属性提供公共的 setter、getter 方法

Garbage Collection 垃圾回收机制

  1. 程序员无权调用垃圾回收器。
  2. 程序员可以通过 System.gc()。通知 GC 运行，但是 JAVA规范并不能保证立刻运行。
  3. finalize 方法，是 JAVA 提供给程序员用来释放对象或资源的方法，但是尽量少用

示例：

public class GCDemo01 {
	public static void main(String[] args) {
		//匿名对象 :没有名字的对象
		//只能在当前行使用一次
		GCDemo01 g=new GCDemo01();
		System.gc(); //通知
		System.out.println("123");
		System.out.println("123");
		System.out.println("123");
		System.out.println("123");
		
	}
	
	public void haha(){
		System.out.println("哈哈哈哈,最近还是先吃火锅~~~");
	}
	
	@Override
	protected void finalize() throws Throwable {
		System.out.println("over....");
	}
}

package和import语句

package语句

​ 为了便于管理大型软件系统中数目众多的类，解决类的命名冲突问题，Java 引入包(package)机制，提供类的多重类命名空间。

​ 一般的命名为:公司域名倒写+功能名|模块名。例如：package com.shsxt.import06;

​ package 语句作为 Java 源文件的第一条语句，指明该文件中定义的类所在的包。（若缺省该语句，则指定为无名包）。

​ **注意:**不要定义与 jdk 相同的包，相同的类， 否则会引起很多你觉得莫名其妙的问题 。

​ 如果一个类存在包名，则在使用该类时，必须使用全额限定名（简称全名或完整类名，com.shsxt.MyClass），编译器才能找到该类；也可以使用 import 在文件的开头引入要使用到的类。

import

  1. 类的上面进行导包:
  2. import 关键字 标识当前所使用的这个类的位置
  3. 这个包下的所有的类,如果有使用都可以引用
  4. 会降低编译效率,不会降低运行效率
  5. 静态导入: 只导入静态的内容
  6. 如果不使用import可以在使用的位置指明类的位置,包名+类名

**注意:**不要与jdk的 包名,类名出现相同情况

示例

import static java.lang.Math.PI;
import static java.lang.Math.sqrt;
import java.util.*;
public class ImportDemo06 {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		Random ran=new Random();
		
		System.out.println(PI);
		System.out.println(PI);
		System.out.println(PI);
		System.out.println(PI);
		
		System.out.println(sqrt(4));
	}
}

extends继承

继承：子承父业

java 中使用 extends 关键字实现类的继承机制，语法规则：

class [extends ]{}

[ ]代表可有可有

作用

​ 实现代码的复用，延续+扩展父类信息，子类可以扩展自己的内容
通过继承，子类自动拥有了基类的所有成员（成员变量和成员方法）。
​ Java 只支持单继承，不允许多继承：一个子类只能拥有一个基类，一个基类可以派生出多个子类

​ 单继承的优点: 简单
​ 单继承的缺点: 不便于后期维护

示例

public class ExtendsDemo01 {
	public static void main(String[] args) {
		Teacher th=new Teacher();
		th.subject="java";
		th.teach();
		th.name="因为";
		th.age=17;
		
		Student s=new Student();
		s.hometown="杭州";
		s.study();
		s.name="马云";
		s.age=50;
		s.sleep();
		
	}
}

//父类
class Person{
	String name;
	int age;
	
	public void sleep(){
		System.out.println("休息");
	}
}

//子类  教师类
class Teacher extends Person{
	
	String subject;
	
	public Teacher() {
		// TODO Auto-generated constructor stub
	}
	
	public void teach(){
		System.out.println("每天上课,边讲课边说rap");
	}
	
	
}

//学生类
class Student extends Person{
	String hometown;
	
	public Student() {
		// TODO Auto-generated constructor stub
	}
	public void study(){
		System.out.println("学习敲代码,敲代码使我快乐~~~");
	}
	
}

修饰符

权限修饰符: 定义对象中内容的可访问范围

本类同包不同包子类不同包其他类
publicYYYY
protectedYYY
default（默认）YY
privateY

以上权限修饰符: 都只能修饰成员,不能修饰局部
能够修饰类的只有default|public

protected:
1.同包类,本类中直接使用
2.不同同包下的子类,必须通过继承关系才能使用

同类下

public class Modifier01 {
	//分别定义不同的修饰符的变量
	public String name="小王";
	protected String mood="unhappy";
    //默认是defalut 不能显式调用,语法规定
	int age=520;
	private double money=150;
	//分别定义不同修饰符的方法
	public void method01(){
		System.out.println("public方法");
	}
	protected void method02(){
		System.out.println("protected方法");
	}
	void method03(){
		System.out.println("默认default");
	}
	private void method04(){
		System.out.println("private方法");
	}
	
	public static void main(String[] args) {
	//在本类中,四种修饰符都可以使用	
		Modifier01 m=new Modifier01();
		m.name="小王2";
		m.mood="开心2";
		m.age=521;
		m.money=1563;
		m.method01();
		m.method02();
		m.method03();
		m.method04();	
	}
}

同包下其他类

package com.shsxt.modifier01;
public class Modifier02 {
	public static void main(String[] args) {
	//在本类中,四种修饰符都可以使用	
		Modifier01 m=new Modifier01();
		m.name="小王2";
		m.mood="开心2";
		m.age=521;
        //私有的不能在除本类外使用,使用范围最小
//		m.money=1563;
		m.method01();
		m.method02();
		m.method03();
//		m.method04();	
	}
}

不同包的子类

package TestModifier;
import com.shsxt.modifier01.Modifier01;
public class Modifier03 extends Modifier01 {
	public static void main(String[] args) {
	//在不同包子类中,四种修饰符可以使用的方法	
		Modifier01 m=new Modifier01();
		m.name="小王2";
		Modifier03 m1=new Modifier03();
        //protected修饰的内容,无法直接调用
        //必须通过新建子类对象,通过子类对象去调用该内容
		System.out.println(m1.mood);
//		m.mood="开心2";
//		m.age=521;
//		m.money=1563;
		m.method01();
		m1.method02();
//		m.method03();
//		m.method04();	
	}
}

不同包的其他类

package TestModifier;
import com.shsxt.modifier01.Modifier01;
public class Modifier04 {
	public static void main(String[] args) {
	//在本类中,四种修饰符都可以使用	
		Modifier01 m=new Modifier01();
		m.name="小王2";
//		m.mood="开心2";
//		m.age=521;
//		m.money=1563;
		m.method01();
//		m.method02();
//		m.method03();
//		m.method04();	
	}
}
weixin_45801172
关注
专栏目录
Java面向对象基础总结
qq_41784749的博客
02-28 894
基础知识 面向过程(POP) 与 面向对象(OOP) 二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。 面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等 bJavaBean JavaBean是一种Java语言写成的可重用组件。 所谓javaBean，是指符合如下标准的Java类： 类是公共的 有一个无参的公共的
5、Java类成员、面向对象的基本特征
Mr_Llz的博客
03-10 4275
> 类的5个成员：属性、方法、构造器、代码块、内部类 > Java的3大基本特性：封装、继承、多态 > ----封装：安全、简单方便、对使用者隐藏实现细节 > ----继承：代码复用、扩展，表示is-a的关系 > ----多态：提高代码灵活性，增强代码功能
详解JAVA中implement和extends的区别
08-29
主要介绍了详解JAVA中implement和extends的区别的相关资料,extends是继承接口，implement是一个类实现一个接口的关键字，需要的朋友可以参考下
菜鸡自学JAVA坎坷路day.6（import的使用，extends，override）
qq_38053395的博客
05-14 329
1.包机制（package）：域名倒着写。实例说明如下：/** * import的使用方法 * author ：Wang * * */ package cn.wang;//包必须是非注释语句的第一句 import project02.user;//先是包名后是类名"包名.*"是全部导入，导入的这个包必须是public类型的才行 同一个包内可以直接使用里面的类 import j...
Java的继承（extends）和实现（implements）
最新发布
03-24 210
Java继承和实现
JAVA关键字-this，static，package，block，private，JavaBean
Wyaoguang的博客
11-11 366
一·this关键字 1·作用： （1）用于指代new的对象； （2）在构造器的首行调用本类中的其他构造器，使用this（参数列表） ——匿名类：指在new关键字创建对象时，不对其进行变量名称的给定，方便灵活但只能在该行使用一次； （3）在构造器中使用时，不能够让多个构造器之间通过this关键字进行相互的调用； （4）用于区分同名的成员变量与局部变量——调用时遵循就近原则 2·this指代对象的地址 3·在成员方法中this默认指代new调用成员方法的对象；在构造器中this默认指代new调用
java-----Static和import关键字、块（block）、封装和继承
qq_41899248的博客
06-02 375
静态关键字static   static也是一种修饰符，修饰变量的时候叫静态变量也叫类变量，他是成员修饰符，不能修饰局部变量。修饰方法的时候叫做静态方法也叫类方法。 调用 ...
JAVA面试、笔试题
weixin_45689111的博客
04-20 1万+
@[TOC]目录 JAVA面试、笔试题 @目录 一、 CoreJava部分 7 1. java中有哪些基本类型？ 7 2. java反射 7 3. 易错,理解题 7 4. Java有几种创建对象的方法? 8 java为什么能够跨平台运行？ 8 整型数据转换成字符串的方式？ 8 String是基本数据类型吗？我可不可以写个类继承于String？ 8 谈谈&和&&的区别？ 8 Switch语句里面的条件可不可以是byte、long、String？使用时候还应注意什么？ 8 short
Java面向对象
qq_51430949的博客
11-17 374
1、面向对象 1.1 定义 思想、思维方式 、思考问题的角度 1.2 优点 复杂的问题简单化，更贴近现实生活中人类的思维角度 1.3 面向对象与面向过程的区别 ①面向过程就是分析出解决问题所需要的步骤，然后用函数实现、调用，关注过程； ②面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为，关注结果。 ③面向过程适用于执行者,面向对象适用于管理者 2、类 2.1 类的定义 : ​ public class 类名{ ​
Java八股文
热门推荐
earn_est的博客
03-07 1万+
我是2022届双非软件工程应届生，目前在准备秋招，总结了一篇不错的八股文，如果你正好需要可以关注一下，共同学习；超链接如下： Java后端八股文（CSDN不再同步） 语雀地址 Hello, interviewer. My name is . I graduated from Zhengzhou University of Light Industry, majoring in software engineering and I will graduate next year. I have exper
初识JAVA07:自定义类、构造方法、this关键字、static关键字、block关键字、Debug调试工具
weixin_43980278的博客
06-13 140
JAVA面向对象01面向对象自定义类构造方法this关键字static关键字block关键字Debug调试工具 面向对象 面向对象和面向过程的区别: ​ 面向过程: ​ 关注"我应该如何实现?"按照步骤一步一步实现就可以了 ​ 面向对象: ​ 关注"我应该找谁来完成?"这个谁就是对象,对象如何完成不关注 ​ 面向对象依赖面向过程 面向对象思想的好处: ​ 1.更符合显示生活中人们的思维 ​ 2.面向对象更贴合管理者的思维角度,面向过程更贴合执行者的思维角度 ​ 3.面向对象可以将复杂的问题简单化 如何使
【java基础知识】——extends 与 implement 区别
学习如逆水行舟，不进则退
04-04 2046
简单说： 1.extends是继承父类，只要那个类不是声明为final或者那个类定义为abstract的就能继承， 2.JAVA中不支持多重继承，但是可以用接口来实现，这样就要用到implements， 3.继承只能继承一个类，但implements可以实现多个接口，用逗号分开就行了 , 比如 class A extends B implements C,D,E 术语话来说： extends 继承类；implements 实现接口。 类和接口是不同的：类里是有程序实现的；而接口无程序实现，只可以预定义方法
Java中继承（extend）的用法
张子又
12-13 6794
继承：从多个具体的子类中抽取出相同的属性以及行为，组合成一个新的父类 然后让这些具体的子类继承这个父类 继承关键字：extends 语法格式 修饰符 class 子类 extends 父类 父类中公开的属性以及方法都能被子类继承 注意：私有的属性不能被继承 私有的方法不能被继承 注意：父类只能有1个，子类可以有多个 java是一种单继承语言，但是它支持继承链 C++是多继承 继承的优点： 1...
java类继承代码_Java类与继承
weixin_39794385的博客
02-15 737
Java：类与继承对于面向对象的程序设计语言来说，类毫无疑问是其最重要的基础。抽象、封装、继承、多态这四大特性都离不开类，只有存在类，才能体现面向对象编程的特点，今天我们就来了解一些类与继承的相关知识。首先，我们讲述一下与类的初始化相关的东西，然后再从几个方面阐述继承这一大特性。以下是本文的目录大纲：一.你了解类吗？二.你了解继承吗？三.常见的面试笔试题若有不正之处，请多多谅解并欢迎批评指正。请尊...
构造器、关键字this、静态static、代码块block、调试debug
qq_43658407的博客
03-10 345
1. 构造器 new关键字做的事情: 1.在堆中为对象开辟空间,成员变量跟随对象进入到堆内存并附默认值。 2.调用构造器为对象初始化信息。 3.将地址返回给引用。 构造器|构造函数|构造方法 : 是一种特殊的方法。 作用: 为对象初始化信息,为对象的属性赋值,不是用来创建对象的,new能够创建对象。 调用: 只能跟随new一起使用。 定义: 修饰符 类名(参数){ 初始化信息代码; } 注意: 1.构造器可以实现重载。 2.如
java中Block代码块的四种用法 附带速记卡
null
10-11 5140
直接上速记卡 特别注意： 当有继承关系时，执行顺序为 父类静态代码块>子类静态代码块 >父类构造代码块>父类空构造>子类构造代码块>子类空构造 主要针对这个顺序，我们简单撸一个Code package Block; public class Fu { static int i; int j; static { i = 15; int i = ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值