Java匹马行天下之JavaSE核心技术——面向对象

注：看此篇时强烈建议有一定的面向对象思想基础，有一定的基础后先翻到下面看第九条：9.面向对象：从未封装→封装→继承→多态→抽象类→接口的代码演变,按这个逻辑去看，哪有不理解的再回头看知识点，这是掌握理解最好最快的方法，切记切记

万物皆对象

描述一个物质都可以通过两方面说明：数据模型（属性）、行为模型（行为）。在Java编程中，我们使用成员变量表示数据模型，用成员方法表示行为模型。使用类表示某些具有相同属性和行为的事物。

1、函数

构造函数：

语法：

[访问修饰符] 类名(){ }

作用：

构造函数，一般是用于为成员属性赋初始化值；

注意：

当类中没有显式的构造方法，实例化该类的对象时，程序会自动创建一个公开的无参构造方法；

如果类中有显示的构造方法，程序就不会创建无参构造；

静态函数:

static关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

对类变量和方法的访问可以直接使用 classname.variablename 和 classname.methodname 的方式访问。

如下例所示，static修饰符用来创建类方法和类变量:

public class InstanceCounter {
   private static int numInstances = 0;
   protected static int getCount() {
      return numInstances;
   }

   private static void addInstance() {
      numInstances++;
   }

   InstanceCounter() {
      InstanceCounter.addInstance();
   }

   public static void main(String[] arguments) {
      System.out.println("Starting with " +
      InstanceCounter.getCount() + " instances");
      for (int i = 0; i < 500; ++i){
         new InstanceCounter();
          }
      System.out.println("Created " +
      InstanceCounter.getCount() + " instances");
   }
}

运行结果：

Starting with 0 instances
Created 500 instances

成员函数(实例函数)

2、变量

成员变量（实例变量）

声明在所有方法体和代码块之外，并且没有使用static修饰的变量，叫做实例变量；

可以使用访问修饰符和final修饰；

使用final修饰时，一定要赋值；

实例变量是在对象被创建时创建，对象被销毁时销毁；

作用域范围在整个类中；

局部变量

声明在构造方法、静态方法、实例方法、代码块中的变量，都是局部变量；

不能使用static和访问修饰符修饰；

可以使用final修饰，即为常量，不必在声明语句中赋值；

当执行局部变量所在的方法或代码块时，才有机会被创建，在方法或代码块执行结束后被自动销毁；

局部变量在内存的栈区分配；

局部变量在使用之前必须要先赋值；

静态变量（类的变量）

声明在所有方法体和代码块之外，并且使用static修饰的变量；

可以使用访问修饰符修饰；

一般配合final使用，即public static fianl，标识符使用大写；

类变量被分配在静态存储区，是被所有该类的对象共享数据；

类变量是在程序开始时被创建，程序结束时销毁；

3、修饰符

访问修饰符

Java中可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

default (即缺省，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

private : 在同一类内可见。使用对象：变量、方法。注意：不能修饰类（外部类）

public : 对所有类可见。使用对象：类、接口、变量、方法

protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类（外部类）

我们可以通过以下表来说明访问权限：

非访问修饰符

为了实现一些其他的功能，Java 也提供了许多非访问修饰符。

static 修饰符，用来修饰类方法和类变量。

final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。

final修饰变量：

final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。

final 修饰符通常和 static 修饰符一起使用来创建类常量。

//实例
public class Test{
  final int value = 10;
  // 下面是声明常量的实例
  public static final int BOXWIDTH = 6;
  static final String TITLE = "Manager";

  public void changeValue(){
     value = 12; //将输出一个错误
  }
}

final修饰方法：

类中的 final 方法可以被子类继承，但是不能被子类修改。

声明 final 方法的主要目的是防止该方法的内容被修改。

如下所示，使用 final 修饰符声明方法：

public class Test{
    public final void changeName(){
       // 方法体
    }
}

final修饰类：

final 类不能被继承，没有类能够继承 final 类的任何特性。

//实例
public final class Test {
   // 类体
}

注意：

当final修饰类时，当前类不能被继承；

当final修饰方法时，该方法不能被重写；

当final修饰变量时，变量的值不能被修改，即为常量；

abstract修饰符，用来创建抽象类和抽象方法。
抽象类：

抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。

一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。

抽象类可以包含抽象方法和非抽象方法。

规则：

含有抽象方法的类，一定是抽象类；

抽象类中可以声明成员变量、常量、成员方法、抽象方法，抽象类中不一定要有抽象方法；

抽象类不能被实例化；

抽象类可以被继承；

可以通过两种方式获得抽象类对象：父类引用指向子类对象、匿名内部类；

子类必须重写抽象父类的所有抽象方法，或者是把子类也定义为抽象类；

如果一个类继承的抽象父类还有上级抽象父类，那么子类中需要要重写所有抽象父类的所有抽象方法；

抽象类也可以继承非抽象类，同时继承了父类的所有非私有的属性和方法；

实例:

abstract class Caravan{
   private double price;
   private String model;
   private String year;
   public abstract void goFast(); //抽象方法
   public abstract void changeColor();
}

抽象方法

抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。

抽象方法不能被声明成 final 和 static。

任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。

如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
*抽象方法的声明以分号结尾，例如：public abstract sample();

实例:

public abstract class SuperClass{
    abstract void m(); //抽象方法
}

class SubClass extends SuperClass{
     //实现抽象方法
      void m(){
          .........
      }
}

synchronized 和 volatile 修饰符，主要用于线程的编程。

synchronized 修饰符

synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。

实例
public synchronized void showDetails(){
.......
}

transient 修饰符

序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。

该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。

实例
public transient int limit = 55;   // 不会持久化
public int b; // 持久化

**volatile **修饰符

volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时,会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

一个 volatile 对象引用可能是 null。

实例
public class MyRunnable implements Runnable
{
    private volatile boolean active;
    public void run()
    {
        active = true;
        while (active) // 第一行
        {
            // 代码
        }
    }
    public void stop()
    {
        active = false; // 第二行
    }
}

通常情况下，在一个线程调用 run() 方法（在 Runnable 开启的线程），在另一个线程调用 stop() 方法。如果第一行中缓冲区的 active 值被使用，那么在第二行的 active 值为 false 时循环不会停止。但是以上代码中我们使用了 volatile 修饰 active，所以该循环会停止。

4、关键字

this指当前对象，用法：

当局部变量名和实例变量名同名时，使用this.变量名来表示实例变量；

this()表示当前类的构造方法，只能在构造方法中使用该写法，并且是写在构造方法内的第一行。

面向对象三大特征：封装、继承、多态

5、封装

私有的属性，公开的方法。
封装的步骤：

声明私有（private）的属性；

声明公开（public）的geter和seter方法；

6、继承

Java中的继承是单继承，可以实现多层继承，继承的关键字extends

语法：

public class Son extends Father{

}

规则：

子类继承父类非私有的所有属性和方法，不能继承父类的构造方法；

实例化子类对象的步骤：先执行父类的构造方法，再执行子类的构造方法；

重写定义：

子类重新声明从父类继承来的方法，称为方法重写；

方法重写时，方法的声明部分要和父类保持一致（返回值类型，方法名，参数）；

重写方法的访问权限要大于等于父类中方法的访问权限；

子类重写父类方法，子类对象调用的是子类中重写后的方法；

使用static修饰的方法不能被重写，但是可以被子类重写声明；

不同包的子类可以重写父类中protected修饰的方法，但是不能以继承的形式，用子类对象直接调用父类的该方法；

7、多态

实现的必要条件：

继承

重写

父类引用指向子类对象

instanceof关键字：

语法：
if (对象名 instanceof 类名) {       
            类型转换代码；
}

实例：
Animal cat = new Cat();
        if (cat instanceof Cat) {//返回结果为boolean类型
            Cat c = (Cat) cat;
            c.eat();
        }else{
            System.out.println("类型不匹配");
        }

8、接口

语法：
public interface ITest {

}

规则：

接口使用interface关键字修饰；

接口是一个完全抽象的抽象类；

接口中没有构造方法；

接口不能被实例化对象；

接口中可以声明静态常量、抽象方法、静态方法；

接口中不能声明实例方法，声明抽象方法时，不能使用static关键字修饰；

声明接口语句中，默认含有abstract关键字，抽象方法中也默认含有abstract关键字；

接口可以被实现，使用implements关键字，一个类实现一个接口，必须重写该接口中所有的抽象方法；

一个类可以实现多个接口，每个接口名用英文的逗号隔开，该类中必须重写所有已实现接口中的抽象方法；

接口可以继承接口，接口与接口间是多继承关系，接口不能继承类；

9.面向对象：从未封装→封装→继承→多态→抽象类→接口的代码演变：

未封装：

public class Person {
    int age;//年龄
    String name;//姓名
    public void print()
    {
        System.out.println("age:"+this.age+" "+"name:"+this.name);
    }
}

class Text{
    public static void main(String[] args) {
        Person person = new Person();//实例化对象
        person.age = -100;//赋值
        person.name = "张三";
        person.print();//执行类中的方法
    }
}


运行结果：<br>age:-100 name:张三

封装：

public class Person {
    private int age;//年龄
    private String name;//姓名

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + this.age +
                ", name='" + this.name + ''' +
                '}';
    }
}


class Text{
    public static void main(String[] args) {
        Person person = new Person();
        person.setAge(20);
        person.setName("张三"); ;
        String s = person.toString();
        System.out.println(s);
    }
}


运行结果：
Person{age=20, name='张三'}

继承

public class Office {
    public void print(){
        System.out.println("打印");
    }
}

class Word extends Office {
    @Override
    public void print() {
        System.out.println("Word打印");
    }
}

class Test{
    public static void main(String[] args) {
        Word word = new Word();
        word.print();
    }
}

运行结果：
Word打印

一个Java源文件中可以声明多个class类，但只能有一个public修饰的类。

多态

public class Office {
    public void print(){
        System.out.println("打印");
    }
}

class Word extends Office {
    @Override
    public void print() {
        System.out.println("Word打印");
    }
}

class Excle extends Office{
    @Override
    public void print() {
        System.out.println("Excel打印");
    }
}

class  Ppt extends Office{
    public void daYin() {//子类可以重写父类方法，也可以自己定义方法
        System.out.println("PPT打印");
    }
}

class Test{
    public static void main(String[] args) {
        Office o = new Word();//多种形态，即多态
        o.print();
    }
}

运行结果：

Word打印

class Test{
    public static void main(String[] args) {
        Office o = new Excle();
        o.print();
    }
}

运行结果：

Excel打印

class Test{
    public static void main(String[] args) {
        Office o = new Ppt();
        o.print();
    }
}

运行结果：

打印

为避免这种方法名称多样的情况，用一种约束叫抽象类

public abstract class Office {
    public abstract void print();
}

class Word extends Office {
    @Override
    public void print() {
        System.out.println("Word打印");
    }
}

class Excle extends Office{
    @Override
    public void print() {
        System.out.println("Excel打印");
    }
}

class  Ppt extends Office{
    @Override
    public void print() {
        System.out.println("PPT打印");
    }
}

class Test{
    public static void main(String[] args) {
        Office o = new Ppt();//父类引用指向子类对象，子类重写父类方法，父类引用调用子类重写后的方法，执行的结果是子类重写后的方法
        o.print();
    }
}

运行结果：

PPT打印

接口是完全抽象的抽象类，并且可以多实现

接口默认为：
public  class abstract interface Office {
    public abstract  void print();
}
---------------------------------------------------------
public interface Office {
    void print();
}

class Word implements Office {
    @Override
    public void print() {
        System.out.println("Word打印");
    }
}

class Excle implements Office{
    @Override
    public void print() {
        System.out.println("Excel打印");
    }
}

class  Ppt implements Office{
    @Override
    public void print() {
        System.out.println("PPT打印");
    }
}

class Test{
    public static void main(String[] args) {
        Office o = new Ppt();
        o.print();
    }
}

运行结果为：

PPT打印

10、内部类

成员内部类

成员内部类声明在类中，方法体、代码块之外。和成员变量、成员方法在同一级别。

语法：
public class Out {
      //成员内部类
      public class Inner{
      }
}

实例化成员内部类：
        //先实例化外部类
        Out o = new Out();
        //使用外部类对象，再实例化内部
        Out.Inner inner = o.new Inner();

实例：
public class Out {
    //成员变量
    public int a = 1;

    //成员内部类
    public class Inner{
        public int a = 2;
        //内部类的成员方法
        public void print(){
//执行内部类中的实例变量a
            System.out.println(a);
//执行外部类的实例变量a
            System.out.println(Out.this.a);    
}
    }
}

静态内部类

声明的位置参考成员内部类。

语法：
public class Out {
    //静态内部类
    public static class Inner{

    }
}

实例化静态内部的对象：
Out.Inner inner = new Out.Inner();

实例：
public class Out {
    public static int a = 1;
    public int b = 3;
    //静态内部类
    public static class Inner{
        public static int a = 2;
        public static void print(){
            //执行静态内部的静态变量
            System.out.println(a);
            //执行外部类的静态变量
            System.out.println(Out.a);
            //执行外部类的实例变量
            Out o = new Out();
            System.out.println(o.b);
        }
    }
}

局部内部类

声明在方法体或代码块内，作用域范围在方法体或代码块内。

语法：
public class Out {
    public void method(){
        //局部内部类
        class Inner{
            //局部内部类的成员方法
            public void print(){
                System.out.println("局部内部类");
            }
        }
        //实例化局部内部类
        Inner inner = new Inner();
        inner.print();
    }
}

执行局部内部类的方法：
Test类：
public static void main(String[] args) {
        Out o  = new Out();
        o.method();
}

匿名内部类

声明位置同局部内部类一样，前提条件：必须继承一个类或实现一个接口，匿名内部类的声明和实例化对象是同时进行的；

一般使用于获得抽象类或接口对象；

语法：
父类名/接口名  对象名 =  new  父类名/接口名(){
        //匿名内部类成员
};

实例：
父类
public class Father {
}

匿名内部类：
public class Out {
    public void method(){
        //匿名内部类对象
        Father f = new Father(){
        };
    }
}

此篇完

这一篇对新手是不友好的，不过对一些一知半解的或者想复习的朋友可能帮助更大。