java的类与对象_java编写一个方法 public static void login(string usernam-CSDN博客

本文链接：https://blog.csdn.net/weixin_43786255/article/details/90614212

java的类与对象

1 面向对象

1.1 面向对象与面向过程的区别

面向过程和面向对象都是解决问题的逻辑方法，面向过程是强调解决问题的步骤，可以先定义多个函数，在使用的使用调用函数即可；面向对象把问题分解成多个对象，强调的是解决问题的行为，总结如下：

面向过程：强化函数，过程(步骤)，实现功能模块。

面向对象：用类和对象的方法来解决问题的行为或功能。

1.2 对象

对象（实例）：具有属性和行为的个体，称为对象。万物皆对象。比如人：名字、年龄、高矮，吃饭、睡觉、跑步——具体的每一个人就是一个对象。属性是名词，行为是动词，不同的对象具有不同的属性值和行为。

对象在内存中存储结构，有如下代码

public class ObjectStructure {
	public static void main(String[] args) {
		int n = 10;  //栈存储
		int m = 10;  //栈存储
		Person p = new Person();
		//属性赋值
		p.name="张三";
		System.out.println(p.name);  //   张三
		System.out.println(p.age);   //0		
		//调用
		String name = "ls";   //局部变量(常量池)
		String aaaa="ls";
		String pwd = "123";
		p.login(name,pwd);
		System.out.println("name:"+name);   //ls
		System.out.println("执行");
	}
}

class Person {
	// 属性
	String name;
	int age;
	//用户登录
	String userName;
	String pwd;
	
	public void login(String userName,String pwd){	
		System.out.println(userName+"===="+pwd);   //ls  123
	}
	
	public void show() {
		System.out.println("姓名：" + name + ",年龄：" + age);
	}
}

其内存图如下：

1.3 类

类：具有相同属性（特征）和行为(动作)对象的集合。

类和对象之间的关系，从设计层面与编码层面分析如下：

（1）设计层面：众多的对象，从众多的对象中，根据需求，划分成不同的类别。
（2）编码层面：从类别出发，编写类的代码——对应的就是我们的class 关键字后面的类名。

可以简单的理解为类是模板，蓝图，对象是类具体实例化出来的对象，个体。

2 类的创建和初始化

2.1 类的定义

【访问权限修饰符】【修饰符】 class 类名{
类体
}

权限修饰符如下：

权限修饰符	描述
public	公共的,在同包，不同包中的类该权限修饰修饰的属性都可以访问
缺省：默认的	只能在同包中的类进行访问

注意：protected和private只能修饰内部类，不能修饰外部类。外部类就只有以上两种修饰符。

static不能修饰外部类，能修饰内部类直接作为一个普通类来使用，而不需先实例一个外部类。

修饰符如下：

修饰符	描述
abstarct	可以被指示一个类只能作为其它类的基类
final	不能再申明子类

注意：一个java文件中，可以有多个class，但是只能有一个public class

2.2 类的属性

属性：描述类中对象的特征。

语法：【访问权限修饰符】【修饰符】类型属性名【= 初始值】；

访问权限修饰符：private 缺省(default)默认 protected public

修饰符如下：

修饰符	描述
static	指定变量被所有对象共享，即所有实例都可以使用该变量。变量属于这个类。
final	最终修饰符，指定此变量的值不能变
transient	指定该变量是系统保留，暂无特别作用的临时性变量。修饰的属性不能序列化
volatile	指定该变量可以同时被几个线程控制和修改。

其中初始值，可以在声明的同时对属性进行赋值。也可以在使用之前进行赋值。在声明的同时赋值，和在使用之前进行赋值有本质的区别：（1）在类中，声明成员变量的同时赋值，相当于创建的所有对象默认的属性值就是赋予的默认值；（2）在使用之前，使使用对象名a.属性名进行赋值，只针对当前这个对象a有效，对其他对象无效。

成员变量（属性）与局部变量的异同：

相同点

①定义的语法格式相同: 类型名称 = “初始值”;

②都有作用域 (作用范围)

不同点

①定义位置不同，成员变量定义在类中,方法外；局部变量定义方法内或者方法的参数或者是代码块中；

②成员变量有默认的初始值;基本类型：

整型：byte short int long 默认值 :0

浮点类型：float double 默认值:0.0

字符类型：char 默认值：空格 \u0000

布尔类型：boolean 默认值：false

引用类型：都是null;

局部变量没有初始值。

③在内存在的位置不同，成员变量存放在堆中；局部变量存放在栈中。

④成员变量的访问权限修饰符有四个(public 默认 protected private );局部变量没有权限修饰符;

2.3 类的方法

类中定义一个行为或者动作。

语法：【访问权限修饰符】【修饰符】返回值类型方法名字(参数类型参数1,参数类型参数2,....){ 方法体 }

访问权限修饰符: private 缺省(default)默认 protected public；

修饰符如下：

修饰符	描述
static	指定不需要实例化就可以激活的一个方法。
final	指定该方法不能被重载。
abstract	指定此方法不需要实现，实现留给子类覆盖，子类覆盖该方法之后方法才能够生效。
native	本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的。
synchronized	同步修饰符，在多个线程中，该修饰符用于在运行前，对他所属的方法加锁，以防止其他线程的访问，运行结束后解锁。

方法的参数：分为形式参数和实际参数

形式参数	形式参数,没有值的参数，在函数定义时候的参数
实际参数	有具体值的参数，在函数调用时候的参数

在调用方法的时候，会自动的将实际参数的值，赋予给形式参数。

方法的返回值：一个方法是用来实现某一个或者多个功能的模块，方法执行的结果有的时候，需要传递出来，被调用端来使用。

设置返回值：（1）在方法内部，写return 返回值表达式。（2）在方法定义的时候，将返回值类型设置成，跟返回值表式匹配的类型。

注意：在方法中，程序当执行到return的时候，一定会跳出当前的方法；在方法中，return后面的代码段一定不执行。

2.4 方法重载

定义：如果有两个方法的方法名相同，但参数不一致，那么可以说一个方法是另一个方法的重载，如下代码构成重载。

class GetMax{
	public void max(int a,int b) {
		int max=a>b?a:b;
		System.out.println("最大值:"+max);
	}
	public double max(double a,double b) {
		double max=a>b?a:b;
		return max;
	}
	public double max(double a,double b,double c) {
		//double max=a>b?a:b;
		double result = max(a,b)>c?max(a,b):c;
		return result;
	}
}

特点：

（1）方法必须在同一类中且方法名相同;

（2）方法名必须相同;

（3）参数列表必须不一致(a.参数类型 b.参数个数 c.参数的顺序)；

（4）与方法的返回值类型无关(可以相同也可以不同)。

2.5 匿名对象

匿名对象：创建的对象是匿名的，代码如下

//创建学生对象，并且要输入学生信息
Student student = new Student();
student.info();
//匿名对象 
new Student().info();

缺点：对象只能创建一次.。

对象中的成员只调用一次时，可以使用匿名对象.。

2.6 方法的可变参数

语法：访问权限修饰符返回值类型方法名(类型…变量名){}

特点：

（1）可变参数与同名方法构成重载；

（2）可变参数只能出现一次，并且必须放在最后；

（3）可变参数的使用和数组的使用方式一致。

2.7 任意类型作为方法的返回值类型

作为返回值：返回一个该类型的对象

public class TestCar {
	public static void main(String[] args) {
		Car car = factory.getCar("benz", "黑色");
		car.info();		
	}
}
//工厂
class Factory{	
	
	public Car getCar(String brand,String color) {
		Car car = new Car();
		car.brand=brand;
		car.color=color;
		return car;
	}
}
//汽车
class Car{
	//属性
	String brand;
	String color;
	//方法输出汽车的信息
	public void info() {
		System.out.println("品牌："+brand+"，颜色："+color);
	}
}

2.8 值类型和引用类型作方法的参数区别

值类型作为方法的参数：值传递的过程只是将实参的值复制给形参，它们实参与形参并不是共享一段相同的内存，因此形参的改变只是改变自己占用的内存的值，而不改变实参。

引用类型作为方法的参数：通过指针和引用将实参传给形参，因为此时实参与形参共享同一地址单元，形参改变值了，实参自然也要改。

通过内存图可以明确的区分，代码及内存图如下：

class Test {
    public static void main(String args[]) {
        Test t = new Test();
        t.first();
    }
    public void first() {
        int i = 5;
        Value v1 = new Value();
        v1.i = 25;
        second(v1, i);
        System.out.println(v.i);  //20
    }
    public void second(Value v, int i) {
        i = 0;
        v.i = 20;
        Value val = new Value();
        v = val;
        System.out.println(v.i + " " + i);  //15  0
    }
}
class Value {
  int i = 15;
}

2.9 构造器

作用：（1）用于创建对象；（2）创建对象的同时给当前对象的属性赋值

语法：访问权限修饰符类名（参数列表） {}

特点：（1）用户没有手动创建构造器系统会自动创建一个无参构造器；

（2）用户创建够造器系统不会为类提供无参构造器；

（3）也可以和方法一样实现重载；

（4）默认构造器的修饰符与所属类的修饰符一致。

class Boy{
	private String name;
	private int age;
	//无参	
	public Boy() {
		super();
	}
    //有参
	public Boy(String name, int age) {
		this.name = name;
		this.age = age;
	}
}

2.10 package包

作用：防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。

规范：项目类型.公司名称.项目名称.模块名称.包名（所有字母小写）

package com.refuel.java;

2.11 import导入

作用：导入相关类。

导入规范：import 包名.类名/接口名

静态导入：import static 包名.类.静态成员

特点：可以使用“*”代表包下的所有类或接口；java.lang包下接口或类自动导入不需要import ;如： String ,System,Math等

注意：如果调用不同包中的相同类名，创建对象时要定义类的全路径。如：包名.类名对象=new包名.类名（）；

import com.refuel.java.Test;
import static java.lang.System.out;
public class TestPckage {
public static void main(String[] args) {
	Test t  = new Test();
	out.println(t.name);
	com.aura.java1.Test t1 = new com.aura.java1.Test();
	out.println(t1.age);
  }
}
class Test{
    String name;
    int age;
}