java基础梳理--朝花夕拾（三）

1、了解面向对象的编程思想以及面向对象的特性；

对象：
    EveryThing is Object； 万物皆是对象，在程序中，我们可以将类、接口、方法、属性等都认为是对象；
面向对象：
    是一种程序设计方法，它以对象作为基本的单元来构建系统，它利用对象将系统的复杂性隐藏在对象里（即封装），从而构建大型的工业级系统和大型系统。
面向对象包括三个过程：
    面向对象分析（OOA）、面向对象设计（OOD）、面向对象编程（OOP）。
面向对象的三个特性：
    继承、封装、多态
面向对象和面向过程的区别？
    面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。 
    面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。 

2、类、属性、方法以及return关键词的使用；

类：
  Java是面向对象的，class（类）可以看做是java中的对象，类中包含：方法（这个对象能做什么）、属性（这个对象具有什么特点）
  类：汽车
  属性：颜色、品牌、引擎等
  方法：启动、行驶、刹车
  我们可以将具有不同特点的不同的事物归为不同的类；
  
类的声明：
    [访问修饰符] class 类名{

    }

例如：
  public class Person{//访问修饰符 public class Person //类名
     private String name;//类的属性
     private String city;
     private String cardno;
     private String eyesColor;
     private String faceColor;
     public void wakeUp(String name,String time){//起床方法
      System.out.println(name+”起床时间：”+time);
      }
     public void sleep(String name,String time){//睡觉方法
      System.out.println(name+”睡觉时间：”+time);
      }
  }
  
属性：
    类的属性即类中声明的变量，也叫做类变量、成员变量、全局变量，可供多个方法调用；
    要掌握：全局变量、局部变量开发中的使用；

方法：
(1)定义无返回值方法：
  [public|private|protected|final]  void 方法名(参数可有可无){

  }
(2)定义有返回值方法：
 [public|private|protected|final]   返回值类型   方法名(参数可有可无){
   操作...
  return 返回值（跟方法名前面类型必须一致）；
 }
 p.s. void关键词：用于方法的声明，void表示无返回值，表示此方法执行完毕后，不反回任何结果；
      return 关键词：用于方法体中，表示该方法执行完毕后，会返回一个指定类型的结果或者数据值；
     
return、break、continue区别：
    return 跳出整个方法体，表示该方法具有返回值；return后面任何语句不会被执行；
    break：表示退出当前循环，用于循环或者switch case语句段中；
    continue:只能用在循环中，表示退出当前循环，继续下面循环；

3、构造方法、实例化（new关键词的使用）；

构造方法：
构造方法必须满足如下几个条件：
1、声明时方法名必须跟当前类名一致；
2、不能使用return,即构造方法无返回值；但也不能使用void关键词；
3、不能被static、final、synchronized、abstract、native修饰；
任何一个类都具有一个隐式无参构造方法；

例如：
    public class Test{
        private String x,y;
        public Test(){}//无参数构造方法
          public Test(String x,String y){//有参数的构造方法
          this.x=x;
          this.y=y;
         }
    }
    
构造方法主要用于：初始化成员变量；
构造方法执行过程：new实例化时直接执行；
例如：
public class Person{
  private String username;
  private int age;
  public Person(){}
  public Person(String username,int age){//构造方法初始化成员变量
      System.out.println(username);
      System.out.println(age);
      this.age=age;
      this.username=username;
  }
  public static void main(String args[]){
    Person person1=new Person("张三",23);
        System.out.println(person1.username);
    Person person1=new Person("张三",23);
        System.out.println(person2.username);
  }
}

实例化（new）:
    在面向对象中，实例化过程即通过类实现对象的创建（类创建对象的过程）；
    实例化过程中，会执行相应类的构造方法；对象是类的引用，类是对象的模板；
    例如：
       1.人是一个类，而名字叫“张三”的这个人，他是人类中一个具体实例；
       2.实例化一个字符串对象：
           String str=new String(“admin”);
       3.实例化类对象：
      public class Person{
        private String cardno;private String name;
        public Person(){ }
        public Person(String cardno,String name){
         this.name=name;
         this.cardno=cardno;
       }
       public void sleep(){
         System.out.println(“sleeping....”);
       }
       public static void main(String args[]){
           Person person=new Person(“2323123123”,“SMITH”);//实例化Person类对象，此时执行有两个参数的构造方法；
           person.sleep();
       }
      }

4、static 、this关键词的使用；

static 关键词：
    1、static 修饰方法，该方法叫做静态方法（也叫做类方法），可直接通过这个类的类名打点直接调用；
    2、静态方法中不能使用this/super关键词，静态方法不能直接调用当前类中的非静态方法（或非静态属性），必须通过new实例化后在调用；而对于非静态成员方法，它访问静态成员方法/变量显然是毫无限制的。
    3、static声明的方法和属性，该对象已经被实例化，且只能被实例化一次
    4、static修饰的属性，被相同对象的不同实例所共享；
例1：
public class Person{
  public static int age;
  
  public void run(){
    System.out.println(“RUN”);
   }
   
  public static void sleep(){
        System.out.println(“SLEEP”);
  }
  
  public static void test(){
    run();//错误,静态方法中不可直接调用非静态方法或者非静态变量；
    int age=this.age;//错误，当前方法是静态方法，不能使用this关键字
    Person person=new Person();
    person.run();
    
    sleep();//正确
    Person.sleep();//正确   
  }
}

例2：
public class Test {
   //静态属性：姓名
    private static String name;
    //非静态属性 ：年龄
    private String age;
    
    
    public static void main(String[] args) {
        Test test1 = new Test();
        test1.name="何东飞";
        test1.age="12";        
        System.out.println(test1.age);//结果为12
        System.out.println(test1.name);//结果为何东飞
        
        Test test2=new Test();
        test2.age="14";
        System.out.println(test2.age);//结果为12
        System.out.println(test2.name);//结果为何东飞
        //test1及test2的name相同，诠释了“static修饰的属性，被相同对象的不同实例所共享”这一特性
    }
}

static代码块：
　　static关键字还有一个比较关键的作用就是用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。
　　为什么说static块可以用来优化程序性能，是因为它的特性:只会在类加载的时候执行一次。下面看个例子:
    class Person{
        private Date birthDate;
         
        public Person(Date birthDate) {
            this.birthDate = birthDate;
        }
         
        boolean isBornBoomer() {
            Date startDate = Date.valueOf("1946");
            Date endDate = Date.valueOf("1964");
            return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0;
        }
    }
    
    isBornBoomer是用来这个人是否是1946-1964年出生的，而每次isBornBoomer被调用的时候，都会生成startDate和birthDate两个对象，造成了空间浪费，如果改成这样效率会更好：
        class Person{
            private Date birthDate;
            private static Date startDate,endDate;
            static{
                startDate = Date.valueOf("1946");
                endDate = Date.valueOf("1964");
            }
             
            public Person(Date birthDate) {
                this.birthDate = birthDate;
            }
             
            boolean isBornBoomer() {
                return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0;
            }
        }
        因此，很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行。

5、程序包package；import 关键词的使用；

程序包：package
package就是组织文件的一种方式。最大的作用就是组织java类文件,可以区分同名的class和interface；

导入：import
用于导入相关的类或者接口；
例如：
Scanner类在java.util包中，使用Scanner类中的相关方法时，需要在当前类中引入这个Scanner类：import java.util.Scanner;
或者import java.util.* ；如果使用*号，表示这个包中的所有类或者接口将全部被引入。

6、访问修饰符public、private、final、protected；

public：公共的，被修饰的类或接口可以被所有类访问；这是一个宽松的访问控制级别，如果一个成员(包括成员变量、方法和构造器等)或者一
              个外部类使用public访问控制符修饰，那么这个成员或外部类就可以被所有类(注：在该类外部，若是类成员，则需要类调用成员或外部
              类；若是非static的类，则应先实例化后，对象对其调用)访问，不管访问类和被访问类是否处于同一个包中，是否具有父子继承关系。
private：私有的，表示只有当前类才可以访问；如果类里的一个成员(包括成员变量、方法和构造器等)使用private访问控制符来修饰，则这个
                成员只能在当前类的内部被访问。很显然，这个访问控制符用于修饰成员变量最合适，使用它来修饰成员变量就可以把成员变量隐藏在该类内部。
protected：受保护的，该类的子类或者同一个包中的其他类都可以访问；如果一个成员(包括成员变量、方法和构造器等)使用protected访问控制符修饰，
                那么这个成员既可以被同一个包中的其他类访问，也可以被不同包中的子类访问。在通常情况下，如果使用protected来修饰一个方法，通常是希望其子类来重写这个方法。
default(包访问权限)：如果类里的一个成员(包括成员变量、方法和构造器等)或者一个外部类不使用任何访问控制符修饰，就称它是包访问权限，
                 default访问控制的成员或外部类可以被相同包下的其他类访问。
final;表示不可继承的，声明变量，表示是常量，必须赋初始值；值不可改变；声明的方法或者变量都不可以被子类继承；

8、方法的重载；

方法的重载：overloading
表示一个类中可以定义具有同名的方法，这些方法参数类型、个数、顺序可以不同；使用时可通过参数类型、个数，顺序区分这些方法；
构造方法重载：
例如：

普通方法重载：
例如：

9、继承、super关键词用法；

继承、super关键词用法：
    1、Java中支持类与类之间、接口与接口之间的继承，即将父类的东西继承过来；所有类的超类是java.lang.Object类；
    2、Java只支持单继承，即一个子类只能有一个父类（超类、基类）；
在java中继承有何优点？
    1、编码的重用性，也就是子类可以具有父类的非private、非final（finla表示不可继承的）修饰的方法或者属性；
    2、使应用程序变得更简单，因为父类涉及到的方法属性，被子类继承过来，子类代码变得更简单；子类由于大部分是继承而来的，很容易修改和扩展已有的实现。
缺点：
    1、打破了封装（隐藏细节），因为基类向子类暴露了实现细节；白盒重用，因为基类的内部细节通常对子类是可见的；当父类的实现改变时可能要相应的对子类做出改变；
    2、如果过多使用继承，会使程序变得复杂、不可控，导致类爆炸；

     

     

10、方法的重写（覆盖）；
11、抽象类；
12、接口；

p.s. 《java基础梳理-朝花夕拾》系列由何东飞根据自己工作几年以来对java的理解梳理而成，笔者闲暇时将持续更新，有不对的地方请各位指教。QQ:983489147