Java知识点1

Java类的定义及其实例化

一个类可以包含以下类型变量：

• 局部变量：在方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
• 成员变量：成员变量是定义在类中、方法体之外的变量。这种变量在创建对象的时候实例化（分配内存）。成员变量可以被类中的方法和特定类的语句访问。
• 类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。static 也是修饰符的一种，将在下节讲解。

构造方法

在类实例化的过程中自动执行的方法叫做构造方法，它不需要你手动调用。构造方法可以在类实例化的过程中做一些初始化的工作。构造方法的名称必须与类的名称相同，并且没有返回值。每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认的构造方法。

// 创建对象时传递的参数要与构造方法参数列表对应。

构造方法不能被显示调用。

构造方法不能有返回值，因为没有变量来接收返回值。

创建对象

对象是类的一个实例，创建对象的过程也叫类的实例化。对象是以类为模板来创建的。
在Java中，使用new关键字来创建对象，一般有以下三个步骤：

• 声明：声明一个对象，包括对象名称和对象类型。
• 实例化：使用关键字new来创建一个对象。
• 初始化：使用new创建对象时，会调用构造方法初始化对象。

例如

    
    
    
    

     
     
     
     
Dog myDog; // 声明一个对象
     
     
     
     
myDog = new Dog("花花", 3); // 实例化 
    
    
    
    

也可以在声明的同时进行初始化：

Dog myDog = new Dog("花花", 3);

访问修饰符

访问修饰符也叫访问控制符，是指能够控制类、成员变量、方法的使用权限的关键字。Java支持四种不同的访问权限：

public-共有的，对所有类可见（被声明为public的类、方法、构造方法和接口能够被任何其他类访问）。Java程序的main() 方法必须设置成公有的，否则，Java解释器将不能运行该类。

protected-受保护的，对同一包内的类和所有子类可见 （protected访问修饰符不能修饰类和接口，方法和成员变量能够声明为protected，但是接口的成员变量和成员方法不能声明为protected。
）

private-私有的，在同一类内可见。（私有访问修饰符是最严格的访问级别，所以被声明为private的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为private。声明为私有访问类型的变量只能通过类中公共的Getter/Setter方法被外部类访问。）

public class Dog{
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

  默认的-在同一包内可见。默认不使用任何修饰符。（不使用任何修饰符声明的属性和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为public static final，而接口里的方法默认情况下访问权限为public。）

注意以下方法继承（不了解继承概念的读者可以跳过这里，或者点击 Java继承和多态 预览）的规则：

• 父类中声明为public的方法在子类中也必须为public。

• 父类中声明为protected的方法在子类中要么声明为protected，要么声明为public。不能声明为private。

• 父类中默认修饰符声明的方法，能够在子类中声明为private。

• 父类中声明为private的方法，不能够被继承。

static

类级变量又称全局级变量或静态变量，需要使用static关键字修饰，你可以与 C/C++ 中的 static 变量对比学习。类级变量在类定义后就已经存在，占用内存空间，可以通过类名来访问，不需要实例化。
对象实例级变量就是成员变量，实例化后才会分配内存空间，才能访问。方法级变量就是在方法内部定义的变量，就是局部变量。

this

this 关键字用来表示当前对象本身，或当前类的一个实例，通过 this 可以调用本对象的所有方法和属性

值得注意的是：

• 在构造方法中调用另一个构造方法，调用动作必须置于最起始的位置。
• 不能在构造方法以外的任何方法内调用构造方法。
• 在一个构造方法内只能调用一个构造方法

Java重载

同一个类中的多个方法可以有相同的名字，只要它们的参数列表不同就可以..参数列表又叫参数签名，包括参数的类型、参数的个数和参数的顺序，只要有一个不同就叫做参数列表不同.

public class Demo{
    // 一个普通的方法，不带参数
    void test(){
        System.out.println("No parameters");
    }
    // 重载上面的方法，并且带了一个整型参数
    void test(int a){
        System.out.println("a: " + a);
    }
    // 重载上面的方法，并且带了两个参数
    void test(int a,int b){
        System.out.println("a and b: " + a + " " + b);
    }
    // 重载上面的方法，并且带了一个双精度参数
    double test(double a){
        System.out.println("double a: " + a);
        return a*a;
    }
   
    public static void main(String args[]){
        Demo obj= new Demo();
        obj.test();
        obj.test(2);
        obj.test(2,3);
        obj.test(2.0);
    }
}运行结果：
 No parameters
 a: 2
 a and b: 2 3
 double a: 2.0

说明：

• 参数列表不同包括：个数不同、类型不同和顺序不同。
• 仅仅参数变量名称不同是不可以的。
• 跟成员方法一样，构造方法也可以重载。
• 声明为final的方法不能被重载。
• 声明为static的方法不能被重载，但是能够被再次声明。
  方法的重载的规则：
• 方法名称必须相同。
• 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）。
• 方法的返回类型可以相同也可以不相同。
• 仅仅返回类型不同不足以成为方法的重载。

基本的 Java 类的运行顺序：

我们以下面的类来说明一个基本的 Java 类的运行顺序：

    
    
    
    

     
     
     
     
public class Demo{
     
     
     
     
 private String name;
     
     
     
     
 private int age;
     
     
     
     
 
     
     
     
     
 public Demo(){
     
     
     
     
 name = "微学苑";
     
     
     
     
 age = 3;
     
     
     
     
 }
     
     
     
     
 public static void main(String[] args){
     
     
     
     
 Demo obj = new Demo();
     
     
     
     
 System.out.println(obj.name + "的年龄是" + obj.age);
     
     
     
     
 }
     
     
     
     
} 
    
    
    
    

基本运行顺序是：

1. 先运行到第 9 行，这是程序的入口。
2. 然后运行到第 10 行，这里要 new 一个Demo，就要调用 Demo 的构造方法。
3. 就运行到第 5 行，注意：可能很多人觉得接下来就应该运行第 6 行了，错！初始化一个类，必须先初始化它的属性。
4. 因此运行到第 2 行，然后是第 3 行。
5. 属性初始化完过后，才回到构造方法，执行里面的代码，也就是第 6 行、第 7 行。
6. 然后是第8行，表示 new 一个Demo实例完成。
7. 然后回到 main 方法中执行第 11 行。
8. 然后是第 12 行，main方法执行完毕。

1) 实现 int 和 Integer 的相互转换           int m = 500;    Integer obj = new Integer(m);  // 手动装箱    int n = obj.intValue();  // 手动拆箱

2) 将字符串转换为整数  Integer 类有一个静态的 paseInt() 方法，可以将字符串转换为整数    parseInt(String s, int radix);

3) 将整数转换为字符串  Integer 类有一个静态的 toString() 方法，可以将整数转换为字符串。

继承

继承使用 extends 关键字。单继承性：Java 允许一个类仅能继承一个其它类，即一个类只能有一个父类，这个限制被称做单继承性。后面将会学到接口(interface)的概念，接口允许多继承。

子类可以覆盖父类的方法。子类可以继承父类除private以为的所有的成员。构造方法不能被继承。注意：构造方法不能被继承，掌握这一点很重要。 一个类能得到构造方法，只有两个办法：编写构造方法，或者根本没有构造方法，类有一个默认的构造方法。

super关键字

super 关键字与 this 类似，this 用来表示当前类的实例，super 用来表示父类。super 可以用在子类中，通过点号(.)来获取父类的成员变量和方法.super 也可以用在子类的子类中，Java 能自动向上层类追溯。super 关键字的功能： 调用父类中声明为 private 的变量。点取已经覆盖了的方法。作为方法名表示父类构造方法。

public class Demo{
    public static void main(String[] args) {
        Dog obj = new Dog();
        obj.move();
    }
}
class Animal{
    private String desc = "Animals are human's good friends";
    // 必须要声明一个 getter 方法
    public String getDesc() { return desc; }

    public void move(){
        System.out.println("Animals can move");
    }
}
class Dog extends Animal{
    public void move(){
        super.move();  // 调用父类的方法
        System.out.println("Dogs can walk and run");
        // 通过 getter 方法调用父类隐藏变量
        System.out.println("Please remember: " + super.getDesc());
    }
}

通过 super 调用父类的隐藏变量，必须要在父类中声明 getter 方法，因为声明为 private 的数据成员对子类是不可见的。

调用父类的构造方法.使用默认构造方法来对父类对象进行初始化。当然也可以使用 super 来显示调用父类的构造方法

public class Demo{
    public static void main(String[] args) {
        Dog obj = new Dog("花花", 3);
        obj.say();
    }
}
class Animal{
    String name;
    public Animal(String name){
        this.name = name;
    }
}
class Dog extends Animal{
    int age;
    public Dog(String name, int age){
        super(name);
        this.age = age;
    }

    public void say(){
        System.out.println("我是一只可爱的小狗，我的名字叫" + name + "，我" + age + "岁了");
    }
}

注意的是：

• 在构造方法中调用另一个构造方法，调用动作必须置于最起始的位置。
• 不能在构造方法以外的任何方法内调用构造方法。
• 在一个构造方法内只能调用一个构造方法。

super 与 this 的区别：super 不是一个对象的引用，不能将 super 赋值给另一个对象变量，它只是一个指示编译器调用父类方法的特殊关键字。