面向对象

  • 对象（Object）:
  • 面向对象编程：对象还有对象之间的关系
  • Objects与Class：Object到Class是一种抽象的方式，Class到Object由抽象到具体即实例化的操作 （class是提取共同特征，通过class实例化得到Object）
  • class：包括状态特征和行为特征

对象分析 ——构建类的方法

  1. 状态特征：里面所需要的各种数据、信息
  2. 行为特征：
  • 构造器：构造对象名称必须与类名相同、无返回类型，使用时通过new构造，可以重载。
  • 方法函数：需要对数据的处理，调用Object.Method,有返回类型

类的使用

className objectName;         //对象申明
objectName = new className();//创建


className objectName  = new className([type date]); //对象的实例化（创建）
objectName.method();              //调用类中的方法

构造器

className(){

}//无参构造器(如果类中没有写构造器也是可以的，调用类会默认使用无参构造器)


className([type newDate]){
    oriDate = newDate;
}//有参构造器（构造器重载）

注意：如果存在有参构造器，则默认构造器不会给出

  • 构造器中的this
Circle(){
    this(date1,date2)
}                            //调用类中的有参构造器，data与参数对应

引用类型（引用变量）

  • 实例化对象是对类的引用，而不是生成了一个变量的储存空间（类似Python）
  • 对象成员访问：
Circle c1 = new Circle();    //先创建
c1.method;                    //对象成员

引用变量

  • 引用变量：类是引用类型，在函数中，使用类来声明一个“对象”，如Circle c1 还未实例化，此时c1称作应用变量，通过new实例化后，引用变量指向实例化之后的对象，而不是对象存储在变量中。
  • 类成员： 有static修饰的属性和方法，称为类属性和类方法，可以通过类名调用（如Math库中的E，PI，pow()）
  • 对象成员：在类中的属性（变量）和方法前，没有用static修饰，就是对象成员，称为对象属性和对象方法，必须实例化之后的对象，通过实例化的对象调用
public class Circle {
    static double radius = 1.0;   //加了static可以使用类名调用

    Circle() {

    }

    Circle(double newRadius){
        radius = newRadius;
    }

    static double getArea(){
        return Math.pow(radius,2) * Math.PI;
    }
    double getPermeter(){
        return 2 * Math.PI * radius;
    }
    void setRadius(double newRadius){
        radius = newRadius;
    }
}

需要注意的是，有static修饰的就是属于类的，没有对象也有其存在，static的成员为静态成员，一般为常量，不变(参考Math类中的内容)（思考如Math.pow()）

public class Math{
    static double abs(double a){
        return ···
    }
}//类对象
Math.abs(m);      //类对象的调用

//同名的对象方法，不能多次重复（有参一个，无参一个，一般有参的为类对象，无参的为实例对象）
   double getArea(){
        return Math.pow(radius,2) * Math.PI;
    }


    static double getArea(double radius){
        return Math.pow(radius,2) * Math.PI;
    }

javaAPI查看类包

  1. 上网查看
  2. 本地安装包src.zip

static members

  • static 是属于类的对象，可以用来对实例对象的统计、定义类的常量final static,静态函数
  • 静态函数中的数据只能访问当前类中的静态成员（非静态成员只在实例化后才有用，而静态成员是本生就已经存在的，如果在使用的静态成员，而还未实例化，就会有错误，无法访问，所以静态函数只能使用静态成员，而非静态函数可以使用静态成员和非静态成员）

可见性修饰符

  • 包（packet）
1. public————对外开放
2. 无修饰符————默认对包内开放
3. pravite————私有，对当前类中开放
4. protected————受保护的，子类能访问

把类在函数中对象作为参数传递

public static void changeRadius(Circle c,double newRadius){
    c.setRadius(newRadius);
}//Circle作为参数传递还是type name

This

  • 区分方法参数和类属性参数的修饰符
public class Circle{
    pravite double radius = 1.0;

    public Circle(double radius){
        this.radius = radius;           //不加this修饰，radius被隐藏，无法区分
    }

    public Circle(double newRadius){
        radius = newRadius;                //这样能区分也可
    }
}
  • 通过默认构造器调用有参构造器
public class Circle{
    pravite double radius = 1.0;

    public Circle(){
        this(5.0);                 //既调用有参构造器方法，参数与有参匹配,而且不能省略！！！
    }

    public Circle(double radius){
        System.out.println("Circle(double radius) is called")
        this.radius = radius;
    }
}

包装类

  • 将基础数据类型也变成对象

String的两个特性!!!

  • 直接赋值的指向相同的空间（和python相同）
String s1 = "java";
string s2 = s1;
System.out.println("s1 == s2");              //结果是true：s1 s2 都指向java
s1 = "hello";
System.out.println("s1 == s2");              //结果是false： s1指向了hello
  • 直接赋值，如果特殊空间存在值则指向该对象，不存在则创建对象指向，通过new创建则在堆空间内创建对象
String s1 = "java";
String s2 = new String("java");           //两者指向不同