黑马程序员———java基础知识———面向对象



------- android培训、java培训、期待与您交流！ ----------

 一.类：是一组相关的"属性"和"行为"的集合；
    对象：是该类事物的具体体现；
 二.类和对象的关系：
  1.现实：
   类 对象
   猫 波斯猫
    折耳猫
    加菲猫
  ----------------------------------------
   狗 金毛
    藏獒
    沙皮
  2.代码：
   类   对象
   class Cat{  Cat c1 = new Cat();
    String name; c1.name = "波斯猫";
    int age; c1.age = 2;
   }   -----------------------------------
      Cat c2 = new Cat();
      c2.name = "折耳猫";
      c2.age = 3;
   -----------------------------------------------------------
   class Dog{  Dog d1 = new Dog();
    String name; d1.name = "金毛";
    int age; d1.age = 2;
   }   -----------------------------------
      Dog d2 = new Dog();
      d2.name = "藏獒";
      d2.age = 3;
      
 三.类的定义：
  1.使用关键字：class(注意小写)
  2.一个java源文件中：
   1).如果定义多个类，但只有一个是public的；而且源文件名必须与这个public的类名一致；
   2).如果定义多个类，可以没有public类；源文件名没有一致性要求；
   3).main()方法不是必须放在public类中；
  3.类中可以定义什么：
   1).成员变量：
    A.可以是基本数据类型，也可以是任何引用数据类型；
    B.可以显示初始化；
     class Student{
      String name = "张三" ;
      int age = 20;
     }
    C.可以隐式初始化；
     整型：0
     浮点：0.0
     字符：'\u0000'
     布尔：false
     引用类型：null
   2).成员方法：
    A.可以有参数，可以没参数；
                                  可以有返回值，可以没有返回值；
   
    B.方法的"形参"可以是任何Java类型(基本数据类型、引用数据类型)
    C.方法的"返回值"可以是任何Java类型(基本数据类型、引用数据类型)
    D.一个类中可以定义多个同名的方法，但形参列表不完全相同，叫：方法的重载；
   3).内部类(后面讲)；
  4.成员变量和局部变量的区别：
   1).成员变量：
    A.定义在"类体"中；可以是任何数据类型；
    B.会被自动初始化；
     class Student{
      String name;
      void show(){
       System.out.println("我叫：" + num); //打印：我叫：null
      }
     }
    C.当实例化对象后，被存储在"堆"中；
    D.当"对象"不被使用(没有任何引用)，并被垃圾回收器回收时被清理；
     
   2).局部变量：
    A.定义在某个方法、或其它代码块中；
    B.必须显示初始化，否则不能访问其值；
     class Student{
      void show(){
       String name;
       System.out.println("我叫：" + name); //编译错误。局部变量必须显示初始化才能访问其值；
       name = "张三"; //OK。可以被赋值。
      }
     }
    C.当方法或其它代码块被执行时，基本数据类型的"值"和引用数据类型的"引用"都是存储在"栈"中；
    D.当方法或代码块执行完毕时，会被立即清理；
 四.对象的使用：
  1.创建对象使用new关键字；会在堆中分配内存空间；
   格式：
    类名  变量名 = new 类名();
  2.一个类可以创建多个对象；
  3.每个“对象”的“成员变量”在"堆"中都有一份独立的空间；
    每个“对象”的“成员方法”被存储在“方法区”中，多个对象只有一个“方法空间”；
  4.对象的"引用(地址)"被存储在"栈"中；
 五.方法的形参：
  1.可以是"基本数据类型"：
   1).调用时，必须传递此类型的“值”；
   2).调用时，是将值复制一份到方法内部；
   3).在方法内，使用形参接收此值的副本；
   4).在方法内，如果更改此值，对原值没有影响；
    int a = 10;
    show(a);
    System.out.println(a);
    ----------------------------------
    public void show(int n){//n = 10
     n = 20;
    }
  2.可以是“引用数据类型”：
   1).调用时，必须传递此类型的“引用”；
   2).调用时，是将“引用(地址)”复制一份到方法内部；
   3).在方法内，使用形参接收此“引用”的副本；
   4).在方法内，如果通过此引用更改堆中的值，对原堆中的值将会产生影响；
 六.匿名对象：
  1.匿名对象：没有名字的对象：new Student();
  2.匿名对象的两种使用情况：
   1).对象调用方法仅仅一次的时候:new Student().show();
   2).作为实际参数传递:printStudent(new Student());

例如：

class Student
{
 String name;
 int age;
 char sex;
}
class MyMath
{
 double getPI(){
  return 3.1415926;
 }
 void printStudent(Student stu){//表示：接收一个有效的Student的引用
  System.out.println("学员姓名：" + stu.name);
  System.out.println("学员年龄: " + stu.age);
  System.out.println("学员性别：" + stu.sex);
 }
}
class Demo 
{
 public static void main(String[] args) 
 {
 // MyMath math = new MyMath();

  System.out.println(new MyMath().getPI());

  //如果后续不再使用math对象，那么可以在调用getPI()方法时，使用"匿名对象"
  
  new MyMath().printStudent(new Student());
 }
}

 七.封装：
  1.直接对外部暴露成员变量是很不安全的，这时可以将成员变量“私有化”，对外提供公有的
    get和set方法；
  2.封装的好处：
   1)隐藏实现细节，提供公共的访问方式
   2)提高了代码的复用性
   3)提高安全性。
  3.封装的原则：
   1)将不需要对外提供的内容都隐藏起来。
   2)把属性隐藏，提供公共方法对其访问。

封装的例子如下：

class Student
{
 private String name;
 private int age;
 private String schooName = "黑马程序员-北京校区";//此属性的值，只能被获取，不能被设置
 
 void setAge(int a){
  age = a;
 }
 int getAge(){
  return age;
 }

 void setName(String n){
  name = n;
 }
 String getName(){
  return name;
 }

 String getSchoolName(){
  return schoolName;
 }

}
class Demo 
{
 public static void main(String[] args) 
 {
  Student stu = new Student();
 // stu.name = "刘德华";
 // stu.age = 200;//当age属性被私有化后，这里不能直接访问了

 // System.out.println(stu.name + "," + stu.age);//当age属性被私有化后，这里不能直接访问了
  
 
  stu.setName("刘德华");
  stu.setAge(20);
  
  System.out.println(stu.getName() + "," + stu.getAge());

 }
}

 八.private关键字：
  1.是一种“访问修饰符”(将在day10讲到)；
    Java中一共有四种访问修饰符：从宽到窄：public，protected，(默认)，private
  2.用于修饰“成员变量”和“成员方法”；
  3.被private修饰的成员，只能在类的内部被其它成员访问。在类外部无法访问；
 九.this关键字：
  1.每个类都有一个“隐式”的变量：this；
  2.它是在实例化对象时，由虚拟机自动赋值的，会被自动赋值为当前对象的“引用”。
                  所以每个对象内的this变量的值是不同的；
  3.this关键字可以调用本对象的“成员属性”、“成员方法”、“构造方法”；
  4.以下情况必须显示的使用this：
   1).“局部变量”覆盖“成员变量”时，可以使用this显示的访问被覆盖的“成员变量”；
       否则访问的是“局部变量”；
   2).在一个构造方法中调用本类的其它构造方法；this()或this(实参)；

例如：

class Student{

 String name;
 int age;
 int num = 10;

 void show(){
  System.out.println(this.name + "," + this.age);//this可以调用本类的成员属性
 }
 void fun(){
  show();//OK的，可以这样直接调用
  this.show();//OK的，也可以这样调用；
 }
 void fun2(){
  int num = 20;//局部变量覆盖同名的成员变量，这个是可以的。
  System.out.println("num = " + num);//此时访问的num 就是局部的num
  System.out.println("this.num = " + this.num);//此时可以通过this关键字，显示的访问被覆盖的成员变量num
 }

}
class Demo 
{
 public static void main(String[] args) 
 {
  Student stu1 = new Student();
  stu1.name = "刘德华";
  stu1.age = 20;

  Student stu2 = new Student();
  stu2.name = "张学友";
  stu2.age = 22;

  Student stu3 = new Student();
  stu3.fun2();
 }
}