关闭

黑马程序员——Java基础——面向对象

标签: 黑马程序员java
127人阅读 评论(0) 收藏 举报
分类:

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------


面向对象概念

面向对象是相对面向过程而言,面向对象和面向过程都是一种思想。


面向过程:
强调的是功能行为。代表语言:C语言。

面向对象:

将功能封装进对象,强调具备了功能的对象。代表语言:Java、C++、C#。


例子:把大象装进冰箱
1.冰箱打开。
2.冰箱存储。

3.冰箱关闭。


可以看到,所有的操作都是以"冰箱"为主体,而不是功能行为。也就是说冰箱自己已经具备"打开"、"存储"、
"关上"的行为功能,我们只需要让冰箱执行它具备的功能就可以了。这就是一种面向对象的以执行功能的对象为

主体的思想体现。


面向对象的特点:

是一种符合人们思考习惯的思想,可以将复杂的事情简单化,将程序员从执行者转换成了指挥者。


完成需求时
1.先要去找具有所需功能的对象来用。
2.如果该对象不存在,那么创建一个具有所需功能的对象。

这样可以简化开发并提高复用。


面向对象开发,设计,特征
开发的过程:
其实就是不断的创建对象,使用对象,指挥对象做事情。
设计的过程:

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


面向对象的特征:
封装(encapsulation)
继承(inheritance)
多态(polymorphism)

类的定义
生活中描述事物无非就是描述事物的属性和行为。

如:人有身高,体重等属性,有说话,打球等行为。

Java中用类class来描述事物也是如此。
属性:对应类中的成员变量。
行为:对应类中的成员函数。
定义类其实在定义类中的成员(成员变量和成员函数)。


成员变量和局部变量的区别?
成员变量:
1.成员变量定义在类中,在整个类中都可以被访问。
2.成员变量随着对象的建立而建立,随着对象的消失而消失,存在于对象所在的堆内存中。
3.成员变量有默认初始化值。


局部变量:
1.局部变量只定义在局部范围内,如:函数内,语句内等,只在所属的区域有效。
2.局部变量存在于栈内存中,作用的范围结束,变量空间会自动释放。
3.局部变量没有默认初始化值。


创建对象,使用对象

/**
 * 描述小汽车
 * 分析:
 * 1.属性:轮胎数,颜色
 * 2.行为:运行.
 * 定义类契税就是在定义类中的成员.
 * 成员:成员变量<-->属性
 * 	        成员函数<-->行为
 */
//对Car这类事物经行描述
class Car{
	//成员变量
	String color = "red";
	int num = 4;
	//成员方法
	void show(){
		//临时变量
		int num = 10;
		//输出临时变量的值
		System.out.println("color="+color +"  num"+num);
	}
	public static void run(){
		System.out.println("function run is running");
	}
}
public class CarDemo {

	public static void main(String[] args) {
		//fun1();
		//匿名对象:对象的简化形式.
		//两种使用情况:1.当对对象方法仅进行一次调用时;
				  //2.匿名对象可以作为实际参数进行传递.
		new Car().run();
		show(new Car());
	}
	public static void show(Car c){
		c.num = 3;
		c.color = "black";
		System.out.println("function show is running!");
		System.out.println(c.num + "..." + c.color);
	}

	public static void fun1() {
		//通过new关键字,建立对象
		//c就是一个类类型的引用变量,指向了该类的对象
		Car c = new Car();
		c.show();
		//对对象的属性进行修改
		c.color = "black";
		//输出成员变量的默认值
		System.out.println(c.num);
		//通过对象.成员的形式来使用对象的功能
		c.show();
	}
}
运行结果:

function run is running
function show is running!
3...black

public class DuixiangDemo {
	int x = 3;
	public static void main(String[] args) {
		/*int x = 3;
		System.out.println("x=" + x);
		show(x);
		System.out.println("x=" + x);*/
		DuixiangDemo d = new DuixiangDemo();
		d.x = 9;
		System.out.println(d.x);
		show(d.x);
		System.out.println(d.x);
		
	}
	public static void show(int x){
		/**
		 * 基本数据类型参数传递
		 */
		//x = 4;
	}
	public static void show(DuixiangDemo d){
		d.x = 4;
	}
}
运行结果:

9

9


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


好处:
1.将变化隔离。
2.便于使用。
3.提高重用性。
4.提高安全性。


封装原则:
1.将不需要对外提供的内容都隐藏起来。
2.把属性都隐藏,提供公共方法对其访问。如,getXXX,setXXX。

package cn.fuxi.zhabaotan;
/**
 * 人:
 * 属性:年龄
 * 行为:说话
 */
class Person{
	//private:私有,是一个权限修饰符,用于修饰
	//不希望别人直接访问赋值,需要通过私有化把属性进行隐藏
	private int age ;
	//通过提供set get 公共方法对其访问
	public void setAge(int a){
		if(a > 0 && a < 130){
			this.age = a;
		}else{
			System.out.println("错误的数据,请输入1~129内的整数");
		}
	}
	public int getAge(){
		return age ;
	}
	void speak(){
		System.out.println("我的年龄是"+age);
	}
}
public class PersonDemo {
	public static void main(String[] args) {
		Person p = new Person();
		//通过其他方式访问
		p.setAge(10);
		p.speak();
		//赋值不合法,set方法就不允许成功赋值
		p.setAge(-20);
		System.out.println(p.getAge());
	}
//1.私有仅仅是封装的一种体现而已.
//2.private 关键字:是一个权限修饰符,用于修饰成员(成员变量和成员函数),被私有化的成员之在本类中有效.
//3.常用场景之一:将成员变量私有化,对外提供对应的set get方法对其经行访问,提高对数据访问的安全性.
}

输出结果:

我的年龄是10
错误的数据,请输入1~129内的整数
10

package cn.fuxi.zhabaotan;

public class HanSu {

	/**
	 * 根据考试成绩获取学生分数对应的等级。
		90~100 A
		80~89  B
		70~79  C
		60~69  D
		60以下     E
	 */
	public static void main(String[] args) {
		String s = score(57);
		System.out.println(s);

	}
	public static String score(int i){
		if(i>=90 && i<=100){
			return "A";
		}else if(i>=80 && i<90){
			return "B";
		}else if(i>=70 && i<80){
			return "C";
		}else if(i>=60 && i<70){
			return "D";
		}else if(i>=0 && i<60){
			return "E";
		}else {
			return "您的输入有误,请数值为输入0~100以内的整数:";
		}
	}

}
输出结果:

E

package cn.fuxi.zhabaotan2;
/**
 *通过this在构造函数中调用其他构造函数的时候
 *只能定义在构造函数的第一行
 *因为初始化动作要先执行,否则就会报错.
 */
class Cat{
	private String name;
	private int age;
	
	Cat(String name, int age){
		this.name =name;
		this.age = age;
	}
	public boolean compare(Cat c){
		return this.age == c.age; 
	}
}


public class ThisDemo2 {

	public static void main(String[] args) {
		Cat c1 = new Cat("咪咪",10);
		Cat c2 = new Cat("喵喵",10);
		System.out.println(c1.compare(c2));
	}
}
输出结果:

true

package cn.fuxi.zhabaotan2;
/**
 * static 关键字:用于修饰成员(成员变量和成员函数).
 * 特点:
 * 1.随着类的加载而加载.
 * 2.优先于对象存在.
 * 3.被所有对象所共享.
 * 4.可以被类名直接调用.
 */
class Cat2{
	//成员变量 = 实例变量
	String name;
	//静态变量 = 类变量
	//所有对象共享的属性用static修饰
	static String country = "China";
	public void show(){
		System.out.println(country +":"+name);
		//等效语句:System.out.println(Cat2.country + ":" + this.name);
	}	
}
public class StaticDemo {
	public static void main(String[] args) {
		//可以在创建对象之前使用
		Cat2.country = "中国";
		System.out.println(Cat2.country);
		Cat2 c1 = new Cat2();
		c1.country = "北京";
		method_1();
		System.out.println(Cat2.country);
		System.out.println(c1.country);
	}
	public static void method_1(){
		Cat2 c2 = new Cat2();
		c2.country = "江西";
	}
}
/*
 * 静态变量和成员变量的区别
 * 1.生命周期: 
 * 静态变量:随着类的加载存在,随着类消失,可以不创建对象用类名调用
 * 成员变量:随着对象的创建存在,在栈内存中,随着对象消失而消失
 * 2.调用方式不同
 * 静态变量:可以被对象调用,也可以被类名调用
 * 成员变量,只能被对象调用
 * 3.存储位置不同
 * 静态变量:存储在方法区(共享数据区)的静态区,所以也叫对象的共享数据
 * 成员变量:存储在堆内存的对象中.所以也叫对象的特有数据
 * 4.别名不同
 * 静态变量 = 类变量
 * 成员变量 = 实例变量
 * 
 * 注意事项:
 * 1.静态方法只能访问静态成员,如果访问非静态成员,就会报错!
 * 	原因:静态方法和变量存在的时候,对象还不存在,非今天变量也不纯在,肯定无法访问.
 * 	所以只有在创建对象之后,通过对象调用该变量,就不会有生命周期的问题
 * 2.静态方法中不可以写this,super关键字
 * 	原因:生命周期不同,this代表的就是调用方法的那个对象,但是有静态时还没有对象出现
 * 3.主函数是静态的
 * 		特点:1--格式固定的
 * 			2--被jvm所识别和调用
 * 
 */
 
输出结果:

中国
江西
江西

package cn.fuxi.zhabaotan2;
/**
 * 静态什么时候用?
 * 1.静态变量
 * 	当分析对象中具备的成员变量的值都是相同时,这时这个成员就可以被静态修饰.
 *  只要数据在对象中都是不同的,就是对象的特有数据,必须存储在对象中,是非静态的.
 *  如果是相同的数据,对象不需要做修改,只需要使用即可,不需要存储在对象中,定义成静态的.
 * 2.静态函数
 * 	函数是否用静态修饰,就参考一点,就是该函数功能是否需要访问到对象中的特有数据.
 * 	从源代码来看,该功能是否需=需要访问非静态的成员变量,如果需要,该功能就是非静态的.
 * 	如果不需要,就可以将该功能定义成静态的.当然,也可以定义成非静态,但是非静态需要被对象调用.
 *  如果没有访问特有数据的方法,该对象的创建时没有意义.
 */
class Demo2{
	int age;
	static int num = 9;
	
	public static void speak(){
		System.out.println(num);
	}
	public void show(){
		System.out.println(age);
	}
}
public class StaticDemo2 {
	public static void main(String[] args) {
		Demo2.speak();
		new Demo2().show();
	}
}
输出结果:

9
0

/**
 * 静态代码块
 * 随着类的加载而执行,而且只执行一次.
 * 作用:用于给类进行初始化.
 */
class StaticCode{
	static int num;
	static{
		num = 10;
	}
	static void show(){
		System.out.println(num);
	}
}
public class StaticDemo3 {
	public static void main(String[] args) {
		StaticCode.show();
	}
}

输出结果:

10




0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:2629次
    • 积分:221
    • 等级:
    • 排名:千里之外
    • 原创:20篇
    • 转载:0篇
    • 译文:0篇
    • 评论:0条
    文章分类
    文章存档