很久没有用过Java基本上以前学的都忘的差不多了,现在重新开始学习Java编程并记录部分知识点。

  找工作的时候公司一般都会要求至少掌握一两门编程语言,对于测试来说懂得编程已是必要条件,在2020年学习什么编程语言不会被淘汰呢?下图是TIOBE编程语言受欢迎程度的Top20,具体学习哪门编程语言还需根据自己的工作需求以及兴趣爱好来考虑。
TIOBE Index for January 2020

Java基础语法

多维数组

多维数组是包含一个或多个数组的数组。
要创建一个二维数组,将每个数组添加到其各自的大括号内:
示例:

int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };
int x = myNumbers[1][2];
System.out.println(x); // Outputs 7

myNumbers现在是一个以两个数组为元素的数组。
要访问myNumbers数组的元素,请指定两个索引:一个用于数组,一个用于该数组内的元素。本示例访问myNumbers的第二个数组(1)中的第三个元素(2)。
我们还可以使用for loop另一个内部for loop来获取二维数组的元素(我们仍然必须指向两个索引):
示例:

public class MyClass {
  public static void main(String[] args) {
    int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };
    for (int i = 0; i < myNumbers.length; ++i) {
      for(int j = 0; j < myNumbers[i].length; ++j) {
        System.out.println(myNumbers[i][j]);
      }
    }
  }
}

Java方法

方法重载

使用方法重载,只要参数的数量和/或类型不同,多个方法可以使用相同的名称。
与其定义两个应该做同样事情的方法,不如重载一个方法。
在下面的示例中,我们重载了plusMethod 同时对int 和使用的方法double:
示例:

static int plusMethod(int x, int y) {
  return x + y;
}

static double plusMethod(double x, double y) {
  return x + y;
}

public static void main(String[] args) {
  int myNum1 = plusMethod(8, 5);
  double myNum2 = plusMethod(4.3, 6.26);
  System.out.println("int: " + myNum1);
  System.out.println("double: " + myNum2);
}

类对象

在Java中,从类创建对象。我们已经创建了名为的类MyClass,因此现在可以使用它来创建对象。
要创建的对象MyClass,请指定类名称,然后指定对象名称,并使用关键字new:
示例:

public class MyClass {
  int x = 5;

  public static void main(String[] args) {
    MyClass myObj1 = new MyClass();  // Object 1
    MyClass myObj2 = new MyClass();  // Object 2
    System.out.println(myObj1.x);
    System.out.println(myObj2.x);
  }
}

您还可以创建一个类的对象,然后在另一个类中访问它。这通常用于更好地组织类(一个类具有所有属性和方法,而另一个类则具有main()方法(要执行的代码))。
MyClass.java

public class MyClass {
  int x = 5;
}

OtherClass.java

class OtherClass {
  public static void main(String[] args) {
    MyClass myObj = new MyClass();
    System.out.println(myObj.x);
  }
}

类属性

类属性是类中的变量,可以通过创建类的对象并使用点语法(.)来访问和修改属性,如果创建一个类的多个对象,则可以更改一个对象的属性值,而不会影响另一个对象的属性值。当变量被final修饰时,值不能被覆盖。
示例:

public class MyClass {
  int x = 5;
  final int y = 10;
  public static void main(String[] args) {
    MyClass myObj = new MyClass();
    myObj.x = 10;
    System.out.println(myObj.x);
  }
}

类方法

static修饰的方法直接调用,public声明的方法需要先将类实例化对象,通过对象.方法调用,使用public修饰也可在其它类中通过对象调用属性和方法

public class MyClass {
  // Static method
  static void myStaticMethod() {
    System.out.println("Static methods can be called without creating objects");
  }

  // Public method
  public void myPublicMethod() {
    System.out.println("Public methods must be called by creating objects");
  }

  // Main method
  public static void main(String[] args) {
    myStaticMethod(); // Call the static method
    // myPublicMethod(); This would compile an error
    MyClass myObj = new MyClass(); // Create an object of MyClass
    myObj.myPublicMethod(); // Call the public method on the object
  }
}

构造函数

Java中的构造函数是一种用于初始化对象的特殊方法。创建类的对象时将调用构造函数。可用于设置对象属性的初始值。构造函数还可以采用参数,这些参数用于初始化属性。下面的示例int y向构造函数添加一个参数。在构造函数内部,我们将x设置为y(x = y)。当我们调用构造函数时,我们将一个参数传递给构造函数(5),该参数会将x的值设置为5。可以根据需要设置任意数量的参数,构造函数的参数之间用逗号隔开,当对象实例化调用构造函数时也应赋予相同数量和类型的参数。
示例:

public class MyClass {
  int x;

  public MyClass(int y) {
    x = y;
  }

  public static void main(String[] args) {
    MyClass myObj = new MyClass(5);
    System.out.println(myObj.x);  // Outputs 5
  }
}

修饰符

访问修饰符

修饰类:

  • public:该类可以被任何其他类访问

  • default: 该类只能由同一包中的类访问。当不指定修饰符时使用。

修饰属性,方法和构造函数:

  • public:该属性方法构造函数可用于所有类
  • private: 该属性方法构造函数只能在声明的类中访问
  • default: 该属性方法构造函数只能在同一程序包中访问。当不指定修饰符时使用。
  • protected:该属性方法构造函数可在相同的包和子类中访问。

非访问修饰符

修饰类:

  • final: 该类不能被其他类继承
  • abstract: 该类不能用于创建对象(要访问抽象类,它必须从另一个类继承。

修饰属性,方法和构造函数:

  • final: 属性和方法不能被覆盖/修改
  • static: 属性和方法属于类,而不是对象,调用需要先对象实例化
  • abstract: 只能在抽象类中使用,并且只能在方法上使用。该方法没有主体,例如abstract void
    run(); 主体由子类提供(从继承)。
  • transient: 序列化包含属性和方法的对象时,将跳过这些属性和方法。
  • volatile:属性的值不在线程本地缓存,并且始终从“主内存”中读取

一种abstract方法属于一个abstract类,并且它不具有体。该主体由子类提供:
示例:

// Code from filename: Person.java
// abstract class
abstract class Person {
  public String fname = "John";
  public int age = 24;
  public abstract void study(); // abstract method
}

// Subclass (inherit from Person)
class Student extends Person {
  public int graduationYear = 2018;
  public void study() { // the body of the abstract method is provided here
    System.out.println("Studying all day long");
  }
}
// End code from filename: Person.java

// Code from filename: MyClass.java
class MyClass {
  public static void main(String[] args) {
    // create an object of the Student class (which inherits attributes and methods from Person)
    Student myObj = new Student();

    System.out.println("Name: " + myObj.fname);
    System.out.println("Age: " + myObj.age);
    System.out.println("Graduation Year: " + myObj.graduationYear);
    myObj.study(); // call abstract method
  }
}

封装

封装确保对用户隐藏“敏感”数据,将类变量/属性声明为 private,提供公共获取 和设置方法以访问和更新private 变量的值。
get方法返回变量值,set方法设置该值,后跟变量名,首字母大写。
示例:

public class Person {
  private String name; // private = restricted access

  // Getter
  public String getName() {
    return name;
  }

  // Setter
  public void setName(String newName) {
    this.name = newName;
  }
}

该get方法返回变量的值name,set方法采用参数(newName)并将其分配给name变量。所述this关键字被用于指当前对象。
但是,由于name变量声明为private,所以我们 不能从此类外部访问它,需要使用getName()和setName()方法访问和更新变量:
示例:

public class MyClass {
  public static void main(String[] args) {
    Person myObj = new Person();
    myObj.name = "John";  // error
    myObj.setName("John"); // Set the value of the name variable to "John"
    System.out.println(myObj.getName());  // Outputs "John"
  }
}

包和API

内置软件包(来自Java API的软件包)

Java API是Java开发环境中包含的,可免费使用的预编写类的库。该库分为包和类,既可以导入单个类(以及其方法和属性),也可以导入包含属于指定包的所有类的整个包。通过import关键字导入,完整列表可以在Oracle网站上找到:Java™ Platform, Standard Edition 8 API Specification

用户自定义包

要创建一个包,使用package关键字:
示例:

package mypack;
class MyPackageClass {
  public static void main(String[] args) {
    System.out.println("This is my package!");
  }
}

将文件另存为MyPackageClass.java,然后进行编译:

C:\Users\Your Name>javac MyPackageClass.java

编译包:

C:\Users\Your Name>javac -d . MyPackageClass.java

这将强制编译器创建“ mypack”包。
该-d关键字指定在哪里保存类文件的目标。您可以使用任何目录名称,例如c:/ user(windows),或者,如果要将软件包保留在同一目录中,则可以使用点号“ .”编译软件包时,创建了一个新文件夹,称为“ mypack”。
运行MyPackageClass.java文件:

C:\Users\Your Name>java mypack.MyPackageClass

继承

可以将属性和方法从一个类继承到另一个类。我们将“继承概念”分为两类:

  • 子类:从另一个类继承的类
  • 超类(父类):从其继承的类

从类继承,使用extends关键字:
在下面的示例中,Car类(子类)从Vehicle类(超类)中继承属性和方法:
示例:

class Vehicle {
  protected String brand = "Ford";        // Vehicle attribute
  public void honk() {                    // Vehicle method
    System.out.println("Tuut, tuut!");
  }
}
class Car extends Vehicle {
  private String modelName = "Mustang";    // Car attribute
  public static void main(String[] args) {
    // Create a myCar object
    Car myCar = new Car();
    // Call the honk() method (from the Vehicle class) on the myCar object
    myCar.honk();
    // Display the value of the brand attribute (from the Vehicle class) and the value of the modelName from the Car class
    System.out.println(myCar.brand + " " + myCar.modelName);
  }
}

输出:

Tuut, tuut! //对象的实例.父类的方法
Ford Mustang //对象的实例.父类的属性 对象的实例.子类的属性

如果不希望其它类继承这个类,使用final关键字

多态

多态是同一个行为具有多个不同表现形式或形态的能力。继承使我们可以从另一个类继承属性和方法,多态使用这些方法来执行不同的任务。例如定义一个超类Animal,该类具有方法animalSound()。动物的子类可以是猪,狗,并且它们具有自动动物声音实现的方式。
示例:

class Animal {
  public void animalSound() {
    System.out.println("The animal makes a sound");
  }
}
class Pig extends Animal {
  public void animalSound() {
    System.out.println("The pig says: wee wee");
  }
}
class Dog extends Animal {
  public void animalSound() {
    System.out.println("The dog says: bow wow");
  }
}

现在可以创建Pig类和Dog类的对象,并在两个类的对象上调用animalSound()方法:

class MyMainClass{
    public static void main(String[] args){
        Animal myAnimal = new Animal();    //创建一个Animal的对象
        Animal myPig = new Pig();    //创建一个Pig的对象
        Animal myDog = new Dog();    //创建一个Dog的对象
        myAnimal.animalSound();    //输出父类方法:The animal makes a sound
        myPig.animalSound();    //输出子类重写的方法:The pig says: wee wee
        myDog.animalSound();    //输出子类重写的方法:The dog says: bow wow
    }
}

内部类

嵌套类(类中的一个类),要访问内部类需要先创建外部类的对象,然后创建内部类的对象。
示例:

class OuterClass {
    int x = 10;
    class InnerClass {
        int y = 5;
        public int myInnerMethod() {
            return x;
        }
    }
}
public class MyMainClass {
    public static void main(String[] args) {
        OuterClass myOuter = new OuterClass();
        OuterClass.InnerClass myInner = myOuter.new InnerClass();
        System.out.println(myInner.y + myOuter.x);
        System.out.println(myInner.myInnerMethod());
    }
}

当Private修饰内部类时,外部对象将无法访问内部类。
当Static修饰内部类时,可以不创建外部类对象访问内部类,无法访问外部类的成员。

抽象

接口

枚举

用户输入

日期

ArrayList

HashMap

包装

异常

文件处理

创建写入

读取

删除

参考

关键字

字符串方法

数学方法

示例

练习

Last modification:February 21st, 2020 at 07:13 pm
如果觉得我的文章对你有用,请随意赞赏,感谢!