黑马程序员——JAVA之面向对象（一）

------- http://www.itheima.com"
target="blank">android培训http://www.itheima.com"target="blank">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.可以显示初始化；C.可以隐式初始化；

                     class Student{

                     String name = "张三" ;

                      int age = 20;

                     }

                           

                 整型：0

                 浮点：0.0

                 字符：'\u0000'

                 布尔：false

                引用类型：null

         2).成员方法：

                A.可以有参数，可以没参数；可以有返回值，可以没有返回值；

                B.方法的"形参"可以是任何Java类型(基本数据类型、引用数据类型)

                C.方法的"返回值"可以是任何Java类型(基本数据类型、引用数据类型)

                D.一个类中可以定义多个同名的方法，但形参列表不完全相同，叫：方法的重载；

          3).内部类(后面讲)；

     4.成员变量和局部变量的区别：

             1).成员变量：A.定义在"类体"中；可以是任何数据类型；B.会被自动初始化；

                class Student{

              
4000
  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);//10

----------------------------------

             public void show(int n){//n = 10

             n = 20;//对原来的a的值是没有影响的；

         }

         2.可以是“引用数据类型“：1).调用时，必须传递此类型的“引用”；   2).调用时，是将“引用(地址)”复制一份到方法内部；   3).在方法内，使用形参接收此“引用”的副本；    4).在方法内，如果通过此引用更改堆中的值，对原堆中的值将会产生影响；

              int[] arr = {14,324,435};//arr = 0x2233

             show(arr);//show(0x2233)

             System.out.println(arr[0]);//1000

-----------------------------------

              public void show(int[] array){//array = 0x2233

              array[0] = 1000;

             }

     六.匿名对象：

           1.匿名对象：没有名字的对象：new Student();

           2.匿名对象的两种使用情况：

                 1).对象调用方法仅仅一次的时候:new Student().show();

                2).作为实际参数在方法中传递:printStudent(new Student());

    七.封装：

           1.直接对外部暴露成员变量是很不安全的，这时可以将成员变量“私有化”，对外提供公有的

  get和set方法；

          2.封装的好处：

               1)隐藏实现细节，提供公共的访问方式

              2)提高了代码的复用性

              3)提高安全性。

          3.封装的原则：

               1)将不需要对外提供的内容都隐藏起来。

               2)把属性隐藏，提供公共方法对其访问。

   八.private关键字：

             1.是一种“访问修饰符”(将在day10讲到)；

                Java中一共有四种访问修饰符：从宽到窄：public，protected，(默认)，private

             2.用于修饰“成员变量”和“成员方法”；

             3.被private修饰的成员，只能在类的内部被其它成员访问。在类外部无法访问；

    九.this关键字：

            1.每个类都有一个“隐式”的变量：this；

            2.它是在实例化对象时，由虚拟机自动赋值的，会被自动赋值为当前对象的“引用”。

            3.this关键字可以调用本对象的“成员属性”、“成员方法”、“构造方法”；

            4.以下情况必须显示的使用this：

                    1).“局部变量”覆盖“成员变量”时，可以使用this显示的访问被覆盖的“成员变量”；否则访问的是“局部变量”；

                    2).在一个构造方法中调用本类的其它构造方法；this()或this(实参)；

 

 

 

部分代码演示
 

/*
this关键字：

1.类中可以定义：成员属性、成员方法；
2.当实例化一个类的对象时，在堆空间，会产生此类对象的空间，内部包含了所有"成员属性"。
"成员方法"的字节码会被存储在"方法区"；
3.实例化多个对象，在堆中：每个对象都有独立的"成员属性"的空间，但"方法区中的方法的字节码"空间,只有一个；
4.如果方法内部需要访问"成员变量"，那么JVM就要区分是哪个对象调用的此方法，那么就会去访问哪个对象的
成员属性。区分的方式：this
5.每个类都有一个隐式的this变量；
当实例化此类的一个对象时，由JVM自动为其赋值，赋值为：当前对象的引用；
6.我们可以显示的使用this去访问"本类的--成员属性、成员方法";
7.有两种情况，必须的显示的使用this关键字：
1).局部变量覆盖成员变量时；
2).在一个构造方法内调用另一个构造方法(下次课讲)
*/
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();

}
}

 
 

 

 

/*
一个标准的Student类
*/
class Student
{
//********私有的成员属性*********//
private String name;
private int age;
private char sex;

//********构造方法****************//
//1.无参的构造方法，一般什么都不做
Student(){
}
//2.带全参的构造方法：为所有的成员属性赋值
Student(String name ,int age,char sex){
this.name = name;
this.age = age;
this.sex = sex;
}

//*********一些get和set方法***********//
void setName(String name){
this.name = name;
}
String getName(){
return this.name;
}
void setAge(int age){
this.age = age;
}
int getAge(){
return this.age;
}
void setSex(char sex){
this.sex = sex;
}
char getSex(){
return this.sex;
}

//还可以定义一些普通成员方法
void show(){
System.out.println("大家好，我叫：" + this.name +
"，今年：" + this.getAge() +
"，性别：" + this.sex);
}
}
class Demo
{
public static void main(String[] args)
{
//通过"无参构造方法"构造一个对象
Student stu = new Student();
stu.setName("张三");
stu.setAge(20);
stu.setSex('男');

System.out.println(stu.getName() + "," + stu.getAge() + "," + stu.getSex());
System.out.println("调用show()方法：");
stu.show();

//通过"全参的构造方法"构造一个对象
Student stu2 = new Student("李四",22,'男');
System.out.println(stu2.getName() + "," + stu2.getAge() + "," + stu2.getSex());
System.out.println("调用show()方法：");
stu2.show();
}
}

 

  

/*
当我们定义一个类，在类中定义"成员属性"时，这些属性是可以直接被其它类访问的。
这种方式，是很不安全的。所以这里讲解Java的封装：

*/
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());

}
}

 

 

 

/*
1.怎样调用类的成员属性和成员方法：
1).一定要通过类的"对象的引用"去调用；
2.以下情况可以使用匿名对象：
1).如果调用某个类的方法，只需要调用一次，这时，可以使用匿名对象；
2)

*/
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.prin
9cbc
tln(new MyMath().getPI());

new MyMath().printStudent(new Student());
}

}