简介: 主要内容 Java 中的方法递归算法接收键盘中的输入面向对象的本质我的第一个类：Student垃圾回收机制构造方法方法的 重载 static声明的静态属性和静态方法this关键字的使用笔记详解1. Java中的方法我们在Java中可以将完成 …

Java 黄色键盘按钮

主要内容

Java中的方法
递归算法
接收键盘中的输入
面向对象的本质
我的第一个类：Student
垃圾回收机制
构造方法
方法的重载
static声明的静态属性和静态方法
this关键字的使用
笔记详解

1. Java中的方法

我们在Java中可以将完成某一个功能的若干行代码组织起来，然后给这些组织起来的代码起一个名字，这样以后想要使用这些代码，直接通过这个名字来调用即可。这就是Java中的方法，在其他语言中也成为函数。
要注意的是，Java中的方法只支持值传递，不支持引用传递。方法定义的实例如下：
public class test Method {
// 定义一个方法，该方法没有返回值，所以使用 void

 tpublic static void showName() {
ttSystem.out.println("我的名字是Tom");
t}
t// 定义一个方法，该方法的返回值类型是int，所以使用int
tpublic static int add(int a, int b) {
ttint sum = a + b;
ttreturn sum;
t}
tpublic static void main(String[] args) {
tt// 调用之前定义的方法
ttshowName();
ttint sum = add(3, 5);
ttSystem.out.println("最终的计算结果是： " + sum);
t}
}  

2. 递归算法

递归算法是Java中常见且使用的一类算法，它的主要思路是一个方法通过不断调用自身，来将问题简单化。我们在写递归算法的时候，主要考虑到两方面：递归体和递归出口。
一个递归算法必须要有递归出口，否则该方法会不断调用自身，出现死循环，最终导致栈溢出。所以在递归算法中要定义一个递归出口，告诉程序什么时候不再调用该方法。
递归体是递归算法的主要内容，一个方法不断地调用自身，就是通过递归体来将问题简单化，从而一步步解决问题。
下面给出一个实例：使用递归算法计算阶乘

 public static int factorial(int a) {
tif (a > 1) { // 调用递归
ttreturn a * factorial(a - 1);
t} else { // 递归出口，不再调用递归
ttreturn 1;
t}
}  

3. 接收键盘中的输入

在Java中接收键盘输入的内容，首先要通过 import java.util.Scanner; 引入 util 包中的 Scanner 类，然后通过这个类来获取键盘输入的内容。下面给出两个实例：
实例一：接收键盘输入的字符串，并打印出来

 public static void inputString() {
tScanner s = new Scanner(System.in);
tSystem.out.print("请输入一个字符串：");
tString str = s.next();
tSystem.out.println(str);
ts. close ();
}  

实例二：接收键盘中输入的整数，进行计算并输出

 public static void add() {
tScanner num = new Scanner(System.in);
tSystem.out.print("请输入一个整数：");
tint a = num.nextInt();
tSystem.out.print("请输入另外一个整数：");
tint b = num.nextInt();
tSystem.out.println("计算结果为：" + (a + b));
tnum.close();
}  

4. 面向对象的本质

以类的方式组织代码，以对象的方式封装数据

5. 我的第一个类：Student

正式接触面向对象编程，我的第一个类是很普通的Student类，类中包括自己的属性和方法，然后通过这个类去定义学生对象。

 public class Student {
t// 类的静态属性
tString name;
tint age;
tString gender;
tint height;
t
t// 类的方法
tpublic void study() {
ttSystem.out.println(name + "正在学习Java!");
t}
tpublic void sayHello(String userName) {
ttSystem.out.println(name + "向" + userName + "说：你好");
t}
t
t// 程序的主入口，虽然写在Student类中，但是在逻辑上和Student类没有联系
tpublic static void main(String[] args) {
ttStudent Tom = new Student();
ttStudent Jane = new Student();
tt
ttTom.name = "Tom";
ttJane.name = "Jane";
tt
ttTom.study();
ttJane.sayHello("Jack");
t}
}  

6. 垃圾回收机制

Java中存在垃圾回收机制，是用来对不再使用的对象进行清理，避免带来的内存占用问题。Java中的垃圾回收机制和C++中的有所不同。在C++中，垃圾回收机制是程序员来手动完成的，也就是说程序员需要手动删除对象，清理垃圾。但是Java中的垃圾回收机制是jdk进行自动完成的，不需要程序员手动清理。虽然这回有一定的系统开销，但是却可以避免人工清理的错误。

7. 构造方法

Java中的构造方法是用来初始化类的实例的，构造方法有以下特点：
构造方法是通过 new 语句来完成的
构造方法返回的是类的实例对象，准确的说是这个实例对象的地址。也就是说构造方法是有返回值的，但是在定义构造方法的时候，我们不能使用int等进行设置返回值的类型，同时在构造方法内部也不能有return语句。
构造方法的名字和类的名字必须完全一直
如果我们有定义构造方法，那么会调用此方法来初始化实例对象，如果我们没有定义构造方法，那么系统会自动定义一个没有参数的默认构造方法。
下面展示一个构造方法的实例：

 public class Point {
tdouble x, y, z;
t// 构造方法
tpublic Point(double _x, double _y, double _z) {
ttx = _x;
tty = _y;
ttz = _z;
t}
}  

8. 方法的重载

方法的重载是指在一个类中，可以定义多个相同名字的方法，但是这些方法需要满足以下三个条件中的一个或多个：参数个数不同，参数类型不用，实参顺序不同。在调用此方法时，就可以通过传入的参数就可以决定调用哪一个具体的方法。除了 普通函数以外， 构造函数 也是可以重构的，实例如下：

 public class TestOverLoad {
tpublic double add(int a, int b) {
ttreturn a + b;
t}
tpublic double add(int a, int b, int c) {
ttreturn a + b + b;
t}
tpublic double add(double a, int b) {
ttreturn a + b;
t}
tpublic static void main(String[] args) {
ttTestOverLoad test = new TestOverLoad();
tt// 通过传入的参数不同，来决定调用哪一个具体的方法
ttSystem.out.println(test.add(10, 20));
ttSystem.out.println(test.add(3.5, 20));
ttSystem.out.println(test.add(3, 20, 15));
t}
}  

9. static声明的 静态变量 和静态方法

在Java中，使用static关键字修饰声明的变量和方法叫做静态变量和静态方法。静态变量也可以叫做静态属性或类属性。
静态变量和静态方法是属于类的，是该类的公有属性，而不是某一个实例的属性。即使在程序中没有实名该类的实例，也是可以通过 类名.静态变量名 和 类名.静态方法名 来调用静态变量和静态方法。
在静态方法中只能使用静态属性，不能使用非静态属性。具体实例如下：

 public class TestStatic {
tstatic int mark = 666; // 静态属性
tpublic static void showMark() { // 静态方法
ttSystem.out.println(mark);
t}
t
tpublic static void main(String[] args) {
tt
ttSystem.out.println(TestStatic.mark);tt// 通过类名直接调用静态属性
ttTestStatic.showMark();tt// 通过类名直接调用静态方法
tt
ttTestStatic test = new TestStatic();
ttSystem.out.println(test.mark);ttt// 通过类的实例来调用静态属性
tttest.showMark();tt// 通过类的实例调用静态方法
t}
}  

10. this关键字的使用

在普通方法中，this指向的是正在调用此方法的实例对象；在构造函数中，this指向的是正在初始化的实例对象。要注意的是，不能使用this来调用静态属性和静态方法，因为这二者是从属于类的，而不是从属于实例对象的。
除此之外，我们还可以使用 this() 来调用类中的构造函数，实例如下：
public class TestThis {
int mark;
String name;
public TestThis(int mark, String name) {
this(); // 通过this()调用其他的构造方法
this.mark = mark;
this.name = name;
}
public TestThis() {
this.mark = 0;
this.name = “初始化”;
}
}

今天的学习就先到这里，小编在最后为大家分享适合Java小白和刚开始学习的新手同学的视频教程+学习路线！关注、转发、私信回复：“学习”即可领取！