黑马程序员 java学习笔记——面向对象1：封装

最新推荐文章于 2024-03-14 20:49:58 发布

PleaseCallMeWisely

最新推荐文章于 2024-03-14 20:49:58 发布

阅读量456

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/PleaseCallMeWisely/article/details/38325353

版权

java基础专栏收录该内容

27 篇文章 1 订阅

订阅专栏

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------

面向对象的概述

记得某年春晚上，宋丹丹讲了一个笑话，把大象放到冰箱里需要几步。第一步打开冰箱门，第二步
把大象放入冰箱，第三步关上冰箱门。这就是一个面向过程的思想，C语言就是这样的思想。而
java则不同，它是面向对象的。

还是这个例子，java将冰箱定义为一个类，放大象是一个方法。除了放大象，它还能放长颈鹿，放袋鼠……

归纳一下，到底什么是面向对象。
1、面向对象是相对于面向过程而言，两者都是一种思想。不同的是，面向对象强调的是对象，它将程序员变成指挥者，而不是像面向过程一样，将程序员变成执行者。
2、面向对象更加符合人们的思考习惯，将许多复杂的事情简单化，这种从执行者到指挥者的转变，其实就是面向对象最大的特点。
3、在实际开发当众，java是以对象为核心，先明确对象，再实现功能，或者可以使用已经有的对象，简单概括就是找对象，使用对象，维护对象之间的关系。
4、最后，不得不提的是面向对象的三大特征：封装、继承和多态。

下面用将大象放进冰箱里的方法，来显示面向对象与面向过程之间的区别。

类与对象

概念：类就是对现实生活中事物的描述，而对象就是这类事物，实实在在存在的个体。类中封装了该类事物的属性和行为。
有个通俗的比喻，社会中有各色的人，人就是一个类，而每一个活生生的个体就是对象，他们虽然都是人，但却有着各自不同的属性和行为，姓名、年龄、性别等等是他们的属性，而从事的职业就是他们的行为。

类与对象的关系：类是对象不断向上抽取的结果，而对象是类实例化的实实在在的个体存在。

类的定义形式
权限修饰符 class 类名{
成员变量……
构造方法……
构造方法……
}

类中的成员包括：成员变量，成员方法，静态代码块，构造代码块，构造方法等等。其中构造方法用于构造该类的实例对象，成员变量用于描述成员的属性，方法则用于定义事物的行为或动作。

创建对象：
类名对象名=new 类名();
代码如下：

class Car{
	String color="红色";
	//描述轮胎数
	int num=4;
	
	//运行行为
	void run(){
		System.out.println(color+".."+num);
	}
}
class Demo{
	public static void main(String[] args){
		//生产汽车，在java中通过new操作符来完成。
		//其实就是在堆内存中产生一个实体
		Car c=new Car();//c就是一个类类型变量，记住，类类型变量指向对象。
		
		//需求：将已有的车的颜色改成蓝色，指挥该对象动作。
		//在java中，指挥方式是：对象.对象成员
		c.color="blue";
		c.run();
		
		Car c1=new Car();
		
		//将c1的轮胎设置为6个
		c1.num=6;
		c1.run();
	}
}
//blue..4
//红色..6

成员变量与局部变量

作用范围：成员变量作用于整个类中，而局部变量作用于方法中或语句中
内存位置：成员变量在堆内存中，因为对象的存在，才在内存中存在；局部变量存在与栈内存中。

匿名对象的应用

匿名对象使用方式：
1、当对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。
2、可以将匿名对象作为实际参数进行传递。

示例代码如下：

class Car{
	String color="红色";
	void run(){
		System.out.println(color+"色汽车开动啦！");
	}
}
class Demo{
	public static void main(String[] args){
		new Car().run();
		show(new Car());
	}
	public static void show(Car c){
		c.color="black";
		c.run();
	}
}
//红色色汽车开动啦！
//black色汽车开动啦！

封装概述

概念：封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：
1、将变化隔离
2、便于使用
3、提高重用性
4、提高安全性
封装原则：
1、将不需要对外提供的内容都隐藏起来
2、把属性都隐藏，提供公共方法对其访问。

封装private

private：私有，它是一个权限修饰符，用于修饰类中的成员，包括成员变量和成员方法。被private修饰后，成员只在本类中有效。
示例代码如下：
class Person{
	private int age;
	public void setAge(int age){
		this.age=age;
	}
	public int getAge(){
		return age;
	}
	void speak(){
		System.out.println("age="+age);
	}
}
class Demo{
	public static void main(String[] args){
		Person p=new Person();
		p.setAge(20);
		p.speak();
	}
}
//20
上面的例子中，将age私有化以后，类以外即使建立了对象也不能直接访问。但是人应该有年龄，就需要在Person类中提供对外访问的age的方式。
注意：似有仅仅是封装的一种表现方式。
有一点不得不提，这也是将某些属性私有化的原因之一。
比如说上面的例子中，如果不私有化age，那么可能会赋给age一个负数，显然这是不符合现实的，人不可能有负的年龄。如果私有化之后，就能在setAge方法中设置判断条件，从而避免这种情况的发生。

构造函数

构造函数的特点：
1、函数名与类名相同。
2、不用定义返回值类型。
3、不可以写return语句。

作用：给对象进行初始化。

注意：
1、默认构造函数的特点：
当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。当在类中自定义了构造函数后，默认的构造函数就没有了。
2、多个构造函数是以重载的形式存在的。

构造函数与一般函数的区别：
1、构造函数是在对象一建立就运行，给对象进行初始化。而一般方法是对象调用才执行，调用对象自己所具备的功能。
2、一个对象的建立，构造函数只运行一次，而一般函数可以被该对象调用多次。

什么时候定义构造函数呢？
当分析事物时，该事物具备一些特性或者行为，那么将这些内容定义在构造函数中，最为合适。

示例代码如下：

class Person{
	private String name;
	private int age;
	Person(){
		System.out.println("A:name="+name+",,age="+age);
		cry();
	}
	Person(String name){
		this.name=name;
		System.out.println("A:name="+name+",,age="+age);
		cry();
	}
	Person(String name,int age){
		this.name=name;
		this.age=age;
		System.out.println("A:name="+name+",,age="+age);
		cry();
	}
	public void cry(){
		System.out.println("cry..........");
	}
	public void setAge(int age){
		this.age=age;
	}
	public int getAge(){
		return age;
	}
	void speak(){
		System.out.println("age="+age);
	}
}
class Demo{
	public static void main(String[] args){
		Person p1=new Person();
		Person p2=new Person("zhaodahai");
		Person p3=new Person("sundesheng",21);
	}
}
//A:name=null,,age=0
//cry..........
//A:name=zhaodahai,,age=0
//cry..........
//A:name=sundesheng,,age=21
//cry..........

上面的例子中，由于人一剩下就会哭，可以将哭这个行为定义在构造函数中，名字年龄等也是如此。

构造代码块

作用：给对象进行初始化
特点：对象一建立就运行，而且优先于构造函数执行。
和构造函数的区别是，构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化。另外一点，构造代码块中定义的是不同对象共性的初始化内容。

比如上面的例子中，每一个人降生时都会哭，所以它就可以直接提取到构造代码块中，如下：

class Person{
	private String name;
	private int age;
	{
		cry();
	}
	Person(){
		System.out.println("A:name="+name+",,age="+age);
	}
	Person(String name){
		this.name=name;
		System.out.println("A:name="+name+",,age="+age);
	}
	Person(String name,int age){
		this.name=name;
		this.age=age;
		System.out.println("A:name="+name+",,age="+age);
	}
	public void cry(){
		System.out.println("cry..........");
	}
	public void setAge(int age){
		this.age=age;
	}
	public int getAge(){
		return age;
	}
	void speak(){
		System.out.println("age="+age);
	}
}
class Demo{
	public static void main(String[] args){
		Person p1=new Person();
		Person p2=new Person("zhaodahai");
		Person p3=new Person("sundesheng",21);
	}
}
//cry..........
//A:name=null,,age=0
//cry..........
//A:name=zhaodahai,,age=0
//cry..........
//A:name=sundesheng,,age=21

this关键字

this：代表本类当前对象的引用
使用情景：
1、当在函数内需要用到调用该函数的对象时，就用this
2、当成员变量和局部变量重名，可以用关键字提上来区分
简单一句话，哪个对象调用了this所在的函数，this就代表哪个对象。

示例代码如下：

class Person{
	private int age;
	Person(int age){
		this.age=age;
	}
	public void setAge(int age){
		this.age=age;
	}
	public int getAge(){
		return age;
	}
	//给人定义一个用于比较年龄是否相同的功能，也就是是否是同龄人。
	public boolean compare(Person p){
		return this.age==p.age;
	}
}
class Demo{
	public static void main(String[] args){
		Person p1=new Person(20);
		Person p2=new Person(25);
		boolean b=p1.compare(p2);
		System.out.println(b);
	}
}
//false
上面的代码中，p1调用了compare方法，那么它就是this。
this语句：用于构造函数之间进行互相调用。
this语句只能定义在构造函数的第一行，因为初始化要先执行。
示例代码如下：

class Person{
	private String name;
	Person(){
		System.out.println("cry中，切勿打扰……");
	}
	Person(String name){
		this();
		this.name=name;
	}
}
class Demo{
	public static void main(String[] args){
		Person p1=new Person("wangdachui");
	}
}
//cry中，切勿打扰……

static关键字

static用于修饰成员，即成员变量和成员方法。

被修饰后的成员具备以下特点：
1、随着类的加载而加载。也就是说，静态会随着类的消失而消失，说明它的生命周期最长。
2、优先于对对象存在。明确一点，静态先存在，对象后存在。
3、被所有对象所共享
4、可以直接被类名调用，类名.静态成员

使用注意：
1、静态方法只能访问静态成员
2、静态方法中不可以写this，super关键字
3、主函数是静态的

实例变量与类变量的区别：
1、存放位置

类变量随着类的加载而存在于方法区中

实例变量随着对象的建立而存在于堆内存中

2、生命周期

类变量生命周期最长，随着类的消失而消失。

实例变量生命周期随着对象的消失而消失。

静态有利有弊
利：
1、对对象的共享数据进行单独空间的存储，节省空间，没有必要每一个对象中都存储一份
2、可以直接被类名调用。
弊：
1、生命周期太长
2、访问出现局限性

示例代码如下：

class Person{
	String name;//成员变量，实例变量
	static String country="CN";//静态的成员变量，类变量
	public void show(){
		System.out.println(name+":::"+country);
	}
}
class Demo{
	public static void main(String[] args){
		System.out.println(Person.country);
		
	}
}
//CN

public static void main(String[] args)的解读：

主函数：是一个特殊的函数，作为程序的入口，可以被jvm调用。

public：代表该函数访问权限是最大的

static：代表主函数随着类的加载就已经存在了。

void：主函数没有具体返回值

main:不是关键字，丹师是一个特殊的单词，可以被jvm识别。

String[] args：函数的参数，参数类型是一个数组，该数组中的元素是字符串，字符串类型的数

组。args=arguments(参数)

主函数是固定格式的，能被jvm识别。

main函数的调用示例

class MainDemo{
	public static void main(String[] args){
		String[] arr={"aaa","bbb","ccc","ddd","eee"};
		Demo.main(arr);
	}
}
class Demo{
	public static void main(String[] args){
		for(int i=0;i<args.length;i++){
			System.out.println(args[i]);
		}
	}
}
//aaa
//bbb
//ccc
//ddd
//eee

什么时候定义静态变量（类变量）呢？
当对象中出现共享数据（不是共享属性）时，该数据被静态所修饰。对象中的特有数据要定义成非静态，存在于堆内存中。
什么时候定义静态函数呢？
当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以定义成静态的。

静态的应用——工具类

示例代码如下：

public class ArrayTool{
	private ArrayTool(){}
	public static int getMax(int[] arr){
		int max = arr[0];
		for(int x=1; x<arr.length; x++){
			if(arr[x]>max)
				max = arr[x];
		}
		return max;
	}
	public static int getMin(int[] arr){
		int min = 0;
		for(int x=1; x<arr.length; x++){
			if(arr[x]<arr[min])
				min = x;
		}
		return arr[min];
	}
	public static void selectSort(int[] arr){
		for (int x=0; x<arr.length-1 ; x++ ){
			for(int y=x+1; y<arr.length; y++){
				if(arr[x]>arr[y])
					swap(arr,x,y);
			}
		}
	}
	public static void bubbleSort(int[] arr){
		for (int x=0; x<arr.length-1 ; x++ ){
			for(int y=0; y<arr.length-x-1; y++){
				if(arr[y]>arr[y+1])
					swap(arr,y,y+1);
			}
		}
	}
	private  static void swap(int[] arr,int a,int b){
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}
	public static void printArray(int[] arr){
		System.out.print("[");
		for(int x=0; x<arr.length; x++){
			if(x!=arr.length-1)
				System.out.print(arr[x]+", ");
			else
				System.out.println(arr[x]+"]");
		}
	}
}

静态代码块、构造代码块与构造函数

这三者都能进行初始化，运行优先级由高到低是：静态代码块，构造代码块，构造函数。
静态代码块，随着类的加载而运行，只运行一次。
构造代码块，随着对象的建立而运行，优先于构造方法。每次new对象都会运行一次。
构造函数，随着对象的建立而运行。
静态代码块，给类进行初始化。
构造代码块，给对象进行初始化。
构造方法，给对应对象进行初始化

示例代码如下：

class Person{
    private String name;
    {
            System.out.println("我是构造代码块");
    }
    Person(){
            System.out.println("我是无参数构造函数");
    }
    Person(String name){
            System.out.println("我是有参构造函数");
    }
    static{
            System.out.println("我是静态代码块");
    }
    public static void show(){
            System.out.println("我是静态方法");
    }
}

public class Sunday{
    public static void main(String[] args) {

            Person p1=new Person();   
            Person p2=new Person("wang");
    }
}
//我是静态代码块
//我是构造代码块
//我是无参数构造函数
//我是构造代码块
//我是有参构造函数

对象的初始化过程

示例代码如下：

class Person{
        private String name;
        private int age;
        private static String country="cn";
        Person(String name,int age){
                this.name=name;
                this.age=age;
        }
}
public class Sunday{
        public static void main(String[] args){
                Person p=new Person("wamgda",20);
        }
}
Person p=new Person("wangda",20)
该句代码的初始化过程。
1、在栈内存中创建关于Person的引用p
2、因为new用到了Person.class虚拟机加载Person.class进内存
3、执行该类中的静态代码块，如果有的话，给Person类进行初始化
4、在堆内存中开辟空间，分配内存地址
5、在堆内存中建立对象的特有属性，并进行默认初始化。
6、对对象进行显式初始化
7、对对象进行构造代码块初始化
8、对对象进行对应构造方法的初始化
9、将内存地址赋给栈内存中的p。

单例设计模式

设计模式：解决某一类问题最行之有效的方法。
java中有23种设计模式
单例设计模式：解决一个类在内存只存在一个对象。

如何保证对象唯一？
1、为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象。
2、还为了让其他程序可以访问到该类对象，只好在本来中，自定义一个对象。
3、为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

这三步怎么用代码体现？
1、将构造方法私有化。
2、在类中创建一个本类对象
3、提供一个方法可以获取到该类对象。

饿汉式单例设计模式：

//将构造方法私有化，避免new对象
private Single(){}
//类中创建一个本类对象，并设置为似有
private static final Single s=new Single();
//构造一个对外提供获取本来对象的方法。
public static Single getInstance(){
	return s;
}

懒汉式单例设计模式：

对象是方法被调用时才初始化，也叫对象的延时加载。
由于该方法存在线程隐患，所以用加锁并双重判断的方式来优化。
private static Single s=null;
private Single(){}
public static Single getInstance(){
	if(s==null)
		synchronized(Single.class){
			if(s==null)
				return s=new Single();
		}
	return s;
}
---------------------- ASP.Net+Android+IO开发S 、 .Net培训、期待与您交流！ ----------------------