黑马程序员_面向对象01

最新推荐文章于 2021-02-17 02:59:01 发布
最新推荐文章于 2021-02-17 02:59:01 发布
阅读量378 收藏
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u013940467/article/details/21413905

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------
面向对象

面向对象的特点：

    是一种符合人们思考习惯的思想

    可以将复杂的事情简单话

    将程序员从执行者转换成了指挥者

    完成需求时：

        先去找具有所需功能的对象来调用

        如果该对象不存在，那么创建一个具有所需功能的对象

        这样简化开发并提高复用

开发的过程：其实就是不断的创建对象，使用对象，指挥对象的做事情

设计的过程：其实就是在管理和维护对象之间的关系

类与对象的关系

    使用计算机语言就是在不断的描述现实生活中的事物

    java中描述事物通过类的方式体现，类是具体事物的抽象，概念上的定义

    对象既是该类事物实实在在存在的个体

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

    成员变量：

    成员变量定义在类中，在整个类中都可以被访问

    成员变量随着对象的建立而建立，存在于对象所在的堆内存中

    成员变量有默认的初始化值

    局部变量：

    局部变量之定义在局部范围内，如函数内，语句内等

    局部变量存在于栈内存中

    作用的范围结束，变量空间会自动释放

    局部变量没有默认的初始化值

匿名对象

    匿名对象是对象的简化形式

    匿名对象的两种使用形式：1，当对对象的方法仅进行一次调用时。2，匿名对象可以作为实际参数进行传递

封装(Encapsulation)

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式

好处：

    将变化隔离

    便于使用

    提高了复用性

    提高安全性

封装原则：

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

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

面向对象的示例：

//需求：描述汽车（颜色，轮胎数）。描述事物其实就是描述事物的属性和行为

//属性对应类中的变量，行为对应类中的函数（方法）
//其实定义类，就是描述事物，就是在定义属性和行为。属性和行为共同称为类中的成员（成员变量和成员方法）

class Car
{
	String color="red";
	int num= 4;
	void run();
	{
		System.out.println(color+"\t"+num);
	}
	
	
}

class Cardemo
{
	public static void main(String[] args)
	{
		Car c=new Car(); //类类型变量指向对象
			
		//需求：将已有车的颜色改成蓝色
		c.color="blue";
		c.run();
		//Car q= new Car();
		//show(q);
		//show(new Car());
	}
	//匿名对象的使用方式之一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样比较简化。
	//			如果对一个对象进行多个成员调用，必须给这个对象起个名字
	//匿名对象使用方式之二：可以将匿名对象作为实际参数进行传递
	/*
	new char().num=5;
	new char().color="blue";
	new char().run();

	Car c= new Car();
	c.num=4;
	c.run();
	new Car().run();
	*/
	//需求：汽车修配厂，将来的车改装成黑色，三个轮胎
	
	/*
	public static void show(Car c)	
	{
		c.num=3;
		c.color="black";
		c.run();
	}
	*/
	
	
}


 

//对象一建立就会调用与之对应的构造函数
//构造函数的作用：可以给对象进行初始化
//当一个类中没有定义构造函数时，那么系统会给该类加一个空参数的构造函数
//Person() {}
//当在类中自定义了构造函数时，默认的构造函数没有了


//什么时候定义构造函数呢？
//当分析事物时，该事物具备一些特性或者行为，那么将这些内容定义构造函数中
//需要未知内容参与运算，定义参数



class Pesron
{
	private String name;
	private int age;
	/*
	构造代码块：
	给对象进行初始化
	对象一建立就运行，而且优先于构造函数执行
	构造代码块是给所有的对象进行统一初始化，而构造函数是给对应的对象初始化
	*/
	{
		System.out.println("Person code run");
		//定义不同对象的共性的初始化内容
		cry();
	}

	//this: 就代表本类的对象，到底代表哪一个呢？
	// this代表它所在函数所属的引用
	//简单说：哪个对象在调用this所在的函数，this就代表哪个对象
	Person()
	{
		System.out.println("A: name="+name+"\t"+" age="+age);
		cry();
	}
	Person( String name)
	{
		this.name=name;
		System.out.println("B: name="+name+"\t"+" age="+age);
		cry();
	}
	Person( String name, int age)
	{
		//this.name=name;
		this(name);
		this.age=age;
		System.out.println("C: name="+name+"\t"+"age="+age);
		cry();
	}
	Person(int age)
	{
		this.age=age;
	}
	public void cry()
	{
		System.out.println("cry...........");
	}
	public String setName(String n);
	{
		name=n;
	}
	public String getName()
	{
		return name;
	}
	//需求：给人定义一个比较年龄是否相同的功能，也就是是否是同龄人
	//this 的应用： 当定义类中功能时，该函数内部要调用该函数的对象时，这时用this来表示这个对象
	//但凡本类功能内部使用本类对象，都用this表示
	public boolean compare(Person p)
	{
		return this.age==p.age;		
	}
	//this()  用于构造函数之间调用,只能定义在构造函数的第一行。因为初始化要先执行
	//一般函数不能调用构造函数
	
}

class PersonDemo
{
	public static void main(String[] args)
	{
		//Person p1= new Person();
		//Person p2=new Person("zhangsan");
		//Person p3=new Person("lisi",10);
		Person p4= new Person(20);
		Person p5= new Person(25);
		boolaen b=p4.compare(p5);
	}
}


 

/*
静态：static 
用法：是一个修饰符,  用于修饰成员（成员变量，成员函数）
             当成员被static修饰后，就多了一种调用方式，除了可以被对象调用外，还可以被类名调用。类名.静态成员

static特点：
1，随着类的加载而加载
	也就是说静态会随着类的消失而消失，说明它的生命周期最长

2，被所有对象所共享
       明确一点：静态是先存在，对象是后存在的
	
3，优先于对象存在
4，可以直接被类名调用

实例变量和类变量的区别：
1，类变量随着类的加载而存在于方法区中
      实例变量随着对象的建立而寻在于堆内存中
2，生命周期:
      类变量生命周期最长，随着类的消失而消失
      实例变量的生命周期随着对象的消失而消失
3，主函数是静态的

静态的使用注意事项：
1，静态方法只能访问静态成员。
2，静态方法总不可以定义this，super关键字，以为静态优先于对象存在

静态有利有弊
利：对对象的共享数据进行单独的存储，节省内存，没有必要每个对象中都存储一份
	可以直接被类调用
弊：生命周期过长，访问出现局限性（静态虽好，只能访问非静态）
*/

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

class StaticDemo
{
	public static void main(String[] args)
	{
		Person p=new Person();
		p.name="zhangsan";
		p.show();
		System.out.println(Person.country);
	}
}


 

/*
public static void main(String[] args)
主函数是一个特殊的函数，作为程序的入口，可以被jvm调用
public：代表该函数的访问权限是最大的
static：代表着随着类的加载已经存在
void：对主函数没有具体的返回值
main：不是关键字，但是可以被jvm所识别
（String[] args)：函数的参数，参数类型是一个数组，该数组中的元素是字符串，字符串类型的数组

主函数是固定格式的：jvm只识别 public static void main(String[] args)。
*/

class MainDemo
{
	public static void main(String[] args)
	{
		System.out.println(args);
	}
}


 

/*
什么时候使用静态？

要从两个方面下手：
因为静态修饰的内容有成员变量和成员函数
什么时候定义静态的变量？	当对象中出现共享数据时,该数据被静态修饰

什么时候定义静态函数？

当功能内部没有访问到非静态数据（对象的特有数据）
那么该功能可以定义成静态

/*
静态的应用：	每一个应用程序中都有共性的功能
		可以将这些功能进行抽取，独立封装，以便复用
*/
/*
public class ArrayTool
{	
	private ArrayTool() {}
	public static int getMax()
	{
		int max=0;
		for( int x=1; x<arr.length; x++)
		{
			if(arr[x]>arr[max])
				max=x;
		}
		return arr[x];
	}
	public static int getMin()
	{
		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])
				{
					awap(arr,x,y);
				}
			}
		}
	}
	public static void bubblesort(int [] arr)
	{
		for( int x=arr.length-1; x>0; x--)
		{
			for(int y=0; y<x; y++)
			{
				if(arr[y]>arr[y+1])
				{
					swap(arr,y,y+1);
				}
			}
		}
	}
	private static void swap( in [] arr, int x, int y)
	{
		int temp=arr[x];
		arr[x]=arr[y];
		arr[y]=temp;
	}
	public static void printArray(int [] arr)
	{
		System.out.prin("[");
		for(int x=0; x<arr.length; x++)
		{
			if(x!=arr.length-1)
				System.out.print(arr[x]+",");
			else
				System.out.println(arr[x]+"]");
		}
	}
	
}
*/

/*
虽然可以通过建立Arraytool的对象使用这些工具方法，对数组进行操作
发现了问题：
1，对象时用来封装数据的，可是Arraytool对象并未封装特有数据
2，操作数组的每一个方法都没有用到ArrayTool对象中的特有数据

这时就考虑，为了让程序更严谨，是不需要对象的
可以将ArrayTool中的方法定义为static的，直接通过类名调用即可

将方法都静态后，可以方便使用，但是该类还是可以被其他程序建立对象的
为了更为严谨，强制让该类不能建立对象
可以通过将构造函数私有化完成
*/


 

 

java说明书

//java的说明书通过文档注释来完成

/**
这是一个可以对数组进行操作的工具类，该类中提供了获取最值，排序等功能
@author 张三
@version V1.1
*/


public class ArrayTool
{	
	/**
	空参数构造函数
	*/
	private ArrayTool();

	/**
	获取一个整型数组中的最大值
	@param arr 接受一个int 型数组
	@return 返回一个数组中的最大值
	*/
	public static int getMax(int [] arr)
	{
		int max=0;
		for( int x=1; x<arr.length; x++)
		{
			if(arr[x]>arr[max])
				max=x;
		}
		return arr[x];
	}
	/**
	获取一个整型数组中的最小值
	@param arr 接受一个int 型数组
	@return 返回一个数组中的最小值
	*/
	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];
	}
	/**
	给int 数组进行选择排序
	@param arr 接收一个int 数组
	*/
	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])
				{
					awap(arr,x,y);
				}
			}
		}
	}
	/**
	给int 数组进行冒泡排序
	@param arr 接收一个int 型数组
	*/
	public static void bubblesort(int [] arr)
	{
		for( int x=arr.length-1; x>0; x--)
		{
			for(int y=0; y<x; y++)
			{
				if(arr[y]>arr[y+1])
				{
					swap(arr,y,y+1);
				}
			}
		}
	}
	/**
	给数组中的值进行位置互换
	@param arr 接收一个int型数组
	@param x 要置换的位置
	@param y 要置换的位置
	*/
	public static void swap( int [] arr, int x, int y)
	{
		int temp=arr[x];
		arr[x]=arr[y];
		arr[y]=temp;
	}
	/**
	用于打印数组中的元素。打印形式是[element 1,element 2,...]
	*/
	public static void printArray(int [] arr)
	{
		System.out.prin("[");
		for(int x=0; x<arr.length; x++)
		{
			if(x!=arr.length-1)
				System.out.print(arr[x]+",");
			else
				System.out.println(arr[x]+"]");
		}
	}
}
/*
	一个类中默认会有一个空参数的构造函数
	这个默认的构造函数的权限和所属的类一致
	如果类被public修饰，那么默认的构造函数也带public修饰符
	
	默认构造函数的权限是随着类的变化而变化的
*/


单例设计模式：

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

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

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


对于事物该怎么描述，还怎么描述
当需要该事物的对象保证在内存中唯一时，就将以上的三步加上即可
*/


class Single
{	
	private int num;
	public void setNum(int num)
	{
		this.num=num;
	}
	public int getNum()
	{
		return num;
	}
	private Single() {}
	private static Single s=new Single();
	public static Single getInstance()
	{
		return s;
	}
}


class SingleDemo
{
	Single s1=Single.getInstance();
	Single s2=Single.getInstance();
	s1.setNum(23);
	//Single s1= new Single();
	//Single s2= new Single();
	//s1.setNum(30);
	System.out.println(s2.getNum());
	
}


 

/*
这个是先初始化对象
称为：饿汉式
Single类，一进内存，就已经创建好了对象
*/


class Single
{
	private Single() {}
	private static Single s =new Single();
	public static Single getInstance()
	{
		return s;
	} 
}
*/
//对象是方法被调用时，才初始化，也叫做对象的延时加载。
//称为：懒汉式
//Single类进入内存，对象还没有存在，只有调用了getInstance时，才建立对象

//定义单例，建议使用饿汉式


class Single
{
	private Single() {}
	private Single s = null;
	public static Single getInstance()
	{	if(s==null)
		{
			Syschronise(Single.class)
			{
				if(s==null)
					s=new Single();
			}
		}
		return s;
	}
}

class


静态代码块

/*
静态代码块
格式：
static
{
	静态代码块中的执行语句
}
特点：随着类的加载而执行，只执行一次,并优先于主函数。
            用于给类进行初始化
*/
class StaticCode
{	
	static 
	{
		System.out.println("a");
	}
	public static void show()
	{
		System.out.println("show run");
	}
}
class StaticCodeDemo
{	
	static
	{
		System.out.println("b");
	}
	public static void main(String[] args)
	{	
		//new StaticCode();
		//new StaticCode();
		//System.out.println("over");
		StaticCode s = null ;
		s = new StaticCode();
		
		StaticCode.show();
	}
	static
	{
		//System.out.println("c");
	}
}


 

对象的初始化过程

Person p= new Person("zhangsan",20);

该句话做了什么事情？

1，因为new用到了Person.class，所以会找到Person.class文件并加载到内存中

2，执行该类中的static代码块，如果有的话，给Person.class进行初始化

3，在堆内存中开辟空间，分配内存地址

4，在堆内存中建立对象的特有属性，并进行默认初始化

5，对对象进行显示初始化

6，对对象进行构造代码块初始化

7，对对象进行构造函数初始化

8，将内存地址付给栈内存的p变量

 

 

 

 

 

 

 

也许依然
关注
java中boolean方法_java中boolean类型怎么用？
weixin_39929465的博客
02-13 1万+
boolean类型的用法是java中的布尔型【逻辑型】数据类型，在java中boolean值只能是true和false，而不能用0和1代替，并且一定要小写，代码为【var myBoolean = new Boolean()】。java中boolean类型的用法：boolean是java中的布尔型(逻辑型)数据类型，在java中boolean值只能是true和false，而不能用0和1代替，并且一定...
Java实验5继承和多态
不吐槽会死星人
07-02 3890
目的： 理解继承与多态的概念，熟练掌握使用方法   1、 设计一个数据类型判断类Polymorphism，使用重载、装箱等技术判断一个不带等号的Java表达式的结果的数据类型。 2、 设计一个链表结点类LinkNode，此类可以存放int、long、float、double、byte、short、String、StringBuffer类型的数据。用此类：a、随机产生100个整数（范围自定）
java bollean_java基本数据类型布尔类型boolean的使用（31）
weixin_36102776的博客
02-13 311
13.这是java的关于java基本数据类型布尔类型boolean的使用的源代码可以直接进行编译运行，希望大家能够从中获益良多。package number;public class Boolean1 {public static void main(String[] args) {// TODO 自动生成的方法存根//boolean类型的特点：//包含2个值为false和true//存储大小为一...
【Java语法基础】Java编译环境配置、基本语法、流程控制
Fanjufei的博客
04-17 849
1. 配置java编译环境 针对Windows64位： 链接：https://pan.baidu.com/s/1q7p6YbKSyxl4k90DEeBQVw提取码：fwmy （1）安装配置jdk 通过以下步骤配置PATH环境变量： （2）下载、安装IntelliJIDEA （3）建立java源代码输出“Hello World” pub...
【转载】J2SE知识点归纳笔记(六)---Java常用类
静静是小花的博客
05-04 570
注：本文转载自coder-pig 原文请戳：http://blog.youkuaiyun.com/coder_pig/article/details/23420907#comments java中的类当然很多很多，猪大哥这篇文章只是冰山一角，看看就行，关键是要用到的时候自己去细查那个类就可以了，努力吧，奋斗吧。 Java常用类: 前言:
黑马程序员_hibernate框架开发2016版讲义和笔记资料_day02
07-28
《黑马程序员_hibernate框架开发2016版讲义和笔记资料_day02》 本文将深入探讨2016年黑马程序员发布的Hibernate框架开发课程的第二天内容。Hibernate，一个强大的Java持久化框架，简化了数据库操作，为开发者提供了...
黑马程序员_hibernate框架开发2016版讲义和笔记资料_day1_day2_day3_day4
05-20
《Hibernate框架深度解析——基于黑马程序员2016版教学资料》 Hibernate，作为一个强大的对象关系映射（ORM）框架，极大地简化了Java开发者在数据库操作中的工作。它通过提供数据持久化的对象模型，使得开发者可以...
黑马程序员_(适合初学者入门的Java基础视频)
08-24
3. **面向对象编程**：深入讲解Java的核心特性——面向对象编程，包括类的定义、对象的创建与使用、封装、继承和多态等概念。 4. **数组和集合框架**：介绍数组的使用，以及ArrayList、LinkedList、HashSet、...
C++黑马程序员学习资料
最新发布
08-05
C++黑马程序员学习资料，附赠《InterviewGuide第四版By阿秀》、《LeetCode刷题手册》、《背包问题九讲》、《算法图解》pdf版本，三个基础课程文档手册及三个实验项目，由简到繁分别为《通讯录管理系统》、《职工管理...
黑马程序员_毕向东_Java基础视频教程第05天-01-面向对象(概述).avi
05-24
黑马程序员_毕向东_Java基础视频教程第05天-01-面向对象(概述).avi
Java实验1,2
不吐槽会死星人
03-30 2702
import java.util.Arrays; public class test { public static void main(String[] args) { //实验一 experimentOne(); //实验2 System.out.println("题目1: x^(1/2)=cos(x)解为： " + question0neAnswer());
java中的boolean_java中boolean的用法解析
热门推荐
weixin_33681937的博客
02-12 1万+
boolean 数据类型 boolean 变量存储为 8 位(1 个字节)的数值形式，但只能是 True 或是 False。本文引用地址：http://www.eepw.com.cn/article/201809/389052.htm当作为一个构造函数(带有运算符 new)调用时，Boolean() 将把它的参数转换成一个布尔值，并且返回一个包含该值的 Boolean 对象。如果作为一个函数(不带...
java运算符详解
qq_37529302的博客
02-28 349
java常用的基本运算符 public class TestOperator { /* * 一、算术运算符： * （1）算术运算符： * + - * / % ++ -- * （2）+的用法： * a.加法 * b.正号 * c.字符串连接符 * （3）/和%的区别：整数做除法操作的时候，/取的是商，%取的是余数 * （4）++ 和 --用法： * a.他们的作用
java随机布尔值_Java 布尔值(Boolean)
weixin_35997133的博客
02-17 3394
1、Java 布尔值通常，在编程中，将需要一个只能具有两个值之一的数据类型，表示逻辑判断条件的真假。为此，Java具有boolean数据类型，该数据类型可以是值true或false。2、boolean变量声明布尔类型使用boolean关键字声明，并且只能是true或false：例如：boolean isJavaFun = true;boolean isFishTasty = false;Syste...
java数据类型之boolean
u014744764的专栏
10-27 6865
前面我们已经学习了一些表示数字和字符的数据类型（java基础之数据类型篇），但是事物往往还有真假之分，比如在判断一件艺术品的时候常说：“这是真的”或“这是假的”。另外还有一些判断性的，比如地铁1号线的首发时间是早上5点吗？这些问题都需要经过判断。但答案只能有两个，要么“是”要么“否”。程序也是一样，有时也需要判断真假，这时就需要一种数据类型，专门用来表示真和假。“boolean”又称布尔，所以我们
bool返回值的函数如果不return会咋样
linxuping的专栏
05-30 4271
bool try_ret_bool(int flag) {     if (flag == 0) return true; } 测试程序： try_ret_bool(0) 毫无疑问返回true，控制之内 try_ret_bool(1) 返回？ 接下去各种试验： int val = is_existed(1) 发现返回的是22,究竟是啥原因呢？看看汇编吧，    0x0804964
ElastiSearch 2.1使用java api获取TransportClient连接ES集群、插入文档、进行搜索，以及在线/离线插件安装的方法...
diaojubian0934的博客
02-16 569
2.0之后ES的java api用法有了很大变化。在此记录一些。 java应用程序连接ES集群，笔者使用的是TransportClient，获取TransportClient的代码设计为单例模式（见getClient方法）。同时包含了设置自动提交文档的代码。注释比较详细，不再赘述。 下方另有提交文档、提交搜索请求的代码。 1、连接ES集群代码如下： 1 package ...
关于java中boolean的使用
liu309635354的博客
05-22 7339
刚开始学Java中，我总是搞不清楚关于Boolean的用法， boolean类型是指 真和假 的类型.只有两种值:true和false，我曾经做一个题目 例如：boolean[] bool = new boolean[n];这句是指创建一个布尔型的数据(boolean默认值为false).所以一般Java中boolean中默认值是false， 由于变量bool是布尔数组,所以数组中的某...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值