java基础（6）---面向对象，类，包

一、类

类对象内存：

 成员变量和局部变量：

　　成员变量：类中定义的一些私有变量，表示对象的属性。

　　局部变量：局部变量是在方法体里创建的，在方法体外是访问不到这个变量的。

public class test{
    int size = 26; //成员变量创建并初始化

    public static void main(String[] args){
        int size1 = 33; //局部变量创建并初始化
    }
}

// 成员变量和局部变量的区别
/*
1、成员变量： 可以被public 、 protected 、default、private、static、final等修饰
    局部变量：只能被final修饰
2、成员变量：在堆里创建
    局部变量：在栈里创建
3、成员变量：系统默认值
    局部变量：局部变量没有系统默认值，必须手动赋值。
*/

private关键字：setter和getter方法【两个方法可控制私有变量不可随意修改】

this关键字：

this关键字代表当前对象。使用this.属性操作当前对象的属性，this.方法调用当前对象的方法。

用private修饰的属性，必须定义 getter 和 setter 方法才可以访问到(Eclipse IDEA 等 IDE 都有自动生成 getter 和 setter 方法的功能)。

如下：

 构造方法：

重载：

 定义一个标准类：

二、面向对象

1、4个特点：

• 继承：extends (子类共享父类成员变量和方法的一种模式。)

• 多态：指对象在运行期和编译期具有两种状态。
• 抽象：在定义类时确定了该类的一些行为和动作。如自行车可移动，但怎么移动不进行说明。这种提前定义一些动作和行为的类为抽象的。
• 封装：对一件物品的描述信息是这个物品所特有的，是不能让外界看到的一些成员变量和方法。在java里成员变量和方法就被封装在类里，需要通过一些特有的方法访问它们。

2、封装： private 成员变量，set \ get

　　在一个类里定义了一些成员变量和方法，通过限制其成员变量和方法的可见性，是外界不能访问它们。

如果我们没有在属性前面添加任何修饰符，我们通过对象就可以直接对属性值进行修改，没有体现封装的特性。这在许多程序设计中都是不安全的，所以我们需要利用封装，来改进我们的代码。

首先在类里要将属性前添加private修饰符。然后定义getter和setter方法。

3、继承：extends ，super

当继承的关系发生了，想用父类的方法就要用super关键字引用，如果想用新的方法就重写来完成新的功能。

成员成员的覆盖：子类里有和父类相同的成员变量或方法，继承的关系，子类的成员变量将会使用，而父类成员变量被保护起来。

方法的重写（override）：在子类自身方法中，如果和所继承的方法具有相同的名称，便构成了方法的重写。重写的特点就是能够为各个子类定义特有的行为。

子类可以继承父类的方法，但如果子类对父类的方法不满意，想在里面加入适合自己的一些操作时，就需要将方法进行重写。并且子类在调用方法中，优先调用子类的方法。

• 子类重写父类的方法时，返回类型、参数类型及个数，和方法名都必须一致。重写是基于继承的。
• 静态方法是不能重写的。static方法在类里声明具有唯一性，不能通过类的实例化而存在的，静态方法可以被继承，但是不可以被重写。

方法的重载（overload）：在一个类中，存在两个或者两个以上具有相同名称、不同参数的方法。方法重载一般用于创建一组任务相似但是参数不同的方法。

重载的方法名称相同，但方法的参数列表不相同，如参数个数和参数类型等。

重载的方法的返回值可以相同也可以不相同。

 重写、重载、覆盖三者关系：

覆盖：

• 覆盖的方法的参数列表必须要和被覆盖的方法的参数列表完全相同，才能达到覆盖的效果。
• 覆盖的方法的返回值必须要和被覆盖的方法的返回值一致。
• 覆盖的方法所抛出的异常必须和被覆盖的方法所抛出的异常一致，或者是其子类。
• 被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。

重载：

• 使用重载时只能定义不同的参数列表。
• 不能通过重载的方法对返回类型、访问权限和抛出的异常来进行方法的重载。

重写：

• 重写的方法存在于父类中，也存在于子类.
• 重写的方法在运行期采用多态的形式。
• 重写的方法不能比被重写的方法有更高的访问限制。
• 重写的方法不能比被重写的方法有更多的异常。

4、抽象

与final的含义是相反的，好比日常生活中人们设计的图纸，这个图纸好比抽象的房子，需要把房子盖起来实现这个图纸。

抽象类最少要含有一个抽象方法，让其子类去实现这个抽象方法。

5、多态

一个物品有多种状态表现。

多态是指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。多态也称作动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

通俗地讲，只通过父类就能够引用不同的子类，这就是多态，我们只有在运行的时候才会知道引用变量所指向的具体实例对象。

向上转型：

Dog 类是 Animal 类的子类：

Animal a = new Animal();  //a是父类的引用指向的是本类的对象

Animal b = new Dog(); //向上转型

在这里，可以认为由于 Dog 继承于 Animal，所以 Dog 可以自动向上转型为 Animal，所以 b 是可以指向 Dog 实例对象的。

如果定义了一个指向子类对象的父类引用类型，那么它除了能够引用父类中定义的所有属性和方法外，还可以使用子类强大的功能。但是对于只存在于子类的方法和属性就不能获取。

class Animal {
    //父类方法
    public void bark() {
        System.out.println("动物叫！");
    }
}

class Dog extends Animal {

    //子类重写父类的bark方法
    public void bark() {
        System.out.println("汪、汪、汪！");
    }
    //子类自己的方法
    public void dogType() {
        System.out.println("这是什么品种的狗？");
    }
}

public class Test {

    public static void main(String[] args) {
        Animal a = new Animal();
        Animal b = new Dog();
        Dog d = new Dog(); 

        a.bark(); //动物叫
        b.bark(); //汪、汪、汪
        //b.dogType();
        //b.dogType()编译不通过
        d.bark(); // 汪、汪、汪
        d.dogType(); //这是什么品种的狗？
    }

}

在这里，由于 b 是父类的引用，指向子类的对象，因此不能获取子类的方法（dogType()方法）,同时当调用 bark()方法时，由于子类重写了父类的 bark()方法,所以调用子类中的 bark()方法。

因此，向上转型，在运行时，会遗忘子类对象中与父类对象中不同的方法，也会覆盖与父类中相同的方法——重写。（方法名，参数都相同）

多态的实现条件：

Java 实现多态有三个必要条件：继承、重写和向上转型（即父类引用指向子类对象）。

只有满足上述三个条件，才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。

Java 中多态的实现方式：继承父类进行方法重写，抽象类和抽象方法，接口实现。

五、枚举类

一组连续的基本类型的数值。

//声明一个枚举类型

enum colors{green,yellow}

public enum Grate

{

A,B,C,D

};

六、包

将不同的类组织起来进行管理。类按照其功能分别存放在各个包里。

1、创建包：

将类存放到指定的包中，必须要使用package语句。

package 包名；

例如：package a.b;

2、使用包

import 包.*;

import 包名.类名;

如果一个类需要使用和自己同处于一个包下的类，可以直接访问。

如：

package a;

public class aaa{
    String emp = "包中的成员变量";
    public void getMes(){
        System.out.println(emp);
    }
}

//如果想在其他程序中使用该类，则在其他程序中加入如下语句。
//import a.aaa;

3、静态引入

静态引入：引入包中的静态成员变量和静态方法。静态引入的关键字为static。

import static 包名.aaa.*;

import static 包名.aaa.方法名称；

// 静态引入System.out.println方法
import static java.lang.System.out;

七、类的访问级别

1、公开的访问级别

带public 修饰符的类，表示任何包中的任何类都能访问该类，但不同包中还需使用引用语句。

public class test {

//方法体

}

//创建一个包a
package a;

import b.*;

public class test
{
    public static void main(String[] args){
        test1 t1 = new test1();
        String s = t1.emp;
    }
}

//创建一个包
package b;

public class test1{
    String emp = "不同包中的成员变量";
}

2、默认的访问级别

具有默认访问类别的类在声明时前面不加任何的修饰符，可以将默认级别看做包级的访问，只能被同一个包下的类使用。

默认的访问级别和公开的访问级别很相似，不同点是默认的访问级别不能访问不同包下的类，只能访问同包下的类。

class test{

//方法体

}

//创建一个包
package b;

class test1{
    String emp = "不同包中的成员变量";
}

//创建一个包a
package a;

import b.*;

public class test
{
    public static void main(String[] args){

        test1 t1 = new test1(); //   会报错，不能访问test1
        String s = t1.emp;
    }
}    

八、抽象类

那我们什么时候会用到抽象类呢？

1. 在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。也就是说抽象类是约束子类必须要实现哪些方法，而并不关注方法如何去实现。
2. 从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。

所以由上可知，抽象类是限制规定子类必须实现某些方法，但不关注实现细节。

那抽象类如何用代码实现呢，它的规则如下：

1. 用 abstract 修饰符定义抽象类
2. 用 abstract 修饰符定义抽象方法，只用声明，不需要实现
3. 包含抽象方法的类就是抽象类
4. 抽象类中可以包含普通的方法，也可以没有抽象方法
5. 抽象类的对象不能直接创建，通常是定义引用变量指向子类对象。

九、内部类

内部类的主要作用如下：

1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
2. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据
3. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便
4. 内部类允许继承多个非接口类型（具体将在以后的内容进行讲解）

静态内部类是 static 修饰的内部类，这种内部类的特点是：

1. 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问
2. 如果外部类的静态成员与内部类的成员名称相同，可通过类名.静态成员访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过成员名直接调用外部类的静态成员
3. 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();

// People.java
//外部类People
public class People {
    private String name = "LiLei";         //外部类的私有属性

/*外部类的静态变量。
Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。
*/
    static String ID = "510xxx199X0724XXXX"; 

    //静态内部类Student
    public static class Student {
        String ID = "20151234";               //内部类的成员属性
        //内部类的方法
        public void stuInfo(){
            System.out.println("访问外部类中的name：" + (new People().name));
            System.out.println("访问外部类中的ID：" + People.ID);
            System.out.println("访问内部类中的ID：" + ID);
        }
    }

    //测试成员内部类
    public static void main(String[] args) {
        Student b = new Student();   //直接创建内部类对象，对象名为b
        b.stuInfo();                 //调用内部对象的suInfo方法
    }
}

 局部内部类，是指内部类定义在方法和作用域内。局部内部类也像别的类一样进行编译，但只是作用域不同而已，只在该方法或条件的作用域内才能使用，退出这些作用域后无法引用的。

例如：

// People.java
//外部类People
public class People {
    //定义在外部类中的方法内：
    public void peopleInfo() {
        final String sex = "man";  //外部类方法中的常量
        class Student {
            String ID = "20151234"; //内部类中的常量
            public void print() {
                System.out.println("访问外部类的方法中的常量sex：" + sex);
                System.out.println("访问内部类中的变量ID:" + ID);
            }
        }
        Student a = new Student();  //创建方法内部类的对象
        a.print();//调用内部类的方法
    }
    //定义在外部类中的作用域内
    public void peopleInfo2(boolean b) {
        if(b){
            final String sex = "man";  //外部类方法中的常量
            class Student {
                String ID = "20151234"; //内部类中的常量
                public void print() {
                    System.out.println("访问外部类的方法中的常量sex：" + sex);
                    System.out.println("访问内部类中的变量ID:" + ID);
                }
            }
            Student a = new Student();  //创建方法内部类的对象
            a.print();//调用内部类的方法
        }
    }
    //测试方法内部类
    public static void main(String[] args) {
        People b = new People(); //创建外部类的对象
        System.out.println("定义在方法内：===========");
        b.peopleInfo();  //调用外部类的方法
        System.out.println("定义在作用域内：===========");
        b.peopleInfo2(true);
    }
}

匿名内部类，顾名思义，就是没有名字的内部类。正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写。但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口。

// Outer.java
public class Outer { 

    public Inner getInner(final String name, String city) {
        return new Inner() {
            private String nameStr = name;
            public String getName() {
                return nameStr;
            }
        };
    } 

    public static void main(String[] args) {
        Outer outer = new Outer();
        Inner inner = outer.getInner("Inner", "NewYork");
        System.out.println(inner.getName());
    }
}
interface Inner {
    String getName();
}

匿名内部类是不能加访问修饰符的。要注意的是，new 匿名类，这个类是要先定义的,如果不先定义，编译时会报错该类找不到。

同时，在上面的例子中，当所在的方法的形参需要在内部类里面使用时，该形参必须为final。这里可以看到形参 name 已经定义为 final 了，而形参 city 没有被使用则不用定义为 final。

然而，因为匿名内部类没名字，是用默认的构造函数的，无参数的，如果需要该类有带参数的构造函数，示例如下：

   public Inner getInner(final String name, String city) {
        return new Inner(name, city) {
            private String nameStr = name; 

            public String getName() {
                return nameStr;
            }
        };
    } 

注意这里的形参 city，由于它没有被匿名内部类直接使用，而是被抽象类 Inner 的构造函数所使用，所以不必定义为 final。

十、Calendar

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class CalendarDemo {
    public static void main(String[] args) {
        System.out.println("完整显示日期时间：");
        // 字符串转换日期格式
        DateFormat fdate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String str = fdate.format(new Date());
        System.out.println(str);

        // 创建 Calendar 对象
        Calendar calendar = Calendar.getInstance();
        // 初始化 Calendar 对象，但并不必要，除非需要重置时间
        calendar.setTime(new Date());

        // 显示年份
        System.out.println("年： " + calendar.get(Calendar.YEAR));

        // 显示月份 (从0开始, 实际显示要加一)
        System.out.println("月： " + calendar.get(Calendar.MONTH));

        // 当前分钟数
        System.out.println("分钟： " + calendar.get(Calendar.MINUTE));

        // 今年的第 N 天
        System.out.println("今年的第 " + calendar.get(Calendar.DAY_OF_YEAR) + "天");

        // 本月第 N 天
        System.out.println("本月的第 " + calendar.get(Calendar.DAY_OF_MONTH) + "天");

        // 3小时以后
        calendar.add(Calendar.HOUR_OF_DAY, 3);
        System.out.println("三小时以后的时间： " + calendar.getTime());
        // 格式化显示
        str = (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS")).format(calendar.getTime());
        System.out.println(str);

        // 重置 Calendar 显示当前时间
        calendar.setTime(new Date());
        str = (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS")).format(calendar.getTime());
        System.out.println(str);

        // 创建一个 Calendar 用于比较时间
        Calendar calendarNew = Calendar.getInstance();

        // 设定为 5 小时以前，后者大，显示 -1
        calendarNew.add(Calendar.HOUR, -5);
        System.out.println("时间比较：" + calendarNew.compareTo(calendar));

        // 设定7小时以后，前者大，显示 1
        calendarNew.add(Calendar.HOUR, +7);
        System.out.println("时间比较：" + calendarNew.compareTo(calendar));

        // 退回 2 小时，时间相同，显示0
        calendarNew.add(Calendar.HOUR, -2);
        System.out.println("时间比较：" + calendarNew.compareTo(calendar));

        // calendarNew创建时间点
        System.out.println((new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS")).format(calendarNew.getTime()));
        // calendar创建时间点
        System.out.println((new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS")).format(calendar.getTime()));
        System.out.println("时间比较：" + calendarNew.compareTo(calendar));
    }
}

/*
完整显示日期时间：
2018-12-12 15:50:49
年： 2018
月： 11
分钟： 50
今年的第 346天
本月的第 12天
三小时以后的时间： Wed Dec 12 18:50:49 CST 2018
2018-12-12 18:50:49:449
2018-12-12 15:50:49:455
时间比较：-1
时间比较：1
时间比较：1
2018-12-12 15:50:49:456
2018-12-12 15:50:49:455
时间比较：1
*/

三、Date类

import java.util.Date;

import java.text.SimpleDateFormat;
import java.util.Date;

public class DateDemo {
    public static void main(String[] args) {
        String strDate, strTime;
        Date objDate = new Date();
        System.out.println("今天的日期是：" + objDate);
        long time = objDate.getTime();
        System.out.println("自1970年1月1日起以毫秒为单位的时间（GMT）：" + time);
        strDate = objDate.toString();
        //提取 GMT 时间
        strTime = strDate.substring(11, (strDate.length() - 4));
        //按小时、分钟和秒提取时间
        strTime = "时间：" + strTime.substring(0, 8);
        System.out.println(strTime);
        //格式化时间
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(formatter.format(objDate));
    }
}
/*
今天的日期是：Wed Dec 12 14:43:15 CST 2018
自1970年1月1日起以毫秒为单位的时间（GMT）：1544596995669
时间：14:43:15
2018-12-12 14:43:15
*/

四、Integer类