Java中类与对象

1、（了解） 面向对象  vs 面向过程

2、面向对象编程的三条主线：
　　1）类及类的构成成分：属性 方法 构造器 代码块 内部类
　　2）面向对象编程的特征：封装性 继承性 多态性 （抽象性）
　　3）其它的关键字：this super package import static final abstract interface ...

3、类的组成成分：

　　1） 属性（成员变量，Field）
　　2）方法（成员方法，函数，Method）

　　3.1属性：
　　* 成员变量 vs 局部变量
　　* 相同点： 1.遵循变量声明的格式： 数据类型 变量名 = 初始化值
　　* 　　　　 2.都有作用域
　　* 不同点： 1.声明的位置的不同 ：成员变量：声明在类里，方法外
　　* 　　　　　　　　　　　　　　 局部变量：声明在方法内，方法的形参部分，代码块内
　　* 　　　　 2.成员变量的修饰符有四个：public private protected 缺省
　　*　　　　　　　　　　　　　　 局部变量没有修饰符，与所在的方法修饰符相同。
　　* 　　　　 3.初始化值：一定会有初始化值。
　　*　　　　　　　　　　　　　　 成员变量:如果在声明的时候，不显式的赋值，那么不同数据类型会有不同的默认初始化值。
　　* 　　　　　　　　 　　byte short int long ==>0
　　* 　　　　　　　　　　float double ==>0.0
　　* 　　　　　　　　　　char ==>空格
　　* 　　　　　　　　　　boolean ==>false
　　* 　　　　　　　　　　引用类型变量==>null
　　* 　　　　　　　　　　局部变量：一定要显式的赋值。（局部变量没有默认初始化值）
　　* 　　　　 4.二者在内存中存放的位置不同:成员变量存在于堆空间中；局部变量：栈空间中
　　*
　　* 总结：关于变量的分类：　　1）按照数据类型的不同：基本数据类型（8种） & 引用数据类型
　　* 　　　　　　　　　　　       2）按照声明的位置的不同：成员变量 & 局部变量

　　3.2 方法：提供某种功能的实现
　　* 1）实例：public void eat( ){  //方法体   }
　　* 　　　　 public String getName( ){    }
　　* 　　　　 public void setName(String n){    }
　　* 　 格式：权限修饰符 返回值类型（void:无返回值/具体的返回值） 方法名(形参){}　　　　* 

　　* 2）关于返回值类型：void：表明此方法不需要返回值
　　* 　　　　 有返回值的方法：在方法的最后一定有return + 返回值类型对应的变量
　　* 　　 记忆：void 与return不可以同时出现一个方法内。
　　*
　　* 3）方法内可以调用本类的其他方法或属性，但是不能在方法内再定义方法！

4、类的初始化的内存解析
　　4.1 内存划分的结构：
　　　　栈(stack):局部变量 、对象的引用名、数组的引用名
　　　　堆(heap):new 出来的“东西”（如：对象的实体，数组的实体），含成员变量
　　　　方法区:含字符串常量
　　　　静态域：声明为static的变量

　　4.2 理解的基础上，学会基本的创建的类的对象在内存中的运行。

5、方法的重载（overload）

　　* 定义：1.同一个类中    2.方法名必须相同     3.方法的参数列表不同（①参数的个数不同②参数类型不同）
　　* 　　【强调】  方法的重载与方法的返回值类型没有关系！

　　//如下的四个方法构成重载
　　//定义两个int型变量的和
　　public int getSum(int i,int j){
　　　　return i + j;
　　}
　　//定义三个int型变量的和
　　public int getSum(int i,int j,int k){
　　　　return i + j + k;
　　}
　　//定义两个double型数据的和
　　public double getSum(double d1,double d2){
　　　　return d1 + d2;
　　}
　　//定义三个double型数组的和
　　public void getSum(double d1,double d2,double d3){
　　　　System.out.println(d1 + d2 + d3) ; 
　　}

　　//不能与如上的几个方法构成重载
　　// public int getSum1(int i,int j,int k){
　　// 　　 return i + j + k;
　　// }
　　// public void getSum(int i,int j,int k){
　　// 　　 System.out.println(i + j + k);
　　// }

　　//以下的两个方法构成重载。
　　public void method1(int i,String str){    }
　　public void method1(String str1,int j){   }

6、可变个数的形参的方法：

　　* 1.格式：对于方法的形参： 数据类型 ... 形参名
　　* 2.可变个数的形参的方法与同名的方法之间构成重载
　　* 3.可变个数的形参在调用时，个数从0开始，到无穷多个都可以。
　　* 4.使用可变多个形参的方法与方法的形参使用数组是一致的。
　　* 5.若方法中存在可变个数的形参，那么一定要声明在方法形参的最后。
　　* 6.在一个方法中，最多声明一个可变个数的形参。

　　//如下四个方法构成重载
　　//在类中一旦定义了重载的可变个数的形参的方法以后，如下的两个方法可以省略
　　// public void sayHello(){
　　// 　　 System.out.println("hello world!");
　　// }
　　// public void sayHello(String str1){
　　// 　　 System.out.println("hello " + str1);
　　// }
　　//可变个数的形参的方法
　　public void sayHello(String ... args){
　　　　for(int i = 0;i < args.length;i++){
　　　　　　System.out.println(args[i] + "$");
　　　　}
　　　　//System.out.println("=====");
　　}

　　public void sayHello(int i,String ... args){
　　//public void sayHello(String ... args,int i){
　　　　System.out.println(i);
　　　　for(int j = 0;j < args.length;j++){
　　　　　　System.out.println(args[j] + "$");
　　　　}
　　}

　　public void sayHello1(String[] args){
　　　　for(int i = 0;i < args.length;i++){
　　　　　　System.out.println(args[i]);
　　　　}
　　}

 7、【重点、难点】方法的参数传递

　　* 1.形参：方法声明时，方法小括号内的参数
　　* 实参：调用方法时，实际传入的参数的值
　　*
　　* 2.规则：java中的参数传递机制：值传递机制
　　* 　　 1）形参是基本数据类型的：将实参的值传递给形参的基本数据类型的变量
　　* 　　 2）形参是引用数据类型的：将实参的引用类型变量的值（对应的堆空间的对象实体的首地址值）传递给形参的引用类型变量。

　　【典型例题1】

　　public static void main(String[] args) {
　　　　TestArgsTransfer tt = new TestArgsTransfer( );
　　　　int i = 10;
　　　　int j = 5;
　　　　System.out.println("i:" + i + " j:" + j) ;   //  i : 10 j : 5
　　　　// 交换变量i与j的值
　　　　// int temp = i;
　　　　// i = j;
　　　　// j = temp;
　　　　tt.swap(i, j);//将i的值传递给m，j的值传递给n
　　　　System.out.println("i:" + i + " j:" + j);//i : 10 j : 5
　　}
　　//定义一个方法，交换两个变量的值
　　public void swap(int m,int n){
　　　　int temp = m;
　　　　m = n;
　　　　n = temp;
　　　　System.out.println("m:" + m + " n:" + n);

　　}

　　分析值传递，使用swap方法前后！！

　　【典型例题2】
　　　public static void main(String[] args) {
　　　　　TestArgsTransfer1 tt = new TestArgsTransfer1( ) ;
　　　　　DataSwap ds = new DataSwap( ) ;
　　　　　System.out.println("ds.i:" + ds.i + " ds.j:" + ds.j);
　　　　　tt.swap(ds);
　　　　   System.out.println(ds);
　　　　   System.out.println("ds.i:" + ds.i + " ds.j:" + ds.j);
　　　}
　　//交换元素的值
　　public void swap(DataSwap d){
　　　　int temp = d.i;
　　　　d.i = d.j;
　　　　d.j = temp;
　　　　System.out.println(d);//打印引用变量d的值
　　}

　　class DataSwap{
　　　　int i = 10;
　　　　int j = 5;
　　}

8、面向对象思想的（封装性的思想）①将类的属性私有化，②提供公共的方法（setter & getter）来实现调用。

9、四种权限修饰符
　　1）权限从大到小为：public protected 缺省 private
　　2）四种权限都可以用来修饰属性、方法、构造器
　　3）修饰类的话：public 缺省

10、构造器(构造方法)

　　* 构造器的作用：①创建对象 ②给创建的对象的属性赋值
　　*
　　* 1.设计类时，若不显式声明类的构造器的话，程序会默认提供一个空参的构造器.
　　* 2.一旦显式的定义类的构造器，那么默认的构造器就不再提供。
　　* 3.如何声明类的构造器。格式：权限修饰符 类名(形参){ }
　　* 4.类的多个构造器之间构成重载
　　* 5.对象的属性赋值的先后顺序：①属性的默认初始化 ②属性的显式初始化③通过构造器给属性初始化 ④通过"对象.方法"的方式给属性赋值

11、this

　　1.使用在类中，可以用来修饰属性、方法、构造器
　　2.表示当前对象或者是当前正在创建的对象
　　3.当形参与成员变量重名时，如果在方法内部需要使用成员变量，必须添加this来表明该变量时类成员
　　4.在任意方法内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性
　　5.在构造器中使用“this(形参列表)”显式的调用本类中重载的其它的构造器
　　　　>5.1 要求“this(形参列表)”要声明在构造器的首行！
　　　　>5.2 类中若存在n个构造器，那么最多有n-1构造器中使用了this。

12、package与import

　　/*
　　* package: 声明源文件所在的包，写在程序的第一行。
　　* 每“.”一次，表示一层文件目录。
　　* 包名都要小写。
　　*
　　* import:
　　* 1)显式导入指定包下的类或接口
　　* 2)写在包的声明和源文件之间
　　* 3)如果需要引入多个类或接口，那么就并列写出
　　* 4)如果导入的类是java.lang包下的，如：System String Math等，就不需要显式的声明。
　　* 5)理解.*的概念。比如java.util.*;
　　* 6)如何处理同名类的导入。如：在util包和sql包下同时存在Date类。
　　* 7)import static 表示导入指定类的static的属性或方法
　　* 8)导入java.lang.*只能导入lang包下的所有类或接口，不能导入lang的子包下的类或接口
　　*/