JAVA的方法与成员变量

1>成员变量和局部变量的区别

1)在代码中的位置不同：

局部变量：在类中的方法被定义或者声明

成员变量： 在类中方法外

2)在内存中的位置不同：

局部变量： 栈内存

成员变量： 堆内存

3)生命周期不同：

局部变量： 随着方法的调用而存在,随着方法的调用完毕而消失

成员变量： 随着对象的建立而存在,随着对象的消失而消失

4)默认值不同：

局部变量: 没有默认值

成员变量： 有默认值0 或者 null

注意：局部名称可以和成员名称一样,在方法使用的时候是就近原则

class Varialbe {
	//成员变量
	//int num = 10;
	int num; //0
	
	public void show() {
		//int num2 = 20; //局部变量
		//可能尚未初始化变量num2
		//int num2; //没有默认值
		int num2 = 20;
		System.out.println(num2);
		
		//int num = 100;//就近原则
		System.out.println(num);
	}
}


class VariableDemo {
	public static void main(String[] args) {
		Varialbe v = new Varialbe();
		
		System.out.println(v.num); //访问成员变量
		
		v.show();	
			
	}
}

2 形参与实参

形式参数的问题：

基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数

形参是基本类型

class Demo {
	public int sum(int a,int b) {
		return a + b;
	}
}
class ArgsTest{
	public static void main(String[] args){
		//形参是基本类型的调用
		Demod = new Demo();
		int result = d.sum(3,4);
		System.out.println("result "+result);
	}
}

形参是引用类型

class Student{
	public void show(){
		System.out.println("我爱学习");
	}
}
class StudentDemo{
	public void method(Student s){
		s.show();
	}
}
class ArgsTest{
	public static void main(String[] args){
		//形参是基本类型的调用
		Demo d = new Demo();
		int result = d.sum(3,4);
		System.out.println("result "+result);
		System.out.println("------------------");
		
		//形参是引用类型的调用
		//需求是要调用类StudentDemo的方法method();
		StudentDemo sd = new StudentDemo();
		//创建学生对象
		Student s = new Student();
		sd.method(s);
	}
}

3 匿名对象

匿名对象：就是没有名字的对象

匿名对象的使用条件：仅仅调用一次时候

同一匿名对象无法被调用多次

匿名对象的使用好处：当被调用完后,就是垃圾值,可以被回收

class Student {
	public void show() {
		System.out.println("我爱学习");
	}
}

class StudentDemo {
	public void method(Student s) {
		s.show();
	}
}
class NoNameDemo{
	public static void main(String[] args){
		//有名字的调用
		Student s =new Student();
		s.show();
		System.out.println("------------");
		
		//没有名字的调用
		new Student().show();
		new Student().show();//这样是在堆区生成了两个类
		System.out.println("--------------");
		
		//匿名对象可可以作为实参传递
		new StudentDemo().method(new Student());
	}
	
}

4封装和private关键字：

private关键字：是一个权限修饰符

可以修饰变量和方法,被修饰的变量和方法只能在本类中被使用

class Demo {
	//int num = 10;
	//用private修饰
	private int num = 10;
	
	public void show() {
		System.out.println(num);
	}
	
	private void method() {
		System.out.println("method");
	}
	
	public void function() {
		method();
	}
}

class PrivateDemo {
	public static void main(String[] args) {
		Demo d = new Demo();
		//不能方法私有的成员变量
		//System.out.println(d.num);
		d.show();
		//不能访问私有的成员方法
		//d.method();
		d.function();
	}
}

封装：隐藏对象的属性和实现细节,仅仅对外提供接口

class Student{
	//姓名
	String name;
	//年零
	private int age;
	
	//写一个方法对数据进行校验
	public void setAge(int a){
		if(a < 0 || age > 120){
			System.out.println("输入数据有误");
		}else{
			age = a;
		}
	}
	
	//show()方法显示所有成员变量值
	public void show(){
		System.out.println("姓名: "+name);
		System.out.println("年龄: "+age);
	}
}

class StudentDemo{
	public static void main(String[] args){
		Student sd = new Student();
		sd.show();//本来是没有赋值不能使用,但是有默认的构造函数
		System.out.println("------------------------------");
		
		sd.setAge(7);
		sd.show();
	}
}

this关键字：就是可以理解为当前类的一个对象。

注意事项：

哪个对象调用这个方法,则this指针就代表那个对象

应用场景：解决局部变量隐藏成员变量

lass Student {
	private String name;
	private int age;
	
	public String getName() {
		return name; //这里其实是隐含了this
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public int getAge() {
		return age;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
}

this关键字图解：

5构造方法

构造方法：

给对象的数据进行进行初始化

格式：

方法名和对象名相同

没有返回类型,连void类型都没有

没有返回值

class Student{
	private int age;
	private String name;
	public Student(){
		System.out.println("这个构造方法!!!");//当对象被创建的时候,构造方法就被执行
	}
	
}
class StudentDemo{
	public static void main(String[] args){
		Student sd = new Student();//创建一个对象
		System.out.println(sd);//地址
	}
}

构造方法的重载：

A:当没有构造函数时候,系统会提供一个默认的构造函数

B:当有构造函数时候,系统不会提供默认的构造函数,此时需要我们自己写一个无参构造函数。

class Student{
	private int age;
	private String name;
	
	public Student(){
		System.out.println("我是无参构造函数");
	}
	
	//构造函数的重载
	public Student(String name){
		System.out.println("String 类型的构造函数");
		this.name = name;
	}
	public Student(int age){
		System.out.println("int 类型的构造函数");
		this.age = age;
	}
	public Student(int age, String name){
		this.name = name;
		this.age = age;
		System.out.println("name: "+name+"age: "+age);
	}
}
class ConstructDemo2{
	public static void main(String[] args)
	{
		Student s = new Student();
		Student s1 = new Student("sonh");
		Student s2 = new Student(7);
		Student s3 = new Student(1,"dong");
	}
}

一个代码的标准版

class Student{
	//名字
	private String name;
	//年龄
	private int age;
	
	//构造方法：
	public Student(){
	}
	public Student(String name, int age){
		this.name = name;
		this.age = age;
	}
	
	//成员方法
	public String getNmae(){
		return name;
	}
	public int getAge(){
		return age;
	}
	public void setName(String name){
		this.name = name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public void show(){
		System.out.println("name: "+name+" age: "+age);
	}
}
class StudentDemo{
	//创建一个对象
	public static void main(String[] args){
		Student s = new Student("宋东",21);
		s.show();
	}
}

6 创建一个对象 Student s = new Student();所做的事情

A：加载.class文件进入方法区

B:在栈中为s变量申请·空间

C:在堆中为学生对象申请一个空间

D:完成堆中数据的初始化

E:将堆中对象的地址值赋值给栈中的s

在定义一个类的时候,其中的成员变量是要求可以描述类的属性的。

7 static关键字的解释

static关键字的特点：

1类加载的时候被创建

2优先于对象被建立

· 3类的所有对象共享

4可以通过类名调用

静态修饰的成员称为类成员。

class Student{
	int num = 1;
	static int num2 = 2;
}
class StudentDemo{
	public static void main(String[] args){
		Student s = new Student();
		
		System.out.println(s.num);
		System.out.println(s.num2);
		System.out.println(Student.num2);
	}
}

static关键字的注意：

1.静态方法没有this关键字,原因静态方法随着类的加载而被创建。this随着对象的创建而被创建。静态的创建时间大于对象的创建时间

2.静态的方法只能访问静态的成员变量和成员方法

static关键字图解

main方法格式的解释：

public static void main(String[] args):

public:公共的，访问权限是最大的。由于main方法是被jvm调用，所以权限要够大。
static:静态的，不需要创建对象，通过类名就可以。方便jvm的调用。
void:因为我们曾经说过，方法的返回值是返回给调用者，而main方法是被jvm调用。你返回内容给jvm没有意义。
main:是一个常见的方法入口。我见过的语言都是以main作为入口。
String[] args:这是一个字符串数组.
这个东西早期是为了接收键盘录入的数据的。
格式是：
java MainDemo hello world java

class MainDemo{
	public static void main(String[] args){
		System.out.println(args.length);//录入数据的长度
		for(int i = 0; i < args.length; i++){
			System.out.println(args[i]);
		}
	}
}