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

最新推荐文章于 2023-07-10 16:30:27 发布

Believeyou365

最新推荐文章于 2023-07-10 16:30:27 发布

阅读量526

点赞数

基础知识概述

一. 类：是一组相关的"属性"和"行为"的集合；

对象：是该类事物的具体体现；

二.类和对象的关系：

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{

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(实参)；

部分代码演示

[java]view plaincopy 
   
 /* 
     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();  
   
   
     }  
 }  

[java]view plaincopy 
   
 /* 
     一个标准的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]view plaincopy 
   
 /* 
     当我们定义一个类，在类中定义"成员属性"时，这些属性是可以直接被其它类访问的。 
     这种方式，是很不安全的。所以这里讲解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());  
   
     }  
 }  

[java]view plaincopy 
   
 /* 
     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.println(new MyMath().getPI());  
   
           
         new MyMath().printStudent(new Student());  
     }  
   
   
 }  