java中静态的学习

最新推荐文章于 2023-05-24 18:16:05 发布
最新推荐文章于 2023-05-24 18:16:05 发布
阅读量401 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50551074/article/details/108684821
版权

1.学习目标：

1.1 String常用方法：

​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zkEcXZkp-1600514315806)(C:\Users\lenovo\Desktop\String常用方法.png)]

1.2String 类中 对substring/charArr/byteArr/replace的测试
                                                                       ```java

package StringTest;

public class Test {
public static void main(String[]args) {
String string=“abcdefg”;
String newStr= string.substring(0);//开始索引
System.out.println(newStr);//abcdefg
System.out.println("");
String newStr1=string.substring(1);
System.out.println(newStr1);//bcdefg
System.out.println("=");
String newStr2=string.substring(2);
System.out.println(newStr2);//cdefg
//截取字符串那个位置开始到结束
System.out.println("=");
String newStr3=string.substring(2, 3);
System.out.println(newStr3);//c
//截取字符串从那个位置开始到那个位置结束
System.out.println("");
char[]charArr=string.toCharArray();
System.out.println(charArr);
System.out.println("");
byte[]byteArr=string.getBytes();
System.out.println(byteArr);
System.out.println("====");
String str=“cd:ef:g”;
String newStr8=str.replace(":",“1” );//把满足条件的所有的符号都替换了
System.out.println(newStr8);
}

}

                                                                       ```

2.课堂笔记

2.1 静态：
2.1.1 怎么去统计创建对象的数量？

错误案例：

                                                           ```java

package StringTest;

public class Test1 {
private String name;
private int age;
public Test1(String name,int age) {
count++;
this.name=name;
this.age=age;
}
int count;
}

                                                           ```

    ```java

package StringTest;
//怎么去统计创建对象的数量？
//1.思路创建一个对象加一个
public class StudentTest {
public static void main(String[]args) {
func();
Test1 test=new Test1(“李三”,12);//
//test.count++;//1 count只属于某一个对象在调用过程中不会发生改变
Test1 test2=new Test1(“王五”,13);
//test2.count++;//1
System.out.println(test2.count);
}
public static void func() {

    Test1 test2=new Test1("张三",14);
   // test2.count++;//1
    //分析：分别创建了三个对象并且这三个对象都有自己的数据因此
    //count统计的只是test/test2/test3创建的它们自己的对象的统计并没有进行累加
    
 }

}

    ```

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MxG3BQ9i-1600514315807)(C:\Users\lenovo\Desktop\怎样统计创建对象错误案例.png)]

正确案例：

          ```java

package StringTest;

public class Test1 {
private String name;
private int age;
static int count;//属于类的不属于某一个具体的对象或者
//说是属于所有对象的
//静态成员变量 共享
public Test1(String name,int age) {
count++;//当创建对象的时候会进行累加但是只是加自己的
//如果重新创建一个对象那个会重新进行累加
this.name=name;
this.age=age;
}
//int count;//本质上属于对象

}

          ```

package StringTest;
//怎么去统计创建对象的数量？
//1.思路创建一个对象加一个
public class StudentTest {
     public static void main(String[]args) {
    	 func();
    	 Test1 test=new Test1("李三",12);//
    	 //test.count++;//1  count只属于某一个对象在调用过程中不会发生改变
    	 Test1 test2=new Test1("王五",13);
    	 //test2.count++;//1
    	 System.out.println(test2.count);
     }
     public static void func() {
    	 
        Test1 test3=new Test1("张三",14);
       // test2.count++;//1
        //分析：分别创建了三个对象并且这三个对象都有自己的数据因此
        //count统计的只是test/test2/test3创建的它们自己的对象的统计并没有进行累加
        
     }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SRJF7aUp-1600514315814)(C:\Users\lenovo\Desktop\正确案例.png)]

2.1.2 Static的含义及定义：
                               ```java

package StringTest;
/***

  • Static 含义：静态的
  • @author lenovo
    *static 的定义：它可以修饰成员变量和成员方法被修饰的成员是属于类的而不是单纯只属于某个对象
    *也就是说既然属于类就可以不用对象调用了。
    *Static 的定义：
  •  Static 数据类型  变量名；

*Static 的调用：

  •  类名.静态成员变量
  • 不加Static：成员变量
  •  为了区分静态成员变量和普通成员变量诞生了一个新的名词（实例成员变量（成员变量））
  • 实例成员属于某一个实例用对象调用
  • 对象.实例成员
    */
    public class Test1 {
    private String name;
    private int age;
    static int count;//属于类的不属于某一个具体的对象或者
    //说是属于所有对象的
    //静态成员变量 共享
    public Test1(String name,int age) {
    count++;//当创建对象的时候会进行累加但是只是加自己的
    //如果重新创建一个对象那个会重新进行累加
    this.name=name;
    this.age=age;
    }
    //int count;//本质上属于对象

}

                               ```

package StringTest;
//怎么去统计创建对象的数量？
//1.思路创建一个对象加一个
public class StudentTest {
     public static void main(String[]args) {
    	 func();
    	 Test1 test=new Test1("李三",12);//
    	 //test.count++;//1  count只属于某一个对象在调用过程中不会发生改变
    	 Test1 test2=new Test1("王五",13);
    	 //test2.count++;//1
    	// System.out.println(test2.count);//对象也可以调用
    	 System.out.println(Test1.count);//类调用
    	 //静态成员使用类调用而不使用对象调用（强烈建议使用类调用）
     }
     public static void func() {
    	 
        Test1 test3=new Test1("张三",14);
       // test2.count++;//1
        //分析：分别创建了三个对象并且这三个对象都有自己的数据因此
        //count统计的只是test/test2/test3创建的它们自己的对象的统计并没有进行累加
        
     }
}
2.1.3 静态变量/静态方法/静态块的含义，定义以及具体案例的应用：
                               ```java

package StaticDemo;

import java.util.ArrayList;

public class Student {
//实例成员变量
private String name;
private int age;
public void func() {

 }
 
public Student(String name, int age) {
    //count++;//如果将统计次数的变量放入构造其中在进行统计的时候只是
   
	//将当时自己创建的对象进行统计并没有统计其他的
	count++;
	this.name = name;
	this.age = age;
}
//静态成员变量
//静态成员变量共享
static int count;//本质是是属于对象的
//在成员变量名前加一个static成员变量就变成了静态的成员变量属于整个类
//共享
//static  静态的
//它可以修饰成员变量和成员方法 被修饰成员变量和成员方法 被修饰的成员是属于类的而不是单单属于某个对象
//也就是说 既然属于类 就可以不用对象调用了
//语法：
//static 数据类型   变量名
//调用：
//类名.静态成员
//sweep打扫
//静态方法语法 ：

// public static void func(){}

public static void sweep() {
	
	//sweep方法属于整个类
	//静态方法的调用：用类名去调用
	//类名.静态方法（参数列表）
	
	if(count>0) {
		System.out.println("有人打扫卫生");
	}else {
		System.out.println("留一个人打扫卫生");
	}
	
}
static ArrayList<Integer> list;//只是在栈上保存了一个地址并没有开辟内存（引用类型在使用之前必须初始化）
//引用类型不初始化不能用
static {
	//引用类型在静态代码块中进行初始化
	list=new ArrayList<>();
	//如果一个静态的引用类型不再静态代码块中初始化则会报错  java.lanq.NullPointerException(空指针）
}
 //引用类型在静态代买块中初始化了在调用的时候直接调用不用初始化了

}

                               ```
2.1.4静态方法/静态代码块/静态成员变量在使用的时候要注意哪些东西以及Math方法的学习：
                ```

package StaticDemo;
/**
*static 静态

  • 一开始怎么分类的：
  • class类名{
  • 成员变量
  • 成员方法
  • }
  • 新的分类：
  • class类名{
  • 静态成员
  • 实例成员
  • }
  • 静态成员变量
    *静态成员方法
    *静态代码块
    *静态的应用场景：工具类（共享） 工具类都会写成静态的
    *例如：算法
  • Math作用：数学计算 （提供的都是静态方法）

*/
import java.util.ArrayList;

//如何统计程序里边创建了多少个对象？
//1.通过变量统计
//学生类里边提供一个变量来统计
public class StudentTest {
public static void main01(String[]args) {

	func();
	func2();
	
	//创建三个不同的对象而且每一对象都有自己的数据
   Student stu1=new Student("李三",12);
  // stu1.count++;//count  属于某一个具体的对象
   Student stu2=new Student("张三",14);
   //stu2.count++;
  // System.out.println(stu1.count);
  System.out.println(Student.count);
  
   //static修饰的成员变量可以用对象调用   但是强烈建议使用类调用
  Student.sweep();
  
  //写一个静态变量   然后在外边初始化 (写一个静态变量然后在外边初始化倒不如把静态变量写在外边)
  Student.list=new ArrayList<>();
  Student.list.add(1);//NullPointerException(空指针)
}
public  static void func() {
	Student stu2=new Student("王五",14);
	//stu2.count++;
}
//
public static void func2() {
	
	System.out.println("测试");
}
//为什么在写的代码的时候习惯在测试的时候都是用静态的类里边都是非静态的？
//为什么在外部调用的时候要加static 
//在外部调用如果不加static 就无法测试
//如果在测试的时候创建的方法没有使用static创建方法在调用的时候只能使用对象调用
//StudentTest student =new StudentTest();
//student.func2();
//测试类也可以创建对象
//this.func2     
//静态方法使用的注意事项：
//1.静态方法可以直接访问类的静态变量和静态方法但是不能访问实例的成员变量和方法
 //解释说明：先有的实例成员还是现有的静态成员?静态成员先于实例成员出现 
//2.实例成员可以访问静态成员
//3.静态方法中不能出现this关键字     this关键字就是调用本类方法的对象  
//实例     创建对象才能调用其中的方法
//静态方法没有提供静态的构造函数但是提供了静态代码块static{   }
//静态代码块无法调用   类加载的时候自己执行
//静态代码块可以初始化资源
public static void main(String[]args) {
int  a=	 Math.abs(-1);//
//如果把常用的功能封装起来的时候也不是面向对象里的对象可以写成一个工具类
//Math是一个工具类
	 //知道 一个方法可以求任意一个数都是都可以求绝对值（重载）
System.out.println(a);
int min=Math.min(100, 89);
System.out.println(min);
Double  number2=Math.ceil(12.99);//向上取整
System.out.println(number2);
//ceil天花板
//大于等于
   Math.floor(12.0001);//向下取整
double number3   =Math.floor(12.999);//向下取整
System.out.println(number3);
}

}

                ```
2.1.5Arrays数组 ：

​ 此类包含用来操作数组（比如排序和搜索）的各种方法

2.1.5.1Arrays方法的学习:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bm0c1P1E-1600514315816)(C:\Users\lenovo\Desktop\Arrays方法的学习.png)]
2.1.5.1Arrays中 toString / sort方法的学习：
                                 ```java

package Array;

import java.util.Arrays;//工具

public class ArrayClass {
public static void main(String[]args) {
//Arrays 集合此类包含用来操作数组（比如排序和搜索）的各种方法
//static String toString(float[] a)
// 返回指定数组内容的字符串表示形式。
int [] arr= {4,2,3};

    	System.out.println(arr);//[I@15db9742   //不写任何转换打印的就是地址
    	
    	Arrays.sort(arr);//排序
    	String str=Arrays.toString(arr);//将数组以字符串的形式打印
    	System.out.println(str);
    }

}

                                 ```
2.2继承 ：

​ 面向对象的三大特性：封装、继承、多态

​ 继承：

2.2.1案例
package ExtendsDemo;
//抽取人的共性
public class Person {
       String name;
       int age;
}


package ExtendsDemo;

public class Student extends Person {
	//保留自己独有的成员
	int score;

}


package ExtendsDemo;

public class Test {
   //分析
	//老师   年龄   姓名    薪资
	//学生    年龄   姓名    成绩
	//保安     年龄  姓名     事故率
	//继承：共性抽取    实现复用
	//表示：父类（基类）和子类
	//语法：子类   extends   父类
	//场景：飞机会飞     老鹰会飞       风筝会飞    
	//继承的关键子：子类 is a 父类  才可以继承 （什么是什么）
	//语法：
	//1.子类可以使用父类的内容    
	//2.父类无法使用子类的内容
	//3.子类也可以有自己的内容
	//4.父类的私有成员子类是访问不到的（反射可以实现）
	//继承关系的规则：
	/**
	 * 1.成员变量
	 * 不重名
	 * 
	 * @param args
	 */
	public static void main(String[]args) {
	    Student stu=new Student();
	    stu.name="张三";
	   System.out.println(stu.name);
	    
	}     
}
2.2.2继承注意事项：
package ExtendsDemo;

public class Father {
        int numberF;
        int number;
        public void showNumber() {
        	System.out.println(number);
        }
}


package ExtendsDemo;

public class Son extends Father {
      int numberS;
      int number;
      public void showNumber(int number) {
    	  System.out.println(number);//就近原则  先打印局部变量的number （局部变量）
    	  System.out.println(super.number);//父类
    	  System.out.println(this.number);//访问成员变量里的number如果没有会找父类的number（子类）
    	  
      }
}


package ExtendsDemo;

public class Test {
   //分析
	//老师   年龄   姓名    薪资
	//学生    年龄   姓名    成绩
	//保安     年龄  姓名     事故率
	//继承：共性抽取    实现复用
	//表示：父类（基类）和子类
	//语法：子类   extends   父类
	//场景：飞机会飞     老鹰会飞       风筝会飞    
	//继承的关键子：子类 is a 父类  才可以继承 （什么是什么）
	//语法：
	//1.子类可以使用父类的内容    
	//2.父类无法使用子类的内容
	//3.子类也可以有自己的内容
	//4.父类的私有成员子类是访问不到的（反射可以实现）
	//继承关系的规则：
	/**
	 * 1.成员变量
	 * 不重名
	 * 
	 * @param args
	 */
	public static void main01(String[]args) {
	    Student stu=new Student();
	    stu.name="张三";
	   System.out.println(stu.name);
	    
	} 
	//父子类中没有重名的成员变量
	public static void main02(String[]args) {
		  Father  f=new Father();
		  Son son=new Son();
		  f.numberF=1;
		  son.numberF=2;//Son找变量先找自己的 如果没有(再找Person(父亲))向上找
		  son.numberS=3;//
	}
	//重名父子类当中存在重名的成员变量
	public static void main(String[]args) {
		 Father  f=new Father();
		  Son son=new Son();
		  //直接访问
		  f.number=100;//肯定是父亲的成员变量的
		  
		  son.number=200;//访问儿子的成员变量（先从自己的类里边找没有再去找父类的）就近原则
	     
		  
		 //通过方法间接访问 
		  f.showNumber();//方法内部访问的还是自己的
		  son.showNumber();//儿子（也是访问自己的）就近原则
		  //方法属于谁的就会找自己的变量
		  //如果子类里边没有变量但是又要用方法输出变量的时候 会调用父类的成员变量（再继承的前提之下）
		  //
		  //父类只能访问自己的而子类先找自己的如果没有再找父类的
		  
		  
	}
	
	
}
2.2.3场景应用：

​ 切水果

​ 第一个版本：

​ 水果 刀

​

3.今日单词：

​ appedn 添加

​ ceil 天花板

​ floor 地板

ther();
Son son=new Son();
//直接访问
f.number=100;//肯定是父亲的成员变量的

	  son.number=200;//访问儿子的成员变量（先从自己的类里边找没有再去找父类的）就近原则
     
	  
	 //通过方法间接访问 
	  f.showNumber();//方法内部访问的还是自己的
	  son.showNumber();//儿子（也是访问自己的）就近原则
	  //方法属于谁的就会找自己的变量
	  //如果子类里边没有变量但是又要用方法输出变量的时候 会调用父类的成员变量（再继承的前提之下）
	  //
	  //父类只能访问自己的而子类先找自己的如果没有再找父类的
	  
	  
}

}


###### 2.2.3场景应用：

​              切水果

​       第一个版本：

​                           水果        刀

​                           

# 3.今日单词：

​            appedn 添加

​             ceil 天花板

​             floor 地板

​             extends 继承   推广
猿字羌
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java 并发学习
jiqiren1994的博客
05-20 241
独占锁模型 共享锁模型
Java io流的学习
DarrenYan
10-19 1033
Java io流
java语法static统计人口
dizaoshen1316的博客
04-10 359
转载于:https://www.cnblogs.com/itBulls/articles/8779035.html
java student_Java之经典Student问题2
weixin_30588381的博客
02-20 586
创建5个学生对象给一个学生数组赋值，每个学生属性有：学号、姓名、年龄。要求：1.给每个学生排序输出。2.给所有学生年龄加1。 3.统计年龄大于20的学生人数。在这里，我们用了compareTo方法，其实compareTo就是用来比较两个值，如果前者大于后者，返回1，等于返回0，小于返回-1package com.cdp.student;public class student {// 属性pri...
Java 静态变量统计（声明书类）
qq_hua_xia的博客
09-21 1322
1.题目详情： 声明一个图书类，其数据成员为书名、编号（利用静态变量实现自动编号）、书价，并拥有静态数据成员册数，记录图书的总册数；在构造方法中，利用静态变量为对象的编号赋值，在主方法中定义对象数组(最多10个元素），并求出总册数。 2.输入格式: 请输入每本图书对应的书名，书价（最多10本） 3.输出格式: 请输出每本图书对应的书名，书号，书价以及总图书数。 4.输入样例: 在这里给出一组输入（以空格分隔）。例如： Java程序设计 34.5 数据结构 44.8 C++程序设计 35.0
Java程序设计实验二 面向对象程序设计
Ace2NoU的博客
12-22 6041
[1]实验目的：通过编程和上机实验，掌握类和构造方法的定义及创建对象的方法，掌握类的封装及继承原则，正确使用重载和覆盖等多态概念设计可复用方法，熟悉包、接口的使用方法，掌握面向对象的程序设计方法。 [2]实验内容： 1、编写MyDate类，完善上次实验中的人员信息录入，实现日期合法性判断，包括大小月和闰年。 *2、声明一个Person类和派生类Student，成员变量包括学号、姓名、入学时间、身份证号、学分绩点等信息，成员方法包括开户、存款、取款、查询（余额、明细）、销户等操作。 *3、设计一个汽车
java学习-java中静态成员方法
12-01
java学习-c
java学习java中的常量和静态变量
12-01
java学习java中的常量和静态变量
Java静态泛型使用方法实例解析
08-19
Java静态泛型使用方法实例解析主要介绍了Java静态泛型使用方法实例解析，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友可以参考下。 一、泛型是什么？ 泛型是Java 5中...
浅谈Java内部类的四个应用场景
01-04
Java内部类是Java言语的一个很重要的概念，《Java编程思想》花了很大的篇幅来讲述这个概念。但是我们在实践中很少用到它，虽然我们在很多时候会被动的使用到它，但它仍然像一个幕后英雄一样，不为我们所知，不为我们所用。 本文不试图来讲述Java内部类的今生前世、来龙去脉，这些在网络上都已经汗牛充栋。如果读者想了解这些，可以在网络上搜索来学习。Java内部类总是躲在它的外部类里，像一个幕后英雄一样。但是幕后英雄也有用武之地，在很多时候，恰当的使用Java内部类能起到让人拍案叫绝的作用。本文试图谈一谈让这个幕后英雄也有用武之地的四个场景，希望引起大家对使用Java内部类的兴趣。
Java静态static关键字原理详解
08-25
Java静态static关键字原理详解 Java静态static关键字是Java语言中一个非常重要的概念，它可以修饰成员变量和成员方法，使其...在本文中，我们详细介绍了Java静态static关键字的原理和应用，希望对大家的学习有所帮助。
java中static的作用 和 利用static记录类的个数
qq_50631074的博客
03-06 304
java中利用static 记录类的个数 class A { private static int i; private static int len; public A () { len++; } public A (int i) { this.i = i; len++; } public static int get () { return len; } public void add () { System.out.printf("%d
Java实验题目
qq_73981813的博客
09-29 368
Java实验题目练习
java实验的总结_java实验总结
weixin_39907133的博客
02-16 530
1. 设计一个Person类，包含：姓名，年龄，性别。要求：该类至多只能创建一男、一女两个对象。2. 设计一个测试类Test，创建若干个Person类对象，测试是否符合要求。package test8;class person {String name;int age;char sex;static int flag1 = 1, flag2 = 1;private person(String n,...
静态内部类介绍与使用场景
thinking-fish的博客
03-21 632
java中 用static 修饰的类为静态类，静态类只能是内部类；内部静态类，是外部类的成员，可以访问外部类成员（包括私有成员），但因为有static约束，和静态方法类似，只能访问静态成员/方法，不能访问普通成员/方法//外部类 public class Outer {//静态成员 private static int static_parm_out;//普通成员 private int parm_out;} //内部静态类 static class InnerStatic {
Java-Static静态类的使用场景
人生在手
05-24 1080
6、static包导入：使用场景：在工作中遇到多次关键字需要导入类，然后发现他们的命名空间一致，这个时候可以直接 如：import java.util.*：平常工作中，遇到读取配置文件、服务器参数、冷数据的加载、字典数据等等，这个时候可以使用static代码块，避免重新查询数据或创建对象。4、static内部类：一个内部类，加上static，成为static内部类；注意点：类中的静态变量是一个整体，共享给所有对象，一个对象对其值改动，那么所有该静态变量都会跟着变动，牵一发而动全身;定义一个静态方法表示。
mpu6050陀螺仪使用方法开发教程文档.docx
最新发布
07-30
mpu6050陀螺仪使用方法
Java学习笔记：静态关键字与Math类
"Java学习笔记第三部分，涵盖了Java中的`static`关键字，静态内存图，静态代码块，以及`Math`类的相关方法。此外，还讨论了继承性，方法重写，以及重写的一些注意事项。" 在Java编程语言中，`static`关键字具有至关...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值