面向对象之类的使用

本文将通过介绍使用类的步骤对类的相关知识进行总结。

文中提出的步骤并不一定是实际操作中的顺序或者必要的步骤，只是为了更好的总结而为之

使用预定义类

所谓预定义类即为Java设计者们向使用者提供的已经设计好的类。可以通过官方API文档进行查看。
使用预定义类主要分为以下几个步骤：

第一步：导入包

java中一个类一定是在某一个中。如果需要使用某一个类，必须向编译器说明导入该类所在的包及其位置。

导入一个包有以下三种方式：
第一种：完全限定名
这种方式是在使用某一个类时，将包名和类名完整的写下来：

1
java.time.LocalDate today = java.time.LocalDate.now;// 这里实例化了一个LocalDate类

这种方式的缺点是以后每次需要实例化一个类时，都需要这样写。会很麻烦。
第二种：使用import
使用import导入包或者类之后将不需要完整的写下包名。

  • 导入一个包中所有的类：import < package name >.*

如：import java.time.*;// 导入了java.time包中所有的类

  • 导入一个特定的类：import < package name >.classname

如：import java.time.LocalDate;// 导入了java.time包中所有的类

在java不同的包可能有相同的类名，在使用这些类时需要告诉编译器你正在使用那个类。
例如：java.util包和java.sql包中都有Date类。如在程序中同时导入了这两个包，在使用Date类时将会报错。
这是后可以加上一句：

import java.util.Date;​

这将告诉编译器，在本程序中使用的Date类都是java.util包中的Date类。
或者在使用Date类时再告诉编译器，究竟使用的是那个包中的Date类。

var today = new java.util.Date()//这将告诉编译器，这个today对象使用的是java.util包中的Date类。

第三种静态导入
再import后面加入static类将会告诉浏览器只导入指定包中的所有类的静态方法和静态字段（前提是存在静态方法和静态字段，如果没有则会报错）
例如在程序中导入：

import static java.lang.System.*;

则在程序中可以直接使用 out.println()方法打印东西。

第二步 使用构造器实例化一个对象

在Java中任何类的使用都要使用构造器构造一个对象，然后才能通过这个对象使用类中的方法。
语法为：new 类名

关于构造器将会在后面进行详细介绍。

使用

实例化一个对象之后就可以通过这个对象来调用类中的方法了。

  • 直接将对象传递给一个方法

System.out.println(new Date())//将会输出当前时间

  • 直接对对象运用方法

String Today = new Date().toString();//将当前日期转换为字符串传递给Today变量

这两种方法构造出的对象将会只能使用一次，如果下次需要使用则需要继续构造。

  • 将对象传递给一个对象对象变量

Date Today = new Date()//将对象传递给了Today变量，并且 该对象可以使用任意次​​.

使用用户自定义类

虽然Java的设计者给我们提供了种类繁多的格式个样的类,但是也一定无法完全满足,我们日常开发中对类的需求.所以,在项目的实施过程中,也需要自己定义出需要的类.

第一步:创建一个类

这一步通常是只用IDE软件完成,在创建类的时候子需要选择类需要在的包,并且给类设定一个名字(命名规则同变量),即可.通常类的名字与类的文件名是一样的.并且在类的最开始出将会自动给出用于告诉编译器类的位置的语句,如:

package cons;

并且会将类自动的设定为public.

第二步 创建构造器

所谓的构造器主要是用于将类设定为指定的初始状态在创建构造器是需要注意以下几点:
第一： 构造器需要与类的名字一样.
第二： 每一个类可以有一个或以上的构造器.如果没有自定义构造器，编译器将会自动提供一个无参构造器，并将实例字段初始化为默认设置(比如将double类型的实例字段初始化为0.0等).当该类拥有参数构造器，但是没有设定无参构造器时，将不会提供无参构造器。构造器将会通过参数情况选择正确的构造器,如果构造对象时没有提供正确的参数，将会报错.

现在创建一个text类(在同一个包中)，并在类中写入以下内容

1
2
3
4
public class text {
	String s;
	}
}

然后在程序中使用这个类：

1
2
text t = new text();
System.out.println(t.s);//将会输出null

现在再将text类改写为：

1
2
3
4
5
6
7
8
9
10
public class text {
	String s;
	
	public text() {//无参构造器
		s = "我没有参数";	
	} 
	public text(int num) {//接收一个int类型的数值
		s = "我有参数";	
	} 
}

再使用这个类

1
2
3
4
text t1 = new text();
System.out.println(t1.s);//输出：我没有参数
text t2 = new text(3);//输出：我有参数
System.out.println(t2.s);

第三： 构造器没有返回值。
如果在上面的构造器中加入

return 0;

将会报错：

Void methods cannot return a value

第四： 构造器总是伴随着操作符new一起被调用。

构造器的调用顺序为：
1.如果构造器的第一行调用了另一个构造器，则基于所提供的参数执行第二个构造器。
2.否则，将所有数据字段初始化为默认值，并按照在类的声明中出现的顺序，执行所有字段初始化方法或初始化块。
3.执行构造器的主体代码

现在将text类中的内容改写为以下内容：

1
2
3
4
5
6
7
8
9
10
11
public class text {
	static String s;
	
	public text() {
		s = "我没有参数";
		text t3 = new text(3);//在无参构造器中调用了下面的构造器
	} 
	public text(int num) {
		s = "我有参数";
	} 
}

在使用该类：

1
2
3
4
text t1 = new text();
System.out.println(t1.s);//将会输出：我有参数，说明第二个构造器被执行
text t2 = new text(3);
System.out.println(t2.s);//输出：我有参数

第三步:创建实例字段

实例字段主要是用来表示对象初始化状态的一类变量，这些变量将会在构造器中被初始化为指定的状态（或默认状态）。例如，上例text类中的：

String s;

就是一个实例字段。

设置访问权限

首先，我们需要给我们的实例字段设定访问权限(即谁可以访问我)。

  • 默认情况。默认情况下是只要是同一个包内的另一个类可以使用。上例中使用了text类中的s实例对象就没有报错。

现在我们建立另外一个包，并在里面创建一个friend类。在里面写入以下内容：

1
2
3
4
5
6
7
8
9
package text;//包名
import cons.text;//引入text类
public class friend {
	public void text() {
	String b;
	text t = new text();//使用text类
	b = t.s;//会报错，因为在text类中的s没有声明为public。
	}
}
  • public。有public关键词的实例对象将允许任何类访问(即使不在同一个包中)。上例中如果将text类中的s前面加上public将不会报错。
  • private。有private关键字的实例对象将不允许其他的类访问这个实例对象，这个实例对象仅能在自己所在的类中被调用。
    在Java中。一般我们会将类中的实例字段声明为private，并在类中创建一个字段更改其(setter+字段名)和字段访问器（getter+字段名）。这样做更加符合类的封装性，我们恶意很清楚的知道在什么时候对那个类中的字段进行了修改。于是我们因该将text类中的改为如下内容：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public class text {

    	private String s;
    	
    	public void setters(String s) {//修改器
    		this.s=s;
    	}
    	
    	public String getters() {//访问器
    		return s;
    	}
    }
    现在再来使用text类：
    1
    2
    3
    4
    5
    public static void main(String[] args) {
    	text t1 = new text();
    	t1.setters("我改了");
    	System.out.println(t1.getters());//将会打印：我改了
    }

    设置读写权限

    设置完字段的访问权限之后，我们需要再来设置字段的读写权限。
    • 默认情况：再不加任何相关关键字的情况下字段将可读可写。
    • final:将字段设置为常量，这将使得改字段再任何情况下都能更改。
1
2
3
4
5
6
7
8
9
10
11
12
public class text {

	private final String s;//设置为常量
	
	public void setters(String s) {
		this.s=s;//将会报错
	}
	
	public String getters() {
		return s;
	}
}
  • static：所有使用这个类创建的对象将会共享这个字段，即一个对象对这个字段进行了更改，另一个对象中也会更改。

将text类改为以下内容

1
2
3
4
5
6
7
8
9
10
11
12
public class text {

	private static String s;//设置为静态
	
	public void setters(String s) {
		this.s=s;
	}
	
	public String getters() {
		return s;
	}
}

现在再来使用这个类：

1
2
3
4
5
6
public static void main(String[] args) {
	text t1 = new text();
	text t2 = new text();
	t1.setters("我要改t2");
	System.out.println(t2.getters());//将会打印：我要改t2
	}

初始化字段

设置完实例字段的相关权限之后，接下来我们就要来考虑一下它们的初始状态，我们可以再以下几个地方进行初始化：

  • 构造器
  • 声明时
  • 初始化块中

将text类改为以下内容：

1
2
3
4
5
6
7
8
9
10
11
12
public class text {
	 String s1 = "我是声明";
	 String s2;
	 String s3;
	 {
		 s2 = "我是初始化块";
	 }
	public text() {
		s3 = "我是构造器";
	}

}

再来使用：

1
2
3
4
5
6
7
public static void main(String[] args) {
		text t2 = new text();
		System.out.println(t2.s1);//我是声明
		System.out.println(t2.s2);//我是初始化块
		System.out.println(t2.s3);//我是构造器
		
	}

构造方法

设置完字段之后，接下来就因该给这个类设置一些方法了。

设置方法的访问权限

需要设置的访问权限有两种（是自己用？还是大家用）

  • 默认情况：跟字段一样，默认情况是再同一个包中的可以使用。
  • public：大家都可以用。
  • private：只有自己可以使用

我们给text中加入两个方法来实现冒泡排序，其中一个方法用来比较大小(设为public)，另外一个方法用来交换（设为private）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class text {

	public int max(int[] info,int num) {//求数组中最大的数
		int max = 0;
		for(int i = 0;i < num;i++)
		{
			max = isMax(max,info[i]);//调用isMax方法
		}
		return max;
	}
	
	private int isMax(int max,int num)//返回两个数中较大的数
	{
		if(max < num)
			max = num;
		return max;
	}
}

使用这个方法：

1
2
3
4
5
6
7
public static void main(String[] args) {
	text whoismax = new text();
	int[] num = {23,134,933,34,930, 45};

	System.out.println("the max numble is:"+whoismax.max(num,num.length));//将会返回933
		
	}

如果直接调用isMax方法将会报错。

设置静态方法

在之前使用预定义中提到可以导入类中的静态方法，现在将对静态方法进行一个简单介绍。
在使用静态方法是需要注意以下几点：

  • 非静态方法既可以访问静态数据成员 又可以访问非静态数据成员，而静态方法只能访问静态数据成员；
    1
    2
    3
    4
    5
    6
    public class text {
    	String s;
    	public static String text() {
    		return s;//将会报错，因为s不是静态数据
    	} 
    }
  • 非静态方法既可以访问静态方法又可以访问非静态方法，而静态方法只能访问静态数据方法。
1
2
3
4
5
6
7
8
9
public class text {
	String s;
	public static String text1() {
		text2();//将会报错，因为text2不是静态方法
	}
	public  String text2() {
		return s;
	} 
}
  • 当有某一个类构造了多个对象，则这几个对象将操作同一个静态方法（即静态方法共享内存）

我们在text类总设置一个静态方法，返回静态字符串s当前的值

1
2
3
4
5
6
7
8
public class text {
	static String s;
	public static String name(String name)
	{
		s = name;
		return s;
	}
}

并调用它：

1
2
3
4
5
6
7
8
9
public static void main(String[] args) {
		text name1 = new text();
		text name2 = new text();
		System.out.println("name1中s为："+name1.name("first"));//将会输出first
		System.out.println("name2中s为："+name2.s);//虽然name2对象中的s值没有设置，但是它与那么共享，将会输出first
		
		System.out.println("name2中s为："+name2.name("next"));//将会输出next
		System.out.println("name1中s为："+name1.s);//由于s的值已经通过name2修改，所以name1中的s值为：next
	}

其在内存中的示意图，可以简略的用以下方式表示：

  • 静态方法可以不使用对象，而直接调用。也就是没有隐式参数
    如：Math.pow()

设置方法名

方法名是用来告诉编译器我们正要使用该类中的哪一个方法。其命名又以下规则:

  • 命名规则同变量的命名规则
  • 最好使用小驼峰命名法，并且方法名能够说明该方法可以做什么

此外在java中还有方法的重载形式，它允许存在多有方法名相同，但是参数不同(个数、类型、顺序等)的方法，这使得我们可以为一些需要考虑输入数据的类型进行不同处理以达到相同作用的方法设置相同的方法名。例如：println方法就可以根据用户传入的数据类型选择合适的方法以显示。

设置参数

在方法中有时候需要用户传入一些数据，有时候需要使用已经定义的实例变量，需要根据实际需要进行选择。这些参数可以被分为两种类型：

  • 显式参数：就是在方法名义中的小括号中写明的，明确的告诉用户需要传入什么类型的数据。如，上例中，text类的name方法的字符串name就是一个显式参数。
  • 隐式参数：在方法的声明中并没有明确的写出来，但是在实际操作中需要使用到类中的其他变量，例如name方法就使用了静态变量s。这是s就是一个隐式参数。

但是如果我将text类中name方法改成：

1
2
3
4
5
6
7
8
public class text {
	static String name;
	public static String name(String name)//返回两个数中较大的数
	{
		name = name;
		return name;
	}
}

这是的隐式参数和显示参数名字都是name，现在再调用：

1
2
3
4
5
6
7
8
9
public static void main(String[] args) {
		text name1 = new text();
		text name2 = new text();
		System.out.println("num1中s为："+name1.name("first"));//first
		System.out.println("num2中s为："+name2.name);//null
		
		System.out.println("num2中s为："+name2.name("next"));//next
		System.out.println("num1中s为："+name1.name);//null
	}

这是为什么呢？
因为在默认情况下，方法将会使用显示参数，也就是说在上例中，方法使用的都是传入的name值，并没有使用静态字符串name。这种情况下需要使用this关键字告诉编译器，哪里使用的是隐式参数。

1
2
3
4
5
6
7
8
public class text {
	static String name;
	public  String name(String name)//返回两个数中较大的数
	{
		this.name = name;
		return this.name;
	}
}

这样输出的内容与上面的一样。

前面说过在静态方法中没有this关键字，会报错，所以这里不能将方法仍设置为静态

设置方法的变量名

我们需要为方法设置一些需要使用到的变量，这些变量将只会在改方法中有效。

  • 可以定义基本类型变量、定义引用变量或者对象变量
  • 变量名需要符合变量命名规则
  • 如果可以从对象的初始值退推测出变量的类型，则可以使用var关键字

    var Today = new Date()

var只能用于方法中局部变量的命名

幕布版思维导图

本文作者： CodeWhat
本文链接： https://quandongli.github.io/post/cfec4ed.html
版权声明： 本作品采用 知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议 进行许可。转载请注明出处！
知识共享许可协议
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家