6.面向对象 -类.md

---

目录

• 1. static：
• 2. 类在内存中，每一个类在创建在栈内存中，当创建一个对象的时候，将非类变量再堆内存中创建，而类变量是不会因为创建对象而在堆中重新创建
• 3. 对象、引用和指针：
• 4. 类名和文件名的关系
• 5. Java的set和get方法
• 5. 包的概念：
  • 包的命名：
  • import包：
  • 特殊情况的引用
  • Java文件结构
• 6.构造器
  • 关于构造在的初始化过程：
  • 在构造中调用构造：
• 7.继承
  • 注意：Java是单继承，不同于C++，每个子类只有一个直接父类。关键字extends
  • 方法的覆盖（Override）:
  • super关键字
• 8.多态
  • 引用变量的强转
  • 子类和父类的封装
  • 使用继承的前提：
• 9.类的初始化
• 10.Java增强的包装类
  • String和其他类型的互转
  • equals方法
    • 单例类

---

1. static：

很多时候将static直接翻译为静态，但是这个描述不够准确，static是用来定义类变量，也就是说被static定义的变量不属于这个类的某个实例。所以被static定义的成为类变量、类方法；反之为实例变量

需要注意的是，在静态方法中不能直接通过对象去调用，需要通过类去调用

123456789101112131415 public class NewClassTest {

public void jump(){

System.out.println("This is NewClassTest");

}

public void run(){
    System.out.println("This is run");
    jump();
}

//static
public static void sFun(){
    new NewClassTest().run();   //correct
    run();                      //error
}

}

2. 类在内存中，每一个类在创建在栈内存中，当创建一个对象的时候，将非类变量再堆内存中创建，而类变量是不会因为创建对象而在堆中重新创建

并且访问类变量不能用对象的方式，必须用类的方式！

3. 对象、引用和指针：

    Java中的变量都是引用，指针被封装了。当对象没有被引用时候就会被垃圾回收机制回收。也可以将对象赋值null，标记回收此对象。

4. 类名和文件名的关系

5. Java的set和get方法

5. 包的概念：

包的命名：

父## 包和子包之间的类关系：

import包：

特殊情况的引用

Java文件结构

---

目录

• 1. static：
• 2. 类在内存中，每一个类在创建在栈内存中，当创建一个对象的时候，将非类变量再堆内存中创建，而类变量是不会因为创建对象而在堆中重新创建
• 3. 对象、引用和指针：
• 4. 类名和文件名的关系
• 5. Java的set和get方法
• 5. 包的概念：
  • 包的命名：
  • import包：
  • 特殊情况的引用
  • Java文件结构
• 6.构造器
  • 关于构造在的初始化过程：
  • 在构造中调用构造：
• 7.继承
  • 注意：Java是单继承，不同于C++，每个子类只有一个直接父类。关键字extends
  • 方法的覆盖（Override）:
  • super关键字
• 8.多态
  • 引用变量的强转
  • 子类和父类的封装
  • 使用继承的前提：
• 9.类的初始化
• 10.Java增强的包装类
  • String和其他类型的互转
  • equals方法
    • 单例类

---

6.构造器

Java可以自定义构造，可以简单理解为C++的构造，如果定义了私有的构造，即不使用默认的无参构造，那么在创建对象的时候，默认的构造是非法的，如果需要多个构造，那么需要定义多个构造，形成构造的重载：

package aaa;

public class Study {

    private int num;
    private String name;

    //这里既可以为public也可以为private，具体区别待理解
    private Study(String name){
        this.name = name;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Study s = new Study("aaa");   //这里合法！
        Study ss = new Study();       //这里会报错！
        System.out.print(s.name);
    }

}

关于构造在的初始化过程：

在构造中调用构造：

package aaa;

public class Study {

    private int num;
    private String name;

    //无参构造
    public Study(){};

    //一个参数的构造
    private Study(String name){
        this.name = name;
    }

    //两个参数的构造
    public Study(String name, int num){
        this(name);   //调用了一个参数的构造，用this
        this.num = num;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Study s = new Study("aaa");     //没有被其他构造再调用，只初始化自己，num默认初始化为0
        System.out.println(s.name);
        System.out.println(s.num);

        Study ss = new Study("bbb", 2); //在构造中调用了一个参数的构造
        System.out.println(ss.name);
        System.out.println(ss.num);
    }

} 

7.继承

注意：Java是单继承，不同于C++，每个子类只有一个直接父类。关键字extends

修饰符 class SubClass extends SuperClass{
    //类定义部分
}

      子类继承后获得父类的全部变量和方法，构造除外。
      **但是可以间接继承多个父类**

方法的覆盖（Override）:

super关键字

子类需要调用父类中被覆盖的实例方法，可以用Super关键字来调用，需要注意的是和this不能出现在static关键字修饰的方法中一样，super也不可以调用类方法

//在两个文件中定义类

//父类
public class Bird{
    public int num = 1;

    public void fly(){
        System.out.println("Bird can fly!");
    }
}

//子类
public class Drck extends Bird{
    public int num = 2;

    public void fly(){
        System.out.println("Drck can not fly!");
    }

    public void accessBirdNum(){
        System.out.println(super.num);  //调用父类变量
    }

    public void accessDrckNum(){
        System.out.println(num);
    }
}

需要注意的是有隐藏的情况，在父类和子类同名的情况下：

//父类
public class Bird{
    public String fly = "Bird can fly";
}
//子类
public class Drck extends Bird{
        //实际上父类的fly被这里隐藏了
    private String fly = "Drck can not fly";
}
//打印
public class Study {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Drck dc = new Drck();
                System.out.println(dc.fly);            //这里编译不过，
        System.out.println(((Bird)dc).fly);  //向上转为父类
    }
}

8.多态

//父类
public class Bird{
    public String name = "Bird";
    //父类独有的方法
    public void birdTest(){
        System.out.println("Bird fly");
    }
    //会被子类方法覆盖
    public void test(){
        System.out.println("父类的test");
    }
}

//子类
public class Drck extends Bird{
    public String name = "Drck";
    //子类独有的方法
    public void drckTest(){
        System.out.println("drck fly");
    }
    //覆盖了子类
    public void test(){
        System.out.println("子类的test");
    }
}

public class Study {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Bird bd = new Drck();
        System.out.println(bd);
        bd.birdTest();    //父类的方法
        bd.test();        //子类的方法
        //bd.drckTest();  //编译的类型是Bird，没有drckTest方法，编译报错
    }
}

引用变量的强转

强转的规则：

1. 基本的数值类型

2. 有继承关系的两个类型之间

是否可以强制转换可以用instanceof来判断

子类和父类的封装

使用继承的前提：

9.类的初始化

10.Java增强的包装类

•自动装箱（AutoBoxing）和自动拆箱(AutoUnboxing)

Java中除了基本数据类型外，所有引用类型的变量都继承自Object，都可当做Object类型变量使用。基本数据类型在Java中通过特定的包装类实现：

public class Study {
    public static void main(String[] args) {
        Integer inObj = 2;
        Float flObj = 2f;
        Double dbObj = 2.0;
        Byte byObj = 1;
        Character chObj = 'c';
        Boolean bObj = false;
        Short shObj = 1;
        //Object
        Object ob = true;

        if (ob instanceof Boolean) {
            bObj = (Boolean)ob;
        }
    }
}

自动装箱和拆箱的过程由Java完成，利用了向上转型的特性。不需要我们认为干预，但是要注意的是不能将错误的类型装箱和拆箱：将int和Float混用

String和其他类型的互转

### 基本类型转String用praseXXX(String s)或者构造XXX(String s)
### String转基本类型用s.valueOf()方法或者 + ""的方式

``Java

public class Study {

public static void main(String[] args) {

int num = 2;

float numf = 2.2f;

String snum = "123";

//String转换为基本类型，使用praseXXX(String s)

int num1 = Integer.parseInt(snum);

System.out.println("int num:" + num1);

//String转换为基本类型，使用构造XXX(String s)

float num2 = new Float(numf);

System.out.println("float num:" + num2);

//基本类型转换为String,使用String的方法s.valueOf()

String s = String.valueOf(numf);

System.out.println("String num:" + s);

//基本类型转换为String,使用+符号

String s1 = num + "";

System.out.println("String plus num:" + s1);

}//main

}

## toString方法

```Java
package aaa;

//定义个类，并重写toString方法
public class Bird{
    private int wing;
    private int eye;

    //无参构造
    public Bird(){
    }

    //有参构造
    public Bird(int wing, int eye){
        this.wing = wing;
        this.eye = eye;
    }

    //省略getter和setter方法

    //Override toString
    public String toString(){
        return "一只鸟有" + wing + "双翅膀" + eye + "双眼睛";
    }

}

//调用

public class Study {
    public static void main(String[] args) {
        Bird bd = new Bird(2,2);
        System.out.print(bd);
    }//main
}

equals方法

单例类

public class Singleton {
    private static Singleton instance;
    //将默认构造私有，方式重复创建对象
    private Singleton(){
    }
    //通过开放的方法获取唯一的实例
    public static Singleton getInstance(){
        if (null != instance){
            instance = new Singleton();
        }
        return instance;
    }
}