手册   游戏   WEB   字典   单词   在线工具  

java面向对象浅析

1.（了解） 面向对象 vs 面向过程 例子：人开门；把大象装冰箱

2. 面向对象的编程关注于类的设计！
1）一个项目或工程，不管多庞大，一定是有一个一个类构成的。
2）类是抽象的，好比是制造汽车的图纸。
而具体的一辆一辆的车，是根据图纸制造的，实际上就是类的实例化

3. 完成一个项目（或功能）的思路
1）所要完成的功能对应的类的对象是否存在。
2）若存在，则通过对象直接调用对应的类中的属性或方法即可 。 例如 Scanner。
3）若不存在，需要创建类的对象。甚至说，类都不存在，就需要设计类。

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

   

1. 关于于类的设计

2. 类的组成成分：
1） 属性（成员变量，Field）
2）方法（成员方法，函数，Method）

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

2.2 方法：提供某种功能的实现 main 方法也是方法，main 方法里边的属性也必须要赋值。
* 1）实例：public void eat(){// 方法体}
* public String getName(){}
* public void setName(String n){}
* 格式：权限修饰符 返回值类型（void: 无返回值 / 具体的返回值） 方法名 (形参){}
*
* 2) 关于返回值类型：void：表明此方法不需要返回值
* 有返回值的方法：在方法的最后一定有 return + 返回值类型对应的变量
* 记忆：void 与 return 不可以同时出现一个方法内。像一对 "冤家"。
*
* 3) 方法内可以调用本类的其他方法或属性，但是不能在方法内再定义方法！

  1. public class Zoo {
  2.     public static void main(String[] args) {
  3.         //基本数据类型的声明：数据类型 变量名 = 初始化值
  4.         int i = 10;
  5.         //类的实例化:如下的a1就是一个实实在在的对象
  6.         Animal a1 = new Animal();
  7.         //int[] arr = new int[10];
  8.         System.out.println("name:" + a1.name + " age:" + a1.age);
  9.         //通过对象调用属性
  10.         a1.name = "花花";
  11.         a1.age = 3;
  12.         System.out.println("name:" + a1.name + " age:" + a1.age);
  13.         //通过对象调用方法
  14.         a1.eat();
  15.         a1.sleep();
  16.         //再创建一个类的对象
  17.         Animal a2 = new Animal();
  18.         System.out.println("name:" + a2.name + " age:" + a2.age); //null 0
  19.         a2.name = "小花";
  20.         System.out.println("name:" + a1.name + " age:" + a1.age);
  21.         System.out.println("name:" + a2.name + " age:" + a2.age);
  22.         //a3不意味着相较于a1重新创建的一个对象，而是a1与a3共用一个对象实体
  23.         Animal a3 = a1;
  24.         System.out.println("name:" + a3.name + " age:" + a3.age); //与a1一样
  25.         a3.name = "维尼熊";
  26.         System.out.println("a1：name:" + a1.name + " age:" + a1.age);
  27.         System.out.println(a2.getName()); //a2.name;
  28.         System.out.println(a2.desc());
  29.     }
  30. }
  31. class Animal {
  32.     //1.属性
  33.     String name;
  34.     int age;
  35.     //2.方法
  36.     public void eat() {
  37.         System.out.println("动物进食");
  38.     }
  39.     public void sleep() {
  40.         System.out.println("动物休眠");
  41.         //return;
  42.     }
  43.     public String getName() {
  44.         return name;
  45.     }
  46.     public int getAge() {
  47.         System.out.println("hello");
  48.         return age;
  49.         //其后不可以声明语句
  50.         //System.out.println("hello");
  51.     }
  52.     //当通过对象调用此方法时，会将方法的方法的返回值提供给方法的调用者，也就是当前的对象。
  53.     public String desc() {
  54.         if (age > 2) {
  55.             return "恰同学少年";
  56.         } else {
  57.             return "还是看动画片的年龄";
  58.         }
  59.     }
  60.     public void setName(String n) { //n:局部变量
  61.         name = n;
  62.     }
  63.     public void addAge() {
  64.         int i = 0; //局部变量
  65.         age += i;
  66.     }
  67.     public void info() {
  68.         //		可以在方法内调用本类的其他方法，但是不可以在方法内定义新的方法
  69.         eat();
  70.         sleep();
  71.         //		public void breath(){
  72.         //			System.out.println("呼吸");
  73.         //		}
  74.     }
  75.     //	System.out.println("hello!");
  76.


3. 面向对象编程的思想的落地法则一：
1）设计并创建类及类的成分
2）实例化类的对象  
3）通过 "对象. 属性" 或 "对象. 方法" 的形式完成某项功能

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

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

 

* 方法的重载（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){

}

 

* 可变个数的形参的方法：
* 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]);
}
}

 

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

  1. package text;
  2. import java.util.Scanner;
  3. public class Circle {
  4.     public static void main(String[] args) {
  5.         Scanner sc = new Scanner(System. in );
  6.         double g = sc.nextInt();
  7.         TestCircle tc = new TestCircle();
  8.         tc.setRadius(g);
  9.         double m = tc.mianji();
  10.         System.out.println(m);
  11.     }
  12. }
  13. class TestCircle {
  14.     private double radius;
  15.     public double getRadius() {
  16.         return radius;
  17.     }
  18.     public void setRadius(double r) {
  19.         this.radius = r;
  20.     }
  21.     public double mianji() {
  22.         return 3.14 * radius * radius;
  23.     }
  24. }


* 二、类对象的属性赋值的先后顺序：①属性的默认初始化 ②属性的显式初始化③通过构造器给属性初始化
* ④通过 "对象. 方法" 的方式给属性赋值

  
  1. public class lianxixixi {
  2.     String pinpai;
  3.     String jixing;
  4.     double price;
  5.     double yh; //油耗
  6.     double lc; //里程
  7.     double yxrj; //油箱容积
  8.     double syyl; //剩余油量
  9.     public lianxixixi(String pinpai, String jixing, double price, double yh, double yxrj, double syyl) {
  10.         this.pinpai = pinpai;
  11.         this.jixing = jixing;
  12.         this.price = price;
  13.         this.yh = yh;
  14.         this.yxrj = yxrj;
  15.         this.syyl = syyl;
  16.     }
  17.     public void show() {
  18.         System.out.println("品牌" + pinpai);
  19.         System.out.println("车型" + jixing);
  20.         System.out.println("价格" + price);
  21.         System.out.println("油耗" + yh);
  22.         System.out.println("里程" + lc);
  23.         System.out.println("油箱容积" + yxrj);
  24.         System.out.println("剩余油量" + syyl);
  25.     }
  26.     public void run(double lc) {
  27.         syyl = syyl - (lc / 100) * yh;
  28.         if (syyl < 10) {
  29.             System.out.println("再开，一会就得车开你了！");
  30.         } else {
  31.             System.out.println(syyl);
  32.         }
  33.     }
  34. }
  35. public class lianxixi2 {
  36.     public static void main(String[] args) {
  37.         lianxixixi li = new lianxixixi("比亚迪", "F0", 45000.0, 7.0, 60.0, 59.0);
  38.         li.show();
  39.         li.run(1000);
  40.     }
  41. }

1.static: 静态的，可以用来修饰属性、方法、* 代码块（或初始化块）、* 内部类

2.
static 修饰属性（类变量）:
* 1. 由类创建的所有的对象，都共用这一个属性
* 2. 当其中一个对象对此属性进行修改，会导致其他对象对此属性的一个调用。vs 实例变量（非 static 修饰的属性，各个对象各自拥有一套副本）
* 3. 类变量随着类的加载而加载的，而且独一份
* 4. 静态的变量可以直接通过 "类. 类变量" 的形式来调用
* 5. 类变量的加载是要早于对象。所以当有对象以后，可以 "对象. 类变量" 使用。但是 "类. 实例变量" 是不行的。
* 6. 类变量存在于静态域中。
*
* static 修饰方法（类方法）:
* 1. 随着类的加载而加载，在内存中也是独一份
* 2. 可以直接通过 "类. 类方法" 的方式调用
* 3. 内部可以调用静态的属性或静态的方法，而不能调用非静态的属性或方法。反之，非静态的方法是可以调用静态的属性或静态的方法
* > 静态的方法内是不可以有 this 或 super 关键字的！
* 注：静态的结构 (static 的属性、方法、代码块、内部类) 的生命周期要早于非静态的结构，同时被回收也要晚于非静态的结构

 

Eclipse 中编辑好了一个类，点击运行时出现如图所示的现象，现在编辑好的这个类并无错误，点击 Proceed 可正常运行。

按照字面意思就是，在这个 "工程" 中存在错误，打开工程列表 ---- 找到前边有红色叉叉的某个类，将错误去掉。

这个弹窗也就不会在出现了。
成员变量 局部变量 static

来源: http://www.cnblogs.com/gaofangquan/p/7197083.html


与本文相关文章

  1. Java 学习笔记 (三): 面向对象
  2. Java 面向对象特性总结
  3. Java面向对象
  4. JAVA 基础 6 - 面向对象 1
  5. 学习 java 第三天 --- 面向对象
  6. java面向对象（三）理论
  7. JAVA 学习总结 - 面向对象
  8. Java 面向对象知识扩展
暂无,快来抢沙发吧！
更多





黑ICP备17005318号-1