Java面向对象之基本概念及封装

 

一.面向对象的思想概述:面向对象是基于面向过程的一种编程语言

(1)面向对象思想的特征:

                            1)符合我们的行为思想习惯; 2)将复杂的事情简单化;  3)从执行者变成了指挥者;

(2)面向对象的三大特征:

                            1)封装性; 2)继承性; 3)多态性;

*面向过程和面向对象的区别:

       以"把大象装进冰箱"为例

                       1)装大象的方法in()
                       2)开冰箱门:open()
                       3)关闭冰箱门:close()

面向过程:
			class Test{
				
				main(..){
					//分别调用三个方法
					open();
					in();
					close();
				}
				
				
				//开冰箱门
				public static void open(){
					System.out.println("开冰箱门...") ;
				}
				//装大象
				public static void in(){
					System.out.println("把大象塞进冰箱") ;
				}
				
				//关闭冰箱门
				public static void close(){
					System.out.println("关闭冰箱门...") ;
				}
			}
			
	面向对象:
			把大象装进冰箱 :   名词提取法:  大象类,冰箱类,测试类
			
			class 大象类{
				public static void in(){//被静态修饰的方法可以被类名直接调用!(类名.方法();)
					System.out.println("把大象塞进冰箱") ;
				}
			}
			
			class 冰箱类{
				public static void open(){
					System.out.println("开冰箱门...") ;
				}
				
				public  static  void close(){
					System.out.println("关冰箱门...") ;
				}
			}
		
			class Test{//测试类,有main方法去执行
				main(){
				
					类名.方法名() ;
					大象类.in() ;
					冰箱类.open();
					冰箱类.close() ;
			
				}
			}

(3)面向对象开发:

                    创建对象(前提是有类),使用对象,指挥对象做事情(用对象.方法();)

(4)面向对象设计:

                    其实就是在管理和维护对象之间的关系

(5)类和对象的关系:

学习编程语言，就是为了模拟现实世界的事物,面向对象语言中现实世界的事物在代码中如何体现的?

            面向对象,就是将现实世界的事物----->代码中的:类

 

      将事物看成XX类

      将事物对应的属性----->看成这个类的成员变量
      将事物对应的行为----->看成这个类的成员方法

      举例:描述一个学生事物

   分析:           学生事物                                               Student  

                              属性:姓名,年龄,性别,学号                        成员变量

                              行为:学习                                               成员方法

 

1)首先,自定义一个学生类

//这是一个学生类
public class Student {
	
	//成员变量
	String name ;
	int age ;
	String gender ;
	int Id ;
	
	//成员方法
	public void study() {
		System.out.println("学生在学习Java.....") ;
	}
}

2)然后写一个学生类的测试类,那么如何创建对象呢?

      在Java中,创建对象:new 对象

                   类名    对象名 = new 类名();

public class StudentTest {

	public static void main(String[] args) {
		
		//创建一个学生对象
        //	格式:	类名 对象名 = new 类名() ;	
		Student s = new Student() ;
		//System.out.println(s);//org.westos.oop.Student@70dea4e  包名.类名@(地址值标记)16进制数据
		
		//给学生对象进行赋值
		//赋值的时候和之前写的这个类的类型要一致!
		s.name = "高圆圆" ;
		s.age = 27 ;
		s.gender = "女" ;
		s.Id = 007 ;
		System.out.println("学生的姓名是:"+s.name+",年龄是:"+s.age+",性别是:"+s.gender+",学号是:"+s.Id);
		
		//调用Student类中的成员方法
		//对象名.成员方法名() ;
		s.study(); 
		
	}
}

二.成员变量和局部变量的区别

1)在类中位置不同
     成员变量:类中,方法外
     局部变量:方法声明上,或者再方法定义中
2)在内存中的位置不同:
     成员变量:堆内存
     局部变量:栈内存
3)生命周期不同:
     成员变量:成员变量是随着类的加载而加载,随着类的消失而消失
     局部变量:随着方法的调用而存在,随着方法调用完毕而消失
4)初始化值不同
     成员变量:初始化由系统默认初始化,
           对于成员变量,可以不给初始化值,由系统给,然后显示初始化;(int类型:默认值0;String类型:默认值null)

     局部变量:定义一个局部变量,必须进行初始化,如果不初始化,无法使用(在使用之前进行初始化)

三.匿名对象

       就是创建对象的时候,没有名字的对象(开发中经常使用).

       比如:有一个Student类

                  创建一个匿名对象new Student();

                  可以用匿名对象调这个类的成员变量和成员方法,如:new Student().name="胡一天";

    但是,匿名对象在实际开发中,只用使用一次,不要使用多次  (可能会造成一个内存溢出的现象);

         比如:new Student() ; 
                new Student () ;//错误,一直给堆内存开辟空间 

四.形式参数问题

    (1)如果是基本数据类型,形式参的改变对实际参数没有影响(字符串类型String是一个特殊的类型,它的形式参数的改变会直接影响实际参数)
     (2)Java研究引用类型:形式参数的改变会直接影响实际参数

举例:

class Student{
	public void show() {
		System.out.println("好好学习,天天向上....");
	}
}

class StudentDemo{
	//method方法中形式参数是一个引用类型:需要的是学生类对象  Student s = new Student () ;
	public void method(Student s) {//形式参数现在引用类型  
		s.show(); 
	}
}

 

    需求:调用StudentDemo中的method方法:如何调用?

           1)创建StudentDemo类对象

StudentDemo sd = new StudentDemo() ;

          2)形式参数是Student类型,所以创建Student类的对象

Student s = new Student() ;

          3)调用StudentDemo中的method方法

<em>sd.method(s);</em>

五.封装和private关键字

  还是以上面学生类为例,

       给学生的年龄赋值了一个不合理的数据(s.age = -30 ;),而这种不合理的数据依然可以被输出出来,有问题!

解决方案:
       在Student类中提供一个针对年龄的判断的一个方法

//针对年龄进行一个判断
	public void ageTest(int age) {
		if(age <0 || age >120) {
			System.out.println("该年龄是一个不合理数据....");
		}
	}

 

       虽然提供了这一个方法,但是成员变量在测试类中永远被访问到,针对这种情况:Java提供了关键字:private:私有的

private:体现的也是一种封装思想

(1)封装:

        标准类的写法,将成员变量全部私有化,被private修饰的成员变量只能在本类中访问,可以通过公共的访问方法去访问成员变量

(2)private的用法:
     1)被private修饰的只能在本类访问
     2)可以通过公共的访问public 去间接访问

class Demo{
	private int num = 100 ;
	
	//成员方法 :公共访问方法
	public void method()	{
		int num = 200 ; //局部变量
		System.out.println(num);
	}
}
//测试类
public class PrivateDemo {
	
	public static void main(String[] args) {
		//创建一个Demo类的对象
		Demo d = new Demo() ;
        //System.out.println(d.num);//外界不能访问
		d.method(); 
	}
}

        注:当前成员变量和局部变量名称一致的情况,遵循就近原则

六.构造方法以及创建对象的过程

(1)作用:就是给对象进行进行初始化

(2)构造方法:1)方法名和类名相同     2)构造方法,连void都没有

(3)构造方法的注意事项:

     1)之前没有写无参构造,系统会默认提供无参构造

     2)如果我们无参构造或者有参构造,系统不会在提供无参构造;定义一个类的时候,建议永远给出无参构造!

     3)构造方法是可以重载的!

  面试题:有一个学生类:Student  里面有一些属性,在测试类中创建学生类对象,经历了哪些过程?

Student s = new Student() ;

(1)通过测试类里面的main主程序进行加载,加载Student类(Student.class)

(2)Student s 先在栈内存开辟内存空间,创建一个学生对象,需要在堆内存申请堆内存空间

(3)通过无参构造方法给学生类的对象进行默认初始化

(4)通过给成员变量赋值的形式,给对象进行显示初始化

(5)显示初始化完毕,整个对象创建完毕之后,给对象进行内存空间地址值的分配

(6)通过地址值找对应的对象

 

七.this关键字以及一个标准类的写法

this:代表是当前类对象,或者是(当前类对象的引用),解决局部隐藏了成员变量

八.static关键字

(1)多个对象对同一个变量进行共享,这个时候Java提供了一个关键字---static:  静态的(共享的)
         在方法区中:开辟一个静态区域: 都是静态标记

(2)关于static关键字:
    1)静态随着类的加载而加载
    2)static优先于对象存在
        回想:main  public static void main(..){...}
    3)static共享数据,可以被多个对象进行共享
        举例: 饮水机(staticd的:共享的)
                水杯(不能共享的...)
    4)如果数据被静态修饰的,它可以被类名直接调用
       被静态修饰的方法: 类名.方法名()
       被静态修饰的变量: 类名.变量名;

(3) static用法:

       一个类中可有静态变量,也可以有非静态

       可以有静态成员方法,也可以非静态的成员方法

       静态的方法只能访问静态变量,或者是静态的方法

       非静态的方法,既可以访问静态变量也可以非静态的变量...

  简单记:静态只能访问静态!