【cs61b】学习笔记day1

1.1 java基础

Hello World

• java程序由一个类声明组成，使用关键字public class声明。在Java中，所有代码都位于类中。

• 运行的代码在一个名为main的方法中，该方法被声明为public static void main(String[] args)。

• 我们使用大括号{}表示一段代码的开始和结束。语句必须以分号结束

运行java程序

执行Java程序最常见的方法是通过两个.program的序列运行它。第一个是Java编译器，或javac。第二个是Java解释器(Java)。

变量和循环

• 所有的变量必须在使用之前声明，并且必须给它一个指定类型，而且这个类型在后面的程序中不可改变，类型在代码运行前就被验证
• 循环定义包含在花括号内，测试的布尔表达式包含在圆括号内。
• 我们的print语句只是System.out.print而不是System.out.println。这意味着我们不应该包括换行符(return)。
• print语句将一个数字添加到空格中。这样可以确保数字不会相互碰撞。
• 在这些特性中，最重要的一个是 声明一个有指定类型的变量。

静态类型

Java最重要的特性之一是所有变量和表达式都有一个称为静态类型。
Java变量可以包含这种类型的值，而且只能包含这种类型的值。
此外，变量的类型永远不能改变。
Java编译器的关键特性之一是它执行静态类型检查。

静态类型具有以下优点:

• 编译器确保所有类型都是兼容的，使程序员更容易调试他们的代码。
• 由于代码保证没有类型错误，编译程序的用户永远不会遇到类型错误。例如，Android应用程序是用Java编写的，并且通常只以.class文件的形式分发，即以编译格式分发。因此，这样的应用程序永远不会因为类型错误而崩溃，因为编译器已经检查过它们了。
• 每个变量、参数和函数都有声明的类型，使程序员更容易理解和推理代码。
  在Java中，我们可以说System.out.println (5 + " ");
  但是在Python中，我们不能说print(5+“horse”)为什么会这样呢?
  考虑这两个Java语句:

String h = 5 + "horse";
int h = 5 + "horse";

第一个会成功，第二个将给出一个编译器错误。由于Java是强类型的，如果您告诉它h是一个字符串，它可以将元素连接起来并给您一个字符串。但是当h是int型时，它不能把一个数字和一个字符串连接起来然后给你一个数字。
Python不限制类型，也不能假设你想要什么类型。x =5 +“horse”应该是一个数字吗?一个字符串?Python不知道。所以它出错了。

函数定义

在Python等语言中，函数可以在任何地方声明，甚至可以在函数外部声明。
在java中，不能在外面定义一个函数，所有的函数必须是类的一部分，类中的函数成为方法，所以在java中所有的函数都是方法。
函数的所有参数必须有声明的类型，Java中的函数只能返回一个值

好的编程风格的一些最重要的特征是:

• 一致的风格(空格、变量命名、大括号风格等)
• 大小(行不要太宽，源文件不要太长)
• 描述性命名(变量、函数、类)，例如变量或函数的名称为year或getUserName，而不是x或f。
• 避免重复代码:除了一些更改之外，您几乎不应该有两个重要的代码块几乎相同。
• 在适当的地方注释。Java中的行注释使用//分隔符。块(也就是多行注释)注释使用/* 和 */。
  黄金法则是:编写代码时要让陌生人也能很容易理解。

break & continue

• continue语句跳过循环当前迭代的其余部分，有效地直接跳转到增量条件。
• break关键字在调用时完全终止最内层循环。

1.2 定义和使用类

静态 & 非静态方法

静态方法

Java中的所有代码都必须是类的一部分(或类似于类的东西，我们将在后面学习)。大多数代码都是在方法内部编写的。
让我们考虑一个例子:

public class Dog {
    public static void makeNoise() {
        System.out.println("Bark!");
    }
}

如果尝试运行Dog类，我们只会得到一条错误消息:

$ java Dog
Error: Main method not found in class Dog, please define the main method as:
       public static void main(String[] args)

我们定义的Dog类不做任何事情。我们简单地定义了狗狗可以做的事情，即制造噪音。要实际运行这个类，我们要么需要向Dog类添加一个主方法。或者我们可以创建一个单独的DogLauncher类来运行来自Dog类的方法。例如，

public class DogLauncher {
    public static void main(String[] args) {
        Dog.makeNoise();
    }
}

实例变量和对象实例化

一些关键的观察和术语:

• Java中的对象是任何类的实例。
• Dog类有自己的变量，也称为实例变量或非静态变量。这些变量必须在类中声明，这与Python或Matlab等语言不同，这些语言可以在运行时添加新变量。
• 我们在Dog类中创建的方法没有static关键字。我们称这种方法为实例方法或非静态方法。
• 要调用makeNoise方法，我们必须首先使用new关键字实例化Dog，然后使特定的Dog吠叫。换句话说，我们调用d.makeNoise()代替Dog.makeNoise()
• 对象实例化后，可以将其赋值给已声明的适当类型的变量，例如d = new Dog();
• 类的变量和方法也称为类的成员。
• 使用点表示法访问类的成员。

Java构造函数

构造函数，实例化是参数化的，从而节省了我们手动输入许多实例变量赋值的时间和混乱。

public class DogLauncher {
    public static void main(String[] args) {
        Dog d = new Dog(20);
        d.makeNoise();
    }
}

类方法和实例方法

Java允许定义两种类型的方法:

• 类方法，也就是静态方法。
• 实例方法，也就是非静态方法。

实例方法是只能由类的特定实例执行的操作。静态方法是类本身采取的操作。两者在不同的情况下都是有用的。作为静态方法的一个示例，Math类提供了一个sqrt方法。因为它是静态的，我们可以这样调用它:

x = Math.sqrt(100);

如果sqrt是一个实例方法，我们就会得到下面这种的语法。

Math m = new Math();
x = m.sqrt(100);

有时，一个类同时具有实例方法和静态方法是有意义的。例如，假设想要比较两只狗的能力。
一种方法是添加一个静态方法来比较Dogs。

public static Dog maxDog(Dog d1, Dog d2) {
    if (d1.weightInPounds > d2.weightInPounds) {
        return d1;
    }
    return d2;
}
//此方法可以通过以下方式调用:
Dog d = new Dog(15);
Dog d2 = new Dog(100);
Dog.maxDog(d, d2);

另一种方法是添加一个非静态方法来比较Dogs。

public Dog maxDog(Dog d2) {
    if (this.weightInPounds > d2.weightInPounds) {
        return this;
    }
    return d2;
}
//调用方式：
Dog d = new Dog(15);
Dog d2 = new Dog(100);
d.maxDog(d2);

用类名调用的是静态方法，用具体实例变量调用的是非静态方法

//test
public static Dog maxDog(Dog d1, Dog d2) {
    if (weightInPounds > d2.weightInPounds) {
        return this;
    }
    return d2;
}

静态变量

类拥有静态变量有时是有用的。这些静态属性是类本身固有的，而不是实例固有的。
例如，我们可能会记录狗的学名(或双名)是“Canis familiaris”:

public class Dog {
    public int weightInPounds;
    public static String binomen = "Canis familiaris";
    ...
}

静态变量应该使用类的名称来访问，而不是使用特定的实例，例如，你应该使用Dog.binomen, 不是 d.binomen。虽然Java在技术上允许您使用实例名访问静态变量，但这是一种糟糕的风格。

/** 
< 10:yip

< 30:
bark

>=30:
woof
*/

public class DogLoop {
    public static void main(String[] args) {
   		Dog smallDog = new Dog(5);
   		Dog mediumDog = new Dog(25);
   		Dog hugeDog = new Dog(150);
 
   		Dog[] manyDogs = new Dog[4];  
        manyDogs[0] = smallDog;
   		manyDogs[1] = hugeDog;    	   
        manyDogs[2] = new Dog(130);
 
   		int i = 0;
   		while (i < manyDogs.length) {
       		Dog.maxDog(manyDogs[i], mediumDog).makeNoise();
       		i = i + 1;
        }
    }
}
/**输出：
bark！
woof
woof
错误
*/

public static void main(String[] args)

有了到目前为止学到的知识，现在是时候揭开我们一直用于main方法的声明的神秘面纱了。把它分成几个部分，

• public:到目前为止，我们所有的方法都以这个关键字开头。
• static:它是一个静态方法，不与任何特定的实例相关联。void:没有返回类型。
• main:方法的名称。
• String[] args:这是传递给main方法的参数。
• 命令行参数由于main是由Java解释器本身而不是另一个Java类调用的，所以提供这些参数是解释器的工作。它们通常引用命令行参数。