java-3-面向对象基础

1. 面向对象，在思考时，需要将待处理的事物分类，将数据

   和对数据的操作进行封装，作为一个整体。

　　例子：

public class Car
{
    private String carName;
    private Date madeDate;
    private String color;
    
    public void drive()
    {
        
    }
    
    public static void main(String[] args)
    {
        Car c = new Car();
        c.drive();
    }
}

 

 

2. 构造函数

   在创建类的对象时，有时候需要一些必要的操作，而且若没有进行，后果会很严重。这部分操作可以放在构造函数中，构造函数会在创建对象时被自动调用。

public class Car
{
    private String carName;
    private String color;
    
    Car()
    {
        carName = "newcar";
        color = "red";
    }
    public void drive()
    {
        
    }
    
    public static void main(String[] args)
    {
        Car c = new Car();
        c.drive();
    }
}

 

3. 构造函数和成员函数类似，可以被才重载

public class Car
{
    private String carName;
    private String color;
    
    Car()
    {
        carName = "newcar";
        color = "red";
    }
    
    Car(String carName, String color)
    {
        this.carName = carName;
        this.color = color;
    }
    public void drive()
    {
    }
    
    public static void main(String[] args)
    {
        Car c = new Car();
        c.drive();
    }
}

程序运行时，编译器会根据函数的参数个数，类型来选择执行哪个函数。

this是一个特殊的对象，指的是调用这个函数的那个对象。

 

 4. static成员变量，成员函数

static变量，也叫做类变量，是整个类的变量，只有一份，所有该类的对象共享。

static函数，函数不管是否是static，都只有一份代码。static函数可以直接通过类来调用。

import java.util.Date;


public class Car
{
    private String carName;
    private String color;
    static int carNumber = 0;
    
    Car()
    {
        carName = "newcar";
        color = "red";
        carNumber++;
    }
    
    Car(String carName, String color)
    {
        this.carName = carName;
        this.color = color;
    }
    public void drive()
    {
    }
    
    public int getCarNum()
    {
        return carNumber;
    }
    
    public static void main(String[] args)
    {
        Car c = new Car();
        c.drive();
    }
}

静态方法不能访问非静态方法和变量

非静态方法可以访问静态方法和变量

 

5 static块和初始化顺序

public class TestStatic
{
    private static int i = 1;
    
    static
    {
        i = 10;
    }
    public static void main(String[] args)
    {
        System.out.println(i);
    }
}

结果为10

public class TestStatic
{
    static
    {
        i = 10;
    }
    private static int i = 1;
    
    public static void main(String[] args)
    {
        System.out.println(i);
    }
}

结果为1 

 

6 常量

private static final double PI = 3.14;

java中可以通过final关键字指定变量为常量，一旦被初始化赋值，不能再被修改。

且常量被定义时，若不是static ,可以定义时初始化。或者，在构造函数中初始化。

当是static,则一定要在定义时初始化。

而且，一般来说，常量在类中都作为static变量存在，节省空间。

 

7 继承

 java中允许类的继承，一方面是现实生活中，不同的类之间确实存在这样的关系，第二

是继承可以实现重用，可以从已有的资源中简单的实现我们需要的功能。

package animal.com.wyq;

public class Animal
{
    private String name;
    public void sleep()
    {
        System.out.println(" animal sellp");
    }
    
    public static void main(String[] args)
    {
        Animal an = new Animal();
        an.sleep();
    }
}

输出：

package animal.com.wyq;

public class Cat extends Animal
{
 
    public static void main(String[] args)
    {
        Cat cat = new Cat();
        cat.sleep();
    }
}

输出：

可以看到，Cat类直接继承了Animal类，直接获得了父类的成员变量和成员函数。

当然，子类可能有和父类相同的方法，也就是接口，但是有不同的实现，因此子类可以

重写父类的方法：

package animal.com.wyq;

public class Cat extends Animal
{
    public void sleep()
    {
        System.out.println(" cat sellp");
    }
    public static void main(String[] args)
    {
        Cat cat = new Cat();
        cat.sleep();
    }
}

输出：

在父类和子类之间，子类重新实现父类方法，override,覆盖，重写。

 

8 继承的构造函数

当构造子类对象时，系统会先调用父类的构造函数，默认是调用不带参数的父类构造函数，在调用子类的构造函数。

当父类没有无参数构造函数时，需要在子类构造函数中，显式得到利用super调用父类的带参构造函数。

package animal.com.wyq;

class Animal
{
    private String name;
    
    Animal(String name)
    {
        this.name = name;
        System.out.println("animal cons");
    }
}

public class Cat extends Animal
{
    Cat()
    {
        super("miao1");
        System.out.println("cat cons");        
    }
 
    public static void main(String[] args)
    {
        Cat cat = new Cat();
     }
}

 父类的构造方法不会被子类继承，所以在子类构造函数中，不能写Animal("miao");

只能用super()关键字。

 

9 多态

当存在类之间的继承关系，而且子类重写了父类的方法，最后，当存在父类引用指向子类对象时，父类调用自己的方法，

实际上调用的是子类重写之后的具体实现。

package animal.com.wyq;

class Animal
{
    public void sleep()
    {
        System.out.println("animal sleep");
    }
}

class Cat extends Animal
{
    public void sleep()
    {
        System.out.println("Cat sleep");
    }
}

class Dog extends Animal
{
    public void sleep()
    {
        System.out.println("Dog sleep");
    }
}


public class Test
{
    public static void TestSleep(Animal an)
    {
        an.sleep();
    }
    
    public static void main(String[] args)
    {
        Animal an = new Cat();
        Test.TestSleep(an);
        
        an = new Dog();
        Test.TestSleep(an);

      }
}

输出

这样，可以清楚的看到多态的好处，具体的函数的参数使用父类引用，当我们实际中传入的是某个具体的子类

则在调用方法时，就会调用对应的子类的具体实现。

 

instanceof操作符：判断一个对象是否是某个类的对象

package animal1.com.wyq;

class Animal
{
}

class Cat extends Animal
{
}

public class Test1
{
    public static void main(String[] args)
    {
        Cat cat = new Cat();
        
        boolean bool = (cat instanceof Cat);
        System.out.println(bool);
        
        bool = (cat instanceof Animal);
        System.out.println(bool);
      }
}

输出，两true