Java程序员从笨鸟到菜鸟之（五）静态staic

最新推荐文章于 2024-01-23 22:05:21 发布

wzj_110

最新推荐文章于 2024-01-23 22:05:21 发布

阅读量342

点赞数 1

分类专栏： Java 文章标签： java 封装 static

本文链接：https://blog.csdn.net/wzj_110/article/details/78249061

版权

Java 专栏收录该内容

67 篇文章 1 订阅

订阅专栏

一. 匿名对象

定义：没有名字的对象
意义：节省代码，使代码结构更优雅，并且很多情况下是针对某个方法只需要调用一次的情况下
匿名对象用法：可以调用方法；也可以给成员变量赋值；同时也可以作为方法的参数进行传递

实例1:

/* 使用匿名对象：
 * new关键字的结果：是指向创建它对象的引用
 * 由于没有变量存储这个“引用”，所以一经使用找不到这个引用了
 * 使用格式：
 * new+类名(参数).+对象属性
 * new+类名(参数).+方法名(参数)
 */
public class AnonymousObject{
	public static void main(String[] args){
		String name=new Person().name;
		System.out.println(name);
		new Person().speak();//又创建了一个对象，调用它的方法
	}
}
class Person{
	 String name = "小王";
	 int age = 20;
	
	void speak(){
		System.out.println("speak:"+age);
	}
	
}

二. 封装

1 概念：隐藏对象的属性和细节，仅对外提供公共的方法进行访问

2 关键字：private

特点：

a. 当类的成员变量使用private 修饰符修饰，那么就不可以直接访问到该成员变量
b. 当使用private 修饰的成员变量或者成员方法，仅能在本类中使用
c. private 对于main 方法的修饰，也是可以产生作用的.

实例2：

public class DemoPrivate{
	
	public static void main(String[] args){
		Person1 person =new Person1();
		person.age=20;//出错的地方：不能直接对类中私有的成员变量值进行操作
		//person.name = "diffo";
	
     }
}
class Person1{
	String name;
	private int age;
	void speak(){
		System.out.println("speak!: "+name+" . "+age);
	}
}

cmd编译结果：

eclipse编译结果：字段 Person1.age 不可视

javaBean类：

是这样一类的类，他的所有成员变量都使用private 进行修饰，并且对外提供可访问的设置值和获取值的set和get方法

不同的应用场景，可能命名不同，数据库的应用中称为POJO类.

实例3：

/*
 * 
 */
class DemoBean {

	public static void main(String[] args) {
		Person person = new Person();
		person.setName("小王");
		person.setAge(30);
		person.speak();
	}

}// java bean

class Person {
	private String name;
	private int age;

	void setName(String nameParm) {
		name = nameParm;
	}

	String getName() {
		return name;
	}

	void setAge(int ageParm) {
		age = ageParm;
	}

	int getAge() {
		return age;
	}

	void speak() {
		System.out.println(name + " . " + age);
	}

}

补充：

main方法细节：
a.每个类中都可以存在main方法，但是当执行的时候，会优先查看public 的class 中是否有main 方法
b.如果没有public 的class, 那么会按照文件名优先查找类中的main方法
c.必须定义为public.

三. 优先原则
优先原则：对于一个类的成员方法来说，如果传递的形参的变量名称和类的成员变量名称相同，jvm在处理的时候优先当做方法的形参来处理.

实例4：

public class SimpleClassToShowThis {  
	//实例变量和局部变量重名  
    public int a;  
    public void test(int a){   
        System.out.println(a);  
    }  
    public static void main(String[] args) {  
        SimpleClassToShowThis var=new SimpleClassToShowThis();  
        var.test(5);  
        System.out.println(var.a);  
    }  
}

编译结果：

说明：

当方法体中使用一个变量的时候，java平台会按照先局部变量，后实例变量的顺序找，所以说test(int a)中声明的int类型a变量，它与实例变量中的变量a虽然重名，但是却不会让java平台迷惑。按照先局部变量后实例变量的顺序，test()方法中第二行和第三行使用到的a都是局部变量。

四. this 关键字
1 含义：代表了当前对象的引用
可以理解为，当前谁来调用，那么方法中的this 就代表谁
对于成员变量可以区分出来的场景，this 可加也可以不加，实际效果相同。
但是对于实现javaBean/POJO 来说，我们建议都加上在setXXX、getXXX方法中，一般方法参数的名字和实例变量参数一致

实例5：

class DemoBeanThis{
	
	public static void main(String[] args){
		Person person = new Person();
		person.setName("李逵");
		person.setAge(30);
		person.speak();
	}
	
}

class Person{
	private String name;
	private int age;
	
	void setName(String name){
		this.name = name;
	}
	
	String getName(){
		return name;
	}
	
	void setAge(int age){
		this.age = age;
	}
	
	int getAge(){
		return age;
	}
	
	void speak(){
		System.out.println(name+" . "+age);
	}
	
	public static void main(String[] args){
		Person person = new Person();
		person.setName("diffo");
		person.setAge(30);
		person.speak();
	}
}

补充：

this关键字只能在方法中使用，是用来指代调用方法的类的对象
this：可以加在成员变量的前面来指定对应的引用，也可以加在成员方法的前面（方法里面调用方法）

五. 初始化类成员变量的方式

a 在定义成员变量的同时进行赋值
b 提供外界可访问到的方法，在方法中进行赋值
c 通过构造方法进行赋值.

实例6：

public class DemoClassTest{
	public static void main(String[] args){
		
		//第一种方式
		//在构造方法执行前进行赋值（static），并且该类每个实现的对象，都会被初始化为该值或者在定义成员变量的同时进行赋值
		//意义： 当我们真的需要一个类的所有对象某些成员变量的值一致的时候
		Person person = new Person();
		person.showEntity();
	/*
		第二种方式
		构造方法中直接进行赋值.
		意义： 可以在创建对象的同时进行赋值，同时还可以动态的指定设定的值是什么
		Person person1 = new Person(40);
		person1.showEntity();
		
		第三种方式
		通过调用某个设置值的方法进行赋值,在对象创建完成之后
		意义: 动态的修改成员变量的值.
		Person person2 = new Person();
		person2.showEntity();
	*/	
		/*
		person.setAge(12);
		person.eat();
		
		Person person1 = new Person();
		person1.setAge(15);
		person1.eat();
		*/
			
	}
}

class Person{
		
		//该成员变量就不可被外部访问(外部: 类之外)
		private int age=20;//第一种赋值方式：在定义成员变量的同时进行赋值
		static String entity;
		
		//是给成员变量赋值
		
		//优先原则: 对于一个方法来说，如果传递的形参的变量名称和类的成员变量名称相同，jvm在处理的时候优先当做方法的形参来处理.
		
		Person(){
		//默认构造器	
		}
		
		Person(int age){
			this.age = age;
		}
		
		void setAge(int age){
			this.age = age;
		}
		
		//拿到成员变量的值
		int getAge(){			
			return this.age; 
		}
		
		void eat(){
			System.out.println("eat :"+this.age);
			speak();
		}
		
		void outputAge(){
				System.out.println(this.age);
		}
		
		void speak(){
			System.out.println("speak!");
		}
		
		void showEntity(){
			System.out.println("Entity:"+entity);
		}
		
}

或者在定义成员变量的同时进行赋值
		//意义： 当我们真的需要一个类的所有对象某些成员变量的值一致的时候
		Person person = new Person();
		person.showEntity();
	/*
		第二种方式
		构造方法中直接进行赋值.
		意义： 可以在创建对象的同时进行赋值，同时还可以动态的指定设定的值是什么
		Person person1 = new Person(40);
		person1.showEntity();
		
		第三种方式
		通过调用某个设置值的方法进行赋值,在对象创建完成之后
		意义: 动态的修改成员变量的值.
		Person person2 = new Person();
		person2.showEntity();
	*/	
		/*
		person.setAge(12);
		person.eat();
		
		Person person1 = new Person();
		person1.setAge(15);
		person1.eat();
		*/
			
	}
}

class Person{
		
		//该成员变量就不可被外部访问(外部: 类之外)
		private int age=20;//第一种赋值方式：在定义成员变量的同时进行赋值
		static String entity;
		
		//是给成员变量赋值
		
		//优先原则: 对于一个方法来说，如果传递的形参的变量名称和类的成员变量名称相同，jvm在处理的时候优先当做方法的形参来处理.
		
		Person(){
		//默认构造器	
		}
		
		Person(int age){
			this.age = age;
		}
		
		void setAge(int age){
			this.age = age;
		}
		
		//拿到成员变量的值
		int getAge(){			
			return this.age; 
		}
		
		void eat(){
			System.out.println("eat :"+this.age);
			speak();
		}
		
		void outputAge(){
				System.out.println(this.age);
		}
		
		void speak(){
			System.out.println("speak!");
		}
		
		void showEntity(){
			System.out.println("Entity:"+entity);
		}
		
}

六. static

1 特点：

1）随着类加载而加载
静态方法区（独立于堆和栈）中来保存静态成员变量

类加载：当遇到main方法的时候，会去加载main方法所在的类，加载完后会继续执行main方法中的程序，若用new创建一个对象的时候也要加载对应的类

2）优先于对象创建，也即用static修饰的变量与方法与对象无关

3）被类的所有对象共享
静态的成员变量会保存在该class的静态方法区中，所以每个对象看到的都是同一份，static所修饰的变量和方法在类中只加载一次

4）可以通过类名来访问也可以通过对象名来访问效果是一样的

5）推荐通过类名来访问
静态的成员，一般称为类成员
例如：Person.className = "java";

6）static 修饰符既可以修饰成员变量，也可以修饰成员方法，且修饰之后就可以通过类名来直接访问到

7）this变量在静态方法中不可以使用
原因：this是指向对象的引用，而static修饰的变量与对象无关

8）静态方法中只能访问静态成员变量和静态方法
非静态方法既可以访问静态成员和方法也可以访问非静态成员和方法
非静态虽然可以访问静态的方法，但是不建议这样做

七. main方法

修饰符返回类型方法名 (参数列表){

}

public static void main(String[] args){

}

说明：
public：最大的一个访问权限，使得jvm能够成功调用
static:：类相关的，与对象无关，A.main([])

public class A{
main(){
System.("");
}
}
void：不需要返回值.
方法名：main
参数列表：执行的时候，可以传递参数.

八. 工具类

全部都是静态的方法；所以可以通过类名.functionName(参数) 方式来访问
注意：一般的话，都会对默认构造方法进行私有化处理，来防止别人使用时习惯性的创建对象来调用方法

例7：

public class ClassTestFinal{
	//计算正方形周长和面积（用JavaBean和自己构造的工具类）
	public static void main(String[] args){
		Square square = new Square();
		square.setLength(2);
		System.out.println(SquareUtil.getCircumLength(square));//类名直接访问方法
		System.out.println(SquareUtil.getArea(square));
	}
	
}

//pojo类
class Square{
	private int length;
	
	void setLength(int length){
		this.length = length;
	}
	
	int getLength(){
		return this.length;
	}
}

//正方形工具类
class SquareUtil{
	
	private SquareUtil(){
	//构造方法私有化，导致外界无法创建对象，只能通过类名调用	
	}
	//传递引用
	static  int getCircumLength(Square square){
		return 4*square.getLength();
	}
	
	static   int getArea(Square square){
		return square.getLength()*square.getLength();
	}
}

例8：

import java.util.Arrays;
import java.util.Random;

/* 目的：使用java类库中的相关类的方法
 * 相关说明：
 * import java.util.*;//将此包中的所有类导入(一劳永逸)
 * 对于不是java.lang中的类，必须用import导入
 * nextInt(int a)是Random类中是非静态方法，必须创建对象才能使用
 * nextInt(int a)是Random类中的一个方法，随机生成一个[0,a-1]之间的自然数
 * sort(int []a) 是Arrays类的一个静态方法(void类型)：对数组升序排列
 * toString(int []a)是Arrays类的一个静态方法(String类型)：将数组转化为字符串
   要求：定义一个保存10个int 型的数组，并且初始化为 0-27 的随机值，之后进行升序排序
   0~0.99999-> 0-9 ->*3 ->0~27(传统按照面向过程的思路)
*/
public class ClassTest {

	public static void main(String[] args) {

		Random d = new Random();
		int[] array = new int[10];
		for (int i = 0; i < array.length; i++) {
			// array[i] = (int)(Math.random()*10) * 3;
			array[i] = d.nextInt(28);
		}
		Arrays.sort(array);
		System.out.println(Arrays.toString(array));
	}

}