java面向对象学不会？看完就会了

1.什么是面向对象

众所周知java是面向对象的编程语言，那么什么是面向对象呢，大家经常把面向对象和面向过程混淆，下面就说个例子，一秒就会！
例如小明有一些脏衣服需要去洗干净，这是就相当于一个命令把衣服洗干净
A:面向过程:小明需要自己独立完成，打水、放洗衣液、搓衣服等等一些列操作直至衣服洗干净
B:面向对象:小明不需要自己独立完成，但是他需要把衣服送到具有洗衣服功能的地方，例如洗衣房，你需要办一张会员卡，然后对工作人员说：我不管你用什么办法，总之给我洗干净就行

2.面向对象格式

首先需要一个类，这里面不写main方法，这里面会有三部分组成
A:类变量B:类方法C:构造函数
假如现在有一个学生类

• A：类变量，又称作成员变量，它是用来描述这个类的属性，、一个学生肯定有姓名、学号、年龄、性别等一些列属性！所以这些成为成员变量
• B:类方法：类方法就是这个类他有什么功能，他能干一些什么，例如一个学生他能算数、考试、吃饭等一系列技能
• C:构造函数：构造函数就是给这个类找个实体，现在只知道这是一个学生类，这个学生类具体是谁啊，目前不知道，现在就需要一个构造函数来完成定义一个实体，注意构造函数他主要有两种，一种是无参构造另一种有参构造构造函数可以有多个或者一个没有，接下来就说一下这两个的区别
  无参构造：无参构造来定义一个实体时，只是指明有一个学生，但是学生的信息没有说！当在学生类中没有写构造函数，java会自动为这个类提供一个无参构造，用于创建对象（实体）
  有参构造:有参构造定义的一个学生，他还指定了一个这个学生的一些信息，比如这个学生叫什么，今年多大了，下面通过代码来说明一下描述

学生类：

public class 	Student {
	
	//成员变量
String name;//学生姓名
String  sex;//学生性别
int age;//学生年龄

/**
 * 成员方法
 * 格式:   修饰值关键字   返回值类型   方法名(参数){}
 * 修饰关键字：public(所有地方都可以用)  protected(同一个项目可以用)  不写(同一个包)   private(同一个类)
 *返回值类型：就是完成这个方法，返回的结果
 *参数：这里的参数指的是形式参数	
 *
 */
public void eat() {
	System.out.println("我会吃饭");
}
public int add(int a,int b) {
	return a+b;
}
//构造函数,记住这个格式即可
//有参构造
public Student(String name, String sex, int age) {
	super();
	this.name = name;
	this.sex = sex;
	this.age = age;
}
//无参构造
public Student() {	
}
}

测试类：
因为在学生类中我们没有写main函数，没有办法运行，需要写一个测试类

public class TestStudent {
	public static void main(String[] args) {
		//创建对象，对象是怎么来的，new出来
		//这就是一个学生，用stu1表示，但这个学生没有指定任何信息就称为无参构造
		Student stu1=new Student();
		//因为stu1是个学生，所以他能够完成Student类中的功能，实体对象.方法名();即可调用
		stu1.eat();
		//这就是一个学生，用stu2表示，但这个学生指定了他的姓名、性别、年龄我们称为有参构造
		Student stu2=new Student("zhangsan","nan",18);
	}
}

注意:一个类中可以没有构造函数，也可以有多个构造函数

3.方法重载

方法的重载这个也比较重要，方法重载指的是在一个类中两个方法方法的名字相同，但传递的参数不同，代码如下

public class Test {

	public void shouMe(String name,int age) {
		System.out.println("我的名字"+"name"+"我今年"+age);
	}public void shouMe(String name ,String sex,int age) {
		System.out.println("我的名字"+name+"我的性别"+sex+"我的年龄"+age);
	}
	public static void main(String[] args) {
		Test t1=new Test();
		t1.shouMe("zhangsan", 14);
		t1.shouMe("lisi", "nan", 15);
		/**
		 * 打印结果
		 * 我的名字name我今年14
		*我的名字lisi我的性别nan我的年龄15
		 */
	}
}

4.this的使用

当一个类中的成员变量与方法的形参重名里，在方法中要使用成员变量的值需要用this.成员变量

public class Stu{
String name="张三";
public static void main(String[] args) {
Stu s1=new Stu();
s1.test("李四");
}
public void test(String name){
//这里的name为形参
System.out.println(name);//结果为李四
System.out.println(this.name);//结果为张三
}
}

5.静态static

静态是比较常用的一个关键字，静态经常修饰变量，方法，静态代码块
用static修饰的有两个特性A:静态B:共享
B:共享：用static修饰的变量和方法，表示他不是一个对象独有的，他是所有对象公用的，用static修饰的变量和方法，不需要创建对象就可以直接类名.方法名/变量名即可调用

public class Stu{
String name="张三";
public static void main(String[] args) {

Stu.test("李四");//因为test方法是静态的，所有可以直接用，不建立对象，变量也是如此
}
public static void test(String name){
//这里的name为形参
System.out.println(name);//结果为李四
System.out.println(this.name);//结果为张三
}
}

静态代码块是类加载便执行的部分，他是第一个执行的，但是他只执行一次，当再次访问这个类时，static代码块不会执行，接下来说明一下静态代码块、构造函数，构造代码块执行顺序

public class sta {
/**
 
 * 
 * 静态代码块在类加载的时候运行，只要加载class文件，静态代码块就会执行，且只执行一次
 * 一个类中静态代码块最先执行且只运行一次，构造代码块会在new对象时执行且在构造方法之前运行
 * 
 * @param args
 */
	String name;
	int age;
	{
		//构造代码块
		System.out.println("我是构造代码块");
	}
	static {
		//静态代码块
		System.out.println("我是静态代码块");
	}
	public sta() {
		//无惨构造函数
		System.out.println("我是无惨构造");
	}
	
	public sta(String name, int age) {
//有参构造函数
		System.out.println("我是有参构造");
		this.name = name;
		this.age = age;
	}
	public static void main(String[] args) {
		sta s=new sta();
		sta s2=new sta("xzc", 21);
	}
	

}
结果
我是静态代码块
我是构造代码块
我是无惨构造
我是构造代码块
我是有参构造

所以执行顺序静态代码块>构造代码块>构造函数
当我们学了继承后就会发现，所有执行顺序都是父类执行完了在执行子类

6.封装

封装是java特性之一，是将java的属性进行私有化，在外界不能随意更改他的属性，要想修改通过特有的方法(set/get方法)快捷键:Alt+shife+s选择Set\Get方法

public class Person2 {
	private String name;
	private int age;
	private String sex;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}
}

public class Test2 {
public static void main(String[] args) {
	Person2 p=new Person2();
	p.setAge(10);
	p.setName("张三");
	p.setSex("女");
	System.out.println(p.getName()+p.getAge()+p.getSex());
	结果：
	张三10女

}
}

7.继承

继承是java特征之一，使用extends关键字，继承需要注意的点

1. 一个子类只有一个直接父类
2. final关键字修饰的类不能被继承
3. 子类是父类的完善与扩展
4. 子类是继承父类非私有的属性和行为
5. 继承不能环形继承例如A是B的父类，B是C的父类，C是A的父类这就会报错

比如这里有一个有一个动物类，小狗、小猫都属于animal所以他属于一个父类，小狗、小猫就能使用拥有父类非私有的属性和行为，一定注意是非私有

public class Animal {
	String name="旺财";//这相当于父类给每一个子类的名字都是旺财
	String sex;
	int age;
	private int num;

	public void eat() {
		System.out.println("一日三餐！");
	}
}

还有一个狗类和熊类继承动物类

public class Dog extends Animal {
	String name="八公";//Dog自己给自己取的名字
	
	
	//小狗的新特性，会算数
	public int add(int a,int b) {
		return a+b;
	}
	public void showMe(String name) {
		System.out.println("我在方法的名字叫"+name);
		System.out.println("我自己的名字"+this.name);//this指子类
		System.out.println("我父亲给我的名字"+super.name);//super指父类
	}
}

public class Bear extends Animal {
	
	public void eat() {
		System.out.println("我喜欢吃任何东西");//与父类传来的方法相同，这叫做方法的重写
	}
	
	
}

测试类

public class Test {
	public static void main(String[] args) {
		Dog dog=new Dog();
		dog.showMe("边牧");
		dog.num;//报错，因为父类的num是私有的
		Bear b=new Bear();
		b.eat();
	}
}
结果：
我在方法的名字叫边牧
我自己的名字八公
我父亲给我的名字旺财
我喜欢吃任何东西

7.上溯

例如以上有个动物类，一个狗类

Animal a=new Dog();//Dog也属于动物类，这样就是上溯，相当于强制转换
//这里a只能使用Animal中定义过得方法和属性，a不能使用Dog自己新增的
//并且如果子类重写了父类的方法，则走重写后的

8.多态

多态是用在继承关系中的，这个也利用到了上述的上溯，多态使用的地方
A：方法的参数 B:方法返回值
例如有一个动物类，Dog类、Cat类、Bear类

public class Animal {
	String name;
	int age;

	public void eat() {
		System.out.println("Animal的eat方法");
	}
}

public class Dog extends Animal {
	@Override
	public void eat() {
		System.out.println("狗爱吃骨头");
	}
}

public class Cat extends Animal {
	@Override
	public void eat() {
		System.out.println("猫爱吃鱼");
	}
}

public class Bear extends Animal {
	@Override
	public void eat() {
		System.out.println("熊什么都爱吃");
	}
}

最后再来一个测试类

public class TestAnimal {

	public static void run(Animal a) {
		a.eat();
	}

	public static void main(String[] args) {
		TestAnimal.run(new Dog());
		结果：狗爱吃骨头
		TestAnimal.run(new Cat());
		结果：猫爱吃鱼
		TestAnimal.run(new Bear());
		结果：熊什么都爱吃
	}
}

在run方法里，需要传递一个Animal的对象，因为上述猫狗熊都继承了Animal类，所以猫狗熊都是属于Animal的一种，这就是多态