JavaSE类和对象

一、面向对象与面向过程

1）面向过程：注重过程，不能缺少任何一个环节，扩展和维护起来比较麻烦。

2）面向对象：主要依靠对象之间的交互完成，并不注重过程。

3）类似于：洗衣服。面向过程注重于洗衣服的过程，要先打湿衣服再....直到洗衣服结束，一个步骤都不能少；而面向对象则是注重对象，人把衣服扔进洗衣机，放入洗衣液，打开洗衣机即可，不会在乎洗衣机是如何洗衣服的。

4）面向对象和面向过程都是一种思想，而不是一种语言。

二、类

1）类的定义采用大驼峰，包含成员变量和成员方法。

2）public修饰的类名必须和文件名相同。

3）类的实例化实现：类名 对象=new 类名（）。new实例化的对象都存储在堆上。

4）当成员变量没有初始化时，都有默认值（例如：引用类型->null,int->0,double->0.0,boolean->false,char->'\u0000'等等）。

5）一个类可实例化多个对象。

三、this引用

this应用：指向当前对象，在成员方法中对所有成员变量的操作，都是通过this引用去访问的。

1、this引用的三种用法：

（1）this.成员变量

（2）this.成员方法

*注意：此处的成员变量和成员方法只能是普通的，而不能是静态的。

（3）this（构造方法）

四、构造方法

构造方法：名字必须与类名相同；没有返回类型；在创建对象时自动调用，并且在对象的生命周期内只调用一次；构造方法可以重载。

1、无参构造方法->编译器会默认生成

public 类名（）{...}

2、带参构造方法->用户自己定义，此时编译器就不会生成无参构造方法

public 类名（参数）{...}

3、在构造方法中，能够用this调用其他构造方法

eg:可以在无参构造方法中调用带参构造方法，但是this.(...)语句必须是第一句;也不能形成环，在无参中调用带参，又在带参中调用无参。

五、封装

面向对象程序三大特性：封装、继承、多态（不代表只有这三种特性）。

1、封装：隐藏对象的属性和实现细节（private），仅对外公开接口来和对象交互。

2、访问限定符

范围	private	default	protected	public
同一包中的同一类	yes	yes	yes	yes
同一包中的不同类		yes	yes	yes
不同包中的子类			yes	yes
不同包中的非子类				yes

1）protecte主要在继承中使用。

2）default是什么都不写时的默认权限。

3）成员变量一般设置为private，此时要写get和set方法；成员方法一般设置为public。

3、包

包是对类、接口的封装机制的体现，是一种对类或接口等的很好的组织方式。

1）用import导入包，用import static导入包中静态的方法和字段。

当要使用某个包中的许多类时，可以这样写import java.util.*，但是这种写法有时也会产生歧义，eg:

import java.util.*
import java.sql.*
public class Test{
   public static void main(String[] args){
       Date date=new Date();
       System.out.println(date.getTime());
   }
}

此时就会出现编译出错，以为在util和sql中都有Date这个类，就会产生歧义，所以要指明是哪个包下的Date类。

import java.util.*
import java.sql.*
public class Test{
   public static void main(String[] args){
       java.util.Date date=new java.util.Date();
       System.out.println(date.getTime());
   }
}

2）用package声明当前的Java类在哪个包下，若未声明，则会放入默认包中。

3）自定义包

包名尽量是唯一的名字，包名要和代码路径相匹配。

六、static

1、static修饰成员变量

1）称为静态成员或类成员，不属于某一个具体的对象，而是所有对象共享的。

2）可以通过对象去访问（对象.变量名），建议用类名访问（类名.变量名）。

2、static修饰成员方法

1）称为静态成员方法，是类的方法，不是某个对象所特有的。通常静态成员变量是通过静态方法来访问的。

2）可以通过对象调用，但建议通过类名调用（类名.静态方法名（...))。

3）静态方法中没有隐藏的this引用参数，不能在其中访问任何非静态成员变量。

3、static成员变量初始化

1）就地初始化

在定义时就直接给初始值

2）静态代码块

七、代码块

用{ }定义的一段代码就是代码块。

1、普通代码块

定义在方法中的代码块（少见）。

2、构造代码块

一般用于初始化实例成员变量。

3、静态代码块

一般用于初始化静态成员变量。static{....}

1）执行时，静态代码块先于实例代码块先于构造方法。

2）无论多少个对象，静态代码块只会调用一次。

3）因为静态成员变量是类的属性，所以在JVM加载类时开辟空间并初始化的。类加载：双亲委派模型。

4）若一个类中有多个静态代码块，编译时，按先后次序合并。

八、内部类

定义在一个类中的类是内部类，定义在一个方法中的类是外部类。

1）内部类和外部类共用同一个Java源文件，经过编译后，内部类会形成单独的字节码文件（外部类名$内部类名.class）

1、成员内部类

1）普通内部类

（1）可以访问外部类中任意成员

（2）若外部类与内部类中有相同名称的成员时，优先访问自己的。如果要访问外部类同名成员，必须是：外部类名称.this.同名成员名字。

（3）获取普通内部类对象：

外部类名.内部类名  对象名=外部类对象的引用.new  内部类名（）
 

OutClass outclass=new OutClass();

OutClass.InnerClass innerclass=outclass.new InnerClass();

普通内部类对象必须在有外部类对象才能创建。

(4)普通内部类中不能定义静态成员变量，若要定义，只能是static final（常量）

public static final a=1;

(5)普通内部类中有自己的this，也有外部类的this。

2）静态内部类

（1）只能访问外部类中的静态成员，若要访问非静态，要想创建外部类对象。

（2）获取静态内部类对象：

外部类名.内部类名  对象名=new  外部类名.内部类名（）

创建静态内部类对象不需要先创建外部类对象。

3）局部内部类（几乎不会用）

（1）定义在方法内部的，只能在方法内部使用，不能被public，static等等修饰符修饰。

（2）有自己独立的字节码文件（外部类名$x内部类名.class，x是整数）。

九、打印对象

有默认的toSring()方法

Student stu=new Student("Jack",18);
System.out.println(stu);

此时并不会如我们所想的打印出对象的信息，所以我们需要自己重写toString()方法。

@Override
public String toString(){
   return "["+name+","+age+"]";
}

idea可以直接右键Generate生成toString方法。