java基础之---面向对象

一、面向对象概述

1.面向过程:

分析解决问题的所需要的步骤，然后我们用函数来一步一步的调用实现。
例子1.把大象放进冰箱
1.打开冰箱
2.放入大象
3.关闭冰箱

例子2.做五子棋的游戏开发
1.开始
2.白子先走
3.绘制棋盘
4.判断输赢
5.黑子再走
6.绘制棋盘
7.判断输赢
……

2.面向对象

OOP（Object Oriented Programming）面向对象编程
面向对象的思想是抽取一类具有相同属性和行为的事物。
冰箱：打开门，关闭门
大象：走路
棋子：走，黑子和白子
棋盘：绘制
规则：判定输赢

java是属于面向对象语言
面向对象4大特性:抽象、封装、继承、多态
核心概念:万物皆对象

二、类

※我们把某些具有相同的属性和行为的事物抽象成一个类。
狗：
属性：颜色，眼睛，耳朵，重量，
行为：看家，睡觉，吃饭

车：
属性：颜色，四个轮子，方向盘
行为：跑，刹车
类就是一个概念

※对象是一个具体的实物，如：京巴。

※类其实类似于一个模板的东西，对象（实例）是根据这个模板所产生的样本。
类：概念，是抽象的
对象：具体的。
如果不理解的话我再举一个例子:例如有一个制作饼干的模具(类)，我们可以根据这个模具生产各式各样的饼干(对象)
语法：
class 类名{
属性
行为
}

※类名首字母要大写，如果类名是多个单词构成，那么每一个单词首字母都要大写 XxxYyyZzz

※属性（成员变量）的定义：
数据类型 属性名 [= 初始值];
中括号里面的可以没有，属性可以没有初始值。
※行为（方法）：
具体语法:
public [static] 返回值类型[void] 方法名（数据类型 参数名，…）{

[return 数据]

}

注意：类是一个概念，不能直接使用，必须使用这个类的具体的对象。根据类来创建对象
具体语法：
类名 变量名 = new 类名();

一个文件中可以写多个类。
如何给一个具体的对象来赋值属性呢：
对象的变量.属性名 = 具体值；
调用方法:
对象的变量.方法名([实际参数1],[实际参数2]…)

代码清单:

class Dog{
   /**
    * 属性
    */
   //姓名
   String name;
    //颜色  
   String color;
   //身高
   double height;
   //体重
   double weight;
    
    /**
    * 行为
    */ 
   public void protectHome(){
		System.out.println(name+"在看家");
   }
	
   public void sleep(){
		System.out.println(name+"在睡觉");
   }
}


class TestDog{
	public static void main(String[] args){
	//创建对象（实例）语法：类名 变量名 = new 类名();
	Dog dog = new Dog();
	//赋值的方法  变量名.类属性名  = 
	dog.name = "栗子黄";
	dog.color = "黄色";
	dog.height = 2.0;
	dog.weight = 13.0;
	                               //变量名.类属性名
	System.out.println("狗的颜色："+dog.color);
	System.out.println("狗的身高："+dog.height);
	System.out.println("狗的体重："+dog.weight);
	System.out.println("---------dog1的第一次打印----------------------");
	
	Dog dog1 = new Dog();
	dog1.name = "小黑";
	dog1.color = "黑色";
	dog1.height = 3.0;
	dog1.weight = 10.0;
	
	System.out.println("狗的颜色："+dog1.color);
	System.out.println("狗的身高："+dog1.height);
	System.out.println("狗的体重："+dog1.weight);
	System.out.println("-----------dog2的第一次打印--------------------");
	
	//把dog1的属性赋给了dog2
	Dog dog2 = dog1;
	dog2.color = "白色";
	System.out.println("狗的颜色："+dog2.color);
	System.out.println("狗的身高："+dog2.height);
	System.out.println("狗的体重："+dog2.weight);
	System.out.println("---------dog1的第二次打印----------------------");
	System.out.println("狗的颜色："+dog1.color);
	System.out.println("狗的身高："+dog1.height);
	System.out.println("狗的体重："+dog1.weight);
	
	//类的对象的方法
	//变量名.方法名([参数]);
	dog.protectHome();
	dog1.protectHome();
	dog2.protectHome();
	dog.sleep();
	}
} 

成员变量和局部变量

※局部变量：
1.定义位置:在方法中(包括参数列表)、在各种语句块中(for循环、try…catch…finally代码块儿、静态代码块儿、对象代码块儿等等)
2.使用方式:局部变量必须赋初始值才能用;
4.生命周期：定义的时候产生，当前的方法的括号语句块的括号执行完毕就会消失。
※成员变量（属性）:
1.定义位置:类的直接下级
2.使用方式:可以不赋值，如果不赋值都有默认值。
3.存储位置:存储在堆中
4.生命周期：随着对象的消失而消失，会被jvm的垃圾回收器来回收掉

匿名对象

没有引用变量来引用它

代码清单

class Cat{
    //姓名
	String name;
	//颜色
	String color;
}
class TestCat{
	public static void main(String[] args){
		//创建匿名对象
		new Cat().name = "咪咪";
		new Cat().color = "白色";
	}
}

匿名对象是毫无意义的，因为栈中没有变量对它做引用，很快就会被垃圾收集器回收掉，在实际开发中应建议避免使用匿名对象。

this关键字

代表的是当前对象

特点:
※this只能在类的对象方法和构造器中使用;
※this代表当前调用这个this所在的方法的对象的自身(谁调用的this所在的方法，this就是谁);
※this可以在方法内区分同名的类的属性和参数名，有this的一定是属性，没有this的一定是方法的参数名;
※this关键字可以调用本类中的构造器;
※this可以调用本类的方法和属性;
※this要放在构造器的第一行。

代码清单:

class Car{
	String name;
	
	String color;	
	
	
	public void run(){
		//System.out.println("车在跑");
		System.out.println(this.color);
	}
	
	public void intrduce(){
		System.out.println("我是"+this.name+"   颜色是："+this.color);
	}
}


class TestCar{
	public static void main(String[] args){
		Car car = new Car();
		car.name = "大黄蜂";
		car.color = "黄色";
		System.out.println(car);
		//和System.out.println(this) 打印的地址是一样的
		car.run();
		car.intrduce();
	}
}

构造器

构造器的语法：
public 类名（[数据类型1 参数名1，数据类型2 参数名2….]）{

}
目的：创建对象
构造器的特点：
※可以定义0个、1个或者N个构造器;
※无参构造器是默认构造器;
※方法名和类名一致;
※方法没有返回值且没有void;
※构造方法的形参可有可无;
※如果类中没有显示的定义构造器，默认构造器是隐式存在的;如果类中定义了有参构造器则无参构造器就会被覆盖掉，如果想要继续使用无参构造器必须要显示的定义;
※在构造器中通过this([参数])可以来调用其他的构造器，而且this必须放在方法的第一行.
※如果类中没有带有参数的构造器，就可以使用一个隐藏的默认构造器来创建对象，如果一旦有带有参数的构造器，默认的构造器就会被覆盖。我们可以显式的定义出来默认构造器就可以使用了。

代码清单

/**
  * 构造器的使用
  */
class Persion{
	String name;
		
	int age; 
	
	char gender;
	
	public void intrduce(){
		System.out.println("姓名"+name+"   性别"+gender+"年龄"+age);
		}
		
	//默认构造器	
	public Persion(){
		
	}
			
	//构造器的创建 语法：public 类名([数据类型 参数名])	
	public Persion(String name){
		System.out.println("一个人被创建");
		this.name = name;
	}
		
	public Persion(String name,int age){
		//调用一个参数本类的构造器
		this(name);
		System.out.println("一个人被创建");
		this.age = age;
	}
	
	public Persion(String name,int age,char gender){
		//调用两个参数的构造器
		this(name,age);
		System.out.println("一个人被创建");
		this.gender = gender;
	}			
}


class TestPersion{
	public static void main(String[] args){
		Persion p = new Persion("张三");	
		System.out.println(p.name);
		System.out.println(p.age);
		System.out.println(p.gender);
		System.out.println("-----------------");
	
		Persion p1 = new Persion("李四",20);
		System.out.println(p1.name);
		System.out.println(p1.age);
		System.out.println(p1.gender);
		System.out.println("-----------------");
		
		Persion p2 = new Persion("王五",23,'男');
		System.out.println(p2.name);
		System.out.println(p2.age);
		System.out.println(p2.gender);
		System.out.println("-----------------");
		
		Persion p3 = new Persion();
		System.out.println(p3.name);
		System.out.println(p3.age);
		System.out.println(p3.gender);
	}	
	
}

static关键字

可以修饰在属性、方法和代码块儿上
1、修饰在属性上
(1)定义类属性：
※static 数据类型 变量名；
※使用static修饰的属性我们认为是类的属性，不带static修饰的属性我们认为是对象的属性;
※静态属性的特点:该类的所有实例可以都共享这个属性。

(2)类属性访问：
类名.类属性名（推荐使用）
对象名.类属性名

(3)类属性和成员属性的区别:
※生命周期：
创建对象的时候初始化对象属性（没有类属性早），当前对象变成匿名对象时，jvm会回收该垃圾对象，对象属性随之消失。
当.class文件被载入内存时static属性就初始化了，jvm关闭，static属性就消失。
※内存结构不同:
static属性存在方法区中(jdk1.8以后叫元数据区);
成员属性存在堆内存中。

代码清单

class User{
	String username;	
	
	int password;
	//类属性的创建 语法：static 数据类型 变量名
	static int  userCount;
	
		public void sign(){
			System.out.println("用户名："+username+"    密码"+password);
		
	  }
}

class TestUser{
	public static void main(String[] args){
		//创建一个类的对象
		User user = new User();
		//类属性的调用1  类名.变量名
		User.userCount++;
		//再次创建类的对象
		User user1 = new User();
		User.userCount++;
		
		User user2 = new User();
		//类属性的调用2  对象名.变量名
		user.userCount++;
		System.out.println("用户的数量："+User.userCount);
		}
}

2.修饰在方法上
(1)语法：
public static 返回值类型[void] 方法名（数据类型 参数名,….）{

方法体
return 结果；

}
(2)类方法的调用
类名.类方法名（推荐使用）
对象.类方法名（不建议使用）
(3)类方法特点
※类方法中不能直接使用对象的属性；
※类方法只能使用类属性；
※类方法中不能存在this关键字；
※对象方法可以调用类方法，反过来不可以。

代码清单:

class Teacher{
	
	String name;
	
	int age;
	
	String lession;
	
	static int teacherCount;
	
	/**
	 * 对象的方法，每一个老师的实例可以使用
	 */
	public void teach(){
		System.out.println(this.name+"老师在教课");
	}
	
	/*
	 * 类方法
	 */
	public static void sleep(){
		System.out.println(teacherCount+"老师在睡觉");
	}
	
}

class TestTeacher{
	
	public static void main(String[] args){
		/*
		//使用类名来调用类方法
		Teacher.sleep();
		//使用对象来调用类方法
		Teacher t = new Teacher();
		t.sleep();
		*/
		Teacher t = new Teacher();
		t.name = "任亮";
		//t.teach();
		t.sleep();
	}
	
}