【Java】this、static、代码块、包

发布于：2024-05-19 ⋅ 阅读:(28) ⋅ 点赞:(0)

this关键字 用法：

（1）this可以修饰属性：

总结：当属性名字和形参发生重名的时候，或者  属性名字 和局部变量重名的时候，都会发生就近原则，所以如果我要是直接使用变量名字的话就指的是离的近的那个形参或者局部变量，这时候如果我想要表示属性的话，在前面要加上：this.修饰

如果不发生重名问题的话，实际上你要是访问属性也可以省略this.

  1. package com.star4;
  3. /**
  4.  * @Auther: Starshine
  5.  */
  6. public class Person {
  7.     //属性
  8.     int age;
  9.     String name;
  10.     double height;
  11.     //空构造器
  12.     public Person(){
  14.     }
  15.     //有参构造器
  16.     public Person(int age,String name,double height){
  17.         this.age = age;
  18.         this.name = name;
  19.         this.height = height;
  20.     }
  21.     //方法：
  22.     public void eat(){
  23.         int age = 10;
  24.         System.out.println(age);//就近原则，age指的是离它近的age--》局部变量的age
  25.         System.out.println(this.age);//这里指代的就是属性的age
  26.         System.out.println("我喜欢吃饭");
  27.     }
  28. }

（2）this修饰方法：

总结：在同一个类中，方法可以互相调用，this.可以省略不写。

  1. package com.star4;
  3. /**
  4.  * @Auther: Starshine
  5.  */
  6. public class Person {
  7.     //属性
  8.     int age;
  9.     String name;
  10.     double height;
  11.     //空构造器
  12.     public Person(){
  14.     }
  15.     //有参构造器
  16.     public Person(int age,String name,double height){
  17.         this.age = age;
  18.         this.name = name;
  19.         this.height = height;
  20.     }
  21.     //方法：
  22.     /*public void eat(){
  23.         int age = 10;
  24.         System.out.println(age);//就近原则，age指的是离它近的age--》局部变量的age
  25.         System.out.println(this.age);//这里指代的就是属性的age
  26.         System.out.println("我喜欢吃饭");
  27.     }*/
  29.     public void play(){
  30.         /*this.*/eat();
  31.         System.out.println("上网");
  32.         System.out.println("洗澡");
  33.     }
  35.     public void eat(){
  36.         System.out.println(/*this.*/age);
  37.         System.out.println("吃饭");
  38.     }
  39. }

（3）this可以修饰构造器：

总结：同一个类中的构造器可以相互用this调用，注意：this修饰构造器必须放在第一行

  1. package com.star4;
  3. /**
  4.  * @Auther: Starshine
  5.  */
  6. public class Person {
  7.     //属性
  8.     int age;
  9.     String name;
  10.     double height;
  11.     //空构造器
  12.     public Person(){
  14.     }
  15.     //有参构造器
  16.     public Person(int age,String name,double height){
  17.         this(age,name);
  18.         this.height = height;
  20.     }
  21.     public Person(int age,String name){
  22.         this(age);
  23.         this.name = name;
  24.     }
  25.     public Person(int age){
  26.         this.age = age;
  27.     }
  28.     //方法：
  29.     /*public void eat(){
  30.         int age = 10;
  31.         System.out.println(age);//就近原则，age指的是离它近的age--》局部变量的age
  32.         System.out.println(this.age);//这里指代的就是属性的age
  33.         System.out.println("我喜欢吃饭");
  34.     }*/
  36.     public void play(){
  37.         /*this.*/eat();
  38.         System.out.println("上网");
  39.         System.out.println("洗澡");
  40.     }
  42.     public void eat(){
  43.         System.out.println(/*this.*/age);
  44.         System.out.println("吃饭");
  45.     }
  46. }
static

【1】static可以修饰：属性，方法，代码块，内部类。

【2】static修饰属性；

  1. package com.star5;
  3. /**
  4.  * @Auther: Starshine
  5.  */
  6. public class Test {
  7.     //属性：
  8.     int id;
  9.     static int sid;
  11.     //这是一个main方法，是程序的入口：
  12.     public static void main(String[] args) {
  13.         //创建一个Test类的具体的对象
  14.         Test t1 = new Test();
  15.         t1.id = 10;
  16.         t1.sid = 10;
  18.         Test t2 = new Test();
  19.         t2.id = 20;
  20.         t2.sid = 20;
  22.         Test t3 = new Test();
  23.         t3.id = 30;
  24.         t3.sid = 30;
  26.         //读取属性的值：
  27.         System.out.println(t1.id);
  28.         System.out.println(t2.id);
  29.         System.out.println(t3.id);
  31.         System.out.println(t1.sid);
  32.         System.out.println(t2.sid);
  33.         System.out.println(t3.sid);
  35.     }
  36. }

内存分析：

一般官方的推荐访问方式：可以通过类名.属性名的方式去访问：

static修饰属性总结：

（1）在类加载的时候一起加载入方法区中的静态域中

（2）先于对象存在

（3）访问方式： 对象名.属性名    类名.属性名（推荐）

static修饰属性的应用场景：某些特定的数据想要在内存中共享，只有一块 --》这个情况下，就可以用static修饰的属性

  1. package com.star5;
  3. /**
  4.  * @Auther: Starshine
  5.  */
  6. public class StarStudent {
  7.     //属性：
  8.     String name;
  9.     int age;
  10.     static String school;
  12.     //这是一个main方法，是程序的入口：
  13.     public static void main(String[] args) {
  14.         StarStudent.school = "马士兵教育";
  15.         //创建学生对象：
  16.         StarStudent s1 = new StarStudent();
  17.         s1.name = "张三";
  18.         s1.age = 19;
  19.         //s1.school = "马士兵教育";
  21.         StarStudent s2 = new StarStudent();
  22.         s2.name = "李四";
  23.         s2.age = 21;
  24.         //s2.school = "马士兵教育";
  26.         System.out.println(s2.school);
  31.     }
  33. }

属性：

静态属性 （类变量）

非静态属性（实例变量）

【3】static修饰方法；

  1. package com.star5;
  3. /**
  4.  * @Auther: Starshine
  5.  */
  6. public class Demo {
  7.     int id;
  8.     static int sid;
  10.     public void a(){
  11.         System.out.println(id);
  12.         System.out.println(sid);
  13.         System.out.println("------a");
  14.     }
  15.     //1.static和public都是修饰符，并列的没有先后顺序，先写谁后写谁都行
  16.     static public void b(){
  17.         //System.out.println(this.id);//4.在静态方法中不能使用this关键字
  18.         //a();//3.在静态方法中不能访问非静态的方法
  19.         //System.out.println(id);//2.在静态方法中不能访问非静态的属性
  20.         System.out.println(sid);
  21.         System.out.println("------b");
  22.     }
  24.     //这是一个main方法，是程序的入口：
  25.     public static void main(String[] args) {
  26.         //5.非静态的方法可以用对象名.方法名去调用
  27.         Demo d = new Demo();
  28.         d.a();
  29.         //6.静态的方法可以用   对象名.方法名去调用  也可以 用  类名.方法名 （推荐）
  30.         Demo.b();
  31.         d.b();
  32.       
  33.     }
  34. }
代码块

【1】类的组成：属性，方法，构造器，代码块，内部类

【2】代码块分类：普通块，构造块，静态块，同步块（多线程）

【3】代码：

  1. package com.star6;
  3. /**
  4.  * @Auther: Starshine
  5.  */
  6. public class Test {
  7.     //属性
  8.     int a;
  9.     static int sa;
  11.     //方法
  12.     public void a(){
  13.         System.out.println("-----a");
  14.         {
  15.             //普通块限制了局部变量的作用范围
  16.             System.out.println("这是普通块");
  17.             System.out.println("----000000");
  18.             int num = 10;
  19.             System.out.println(num);
  20.         }
  21.         //System.out.println(num);
  22.         //if(){}
  23.         //while(){}
  24.     }
  25.     public static void b(){
  26.         System.out.println("------b");
  27.     }
  29.     //构造块
  30.     {
  31.         System.out.println("------这是构造块");
  32.     }
  33.     //静态块
  34.     static{
  35.         System.out.println("-----这是静态块");
  36.         //在静态块中只能方法：静态属性，静态方法
  37.         System.out.println(sa);
  38.         b();
  39.     }
  42.     //构造器
  43.     public Test(){
  44.         System.out.println("这是空构造器");
  45.     }
  46.     public Test(int a){
  47.         this.a = a;
  48.     }
  51.     //这是一个main方法，是程序的入口：
  52.     public static void main(String[] args) {
  53.         Test t = new Test();
  54.         t.a();
  56.         Test t2 = new Test();
  57.         t2.a();
  58.     }
  62. }

总结：

（1）代码块执行顺序：

最先执行静态块，只在类加载的时候执行一次，所以一般以后实战写项目：创建工厂，数据库的初始化信息都放入静态块。

一般用于执行一些全局性的初始化操作。

再执行构造块，（不常用）

再执行构造器，

再执行方法中的普通块。

包，import

【1】生活案例：

邮寄快递：中国.北京.通州区.****小区.5号楼.3单元.101房.赵珊珊

历史：常山赵子龙

【2】包的作用：

为了解决重名问题（实际上包对应的就是盘符上的目录）

解决权限问题

【3】创建包：

包名定义：

（1）名字全部小写

（2）中间用.隔开

（3）一般都是公司域名倒着写 ：  com.jd   com.star

（4）加上模块名字：

com.jd.login    com.jd.register

（5）不能使用系统中的关键字：nul,con,com1---com9.....

（6）包声明的位置一般都在非注释性代码的第一行：

【4】导包问题：

  1. //声明包：
  2. package com.star7;
  4. import com.star2.Person; //导包：就是为了进行定位
  6. import java.util.Date;
  8. /**
  9.  * @Auther: Starshine
  10. */
  11. public class Test {
  12.     //这是一个main方法，是程序的入口：
  13.     public static void main(String[] args) {
  14.         new Person();
  15.         new Date();
  16.         new java.sql.Date(1000L);//在导包以后，还想用其他包下同名的类，就必须要手动自己写所在的包。
  17.         new Demo();
  18.     }
  19. }

总结：

（1）使用不同包下的类要需要导包： import **.*.*;  例如：import java.util.Date;

（2）在导包以后，还想用其他包下同名的类，就必须要手动自己写所在的包。

（3）同一个包下的类想使用不需要导包，可以直接使用。

（4）在java.lang包下的类，可以直接使用无需导包：

（5）IDEA中导包快捷键：alt+enter  

        可以自己设置自动导包

（6）可以直接导入*：

【5】在Java中的导包没有包含和被包含的关系：

设置目录平级的格式（不是包含和被包含的显示）：

【6】静态导入：

  1. package com.star11;
  2. //静态导入：
  3. import static java.lang.Math.*;
  4. //导入：java.lang下的Math类中的所有静态的内容
  5. /**
  6.  * @Auther: Starshine
  7.  */
  8. public class Test {
  9.     //这是一个main方法，是程序的入口：
  10.     public static void main(String[] args) {
  11.         System.out.println(random());
  12.         System.out.println(PI);
  13.         System.out.println(round(5.6));
  14.     }
  15.     //在静态导入后，同一个类中有相同的方法的时候，会优先走自己定义的方法。
  16.     public static int round(double a){
  17.         return 1000;
  18.     }
  19. }

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布