面向对象

面向对象 **

一、类和对象的关系解析

**
1.类
类是一个抽象的概念，它不存在于现实中的时间/空间里，类只是为所有的对象定义了抽象的属性与行为。就好像“Person（人）”这个类，它虽然可以包含很多个体，但它本身不存在于现实世界上。
2.类是一个静态的概念，类本身不携带任何数据。当没有为类创建任何对象时，类本身不存在于内存空间中。
例子：
public class 类名{class就是定义类的关键字,注意Java要求类名和文件名一致
对象：对象是类的一个具体。它是一个实实在在存在的东西
对象是一个动态的概念。每一个对象都存在着有别于其它对象的属于自己的独特的属性和行为。对象的属性可以随着它自己的行为而发生改变。
例子：
类名 对象名=new 类名() \如果加了带参数的构造方法

二、如何创建类，如何创建对象，如何调用属性和方法

如何创建类：
public class 类名{class就是定义类的关键字,注意Java要求类名和文件名一致

如何创建对象：
类名 对象名=new 类名() \如果加了带参数的构造方法，（）里面必须传入对应参数的类型

三、构造方法与一般方法的区别

构造方法作用：
构造方法作用就是对类进行初始化。 如果你没有定议任何构造方法的形式，程式会为你取一个不带任何参数的构造函数，那么你产生类的对像时只能用不带参数的方法。
如果一个类没有声明构造方法，则会有一个默认的无参数的构造方法【隐式声明】
与一般方法的区别：
构造方法没有返回值声明，方法必须有返回值的声明
构造方法的名字必须和类名一样，方法的名字一般和类名不一样
构造方法通过new 关键字调用 ,方法通过对象调用
调用构造方法的结果是创建一个对象，调用方法的结果是对象在执行一个动作
一般方法的代码：
///编写一个java程序在屏幕上输出，1！+2！+3！+。。。+10！的和
一般方法：
package task;

public class task {
public static void main (String [] agrs){
int i,j,numb,sum;
for(i=1;i<=10;i++){
numb=1;

   for(j=1;j<=i;j++){
	   numb=numb*j;
   }
   sum=sum+numb;
   }
   System.out.println(sum);

}
}
构造方法的代码：
学生类：
public class Student{

//成员属性
protected String name;
private int age;


//设置姓名
public void setName(String s){
	name= s;
}

//获得姓名
public String getName(){
	return name;
}

//成员方法
public void study(){
	System.out.println(name+"今年"+age+"岁了，要上大学了");
}

public void study(String km){
	System.out.println(name+"在学习"+km);
}

}
主函数：
public class Main{
public static void main(String[] args){

Student stu = new Student();
stu.setName("张三");
stu.study();



UNStudent stu2 = new UNStudent();
stu2.setName("李四");
stu2.study();
stu2.cet();

//类型的自动转换
Student stu3 = new UNStudent();
stu3.setName("王五");
stu3.study();


UNStudent stu4 = (UNStudent)stu3;
stu4.study();
stu4.cet();




}

}
**

四、方法重载与重写的区别

**
方法的重载：在同一个类中，可以定义多个同名不同参数列表的方法，就是方法的重载
不同参数列表指方法的参数类型或者个数或者顺序不一样。在同一个类中可以定义多个构造方法，必须要保证构造方法的参数类型或者个数或者顺序不一样

方法的重写：方法重载是静态多态，是编译时的多态
　　b.发生在一个类里面，方法名相同，但参数个数或种类不同的方法之间的联系方式，称之为方法重载
c.使你的程序变的更灵活

方法的重载代码演示：

• 方法重载演示
  */public class Caculator {
  public int add(int x, int y) {
  return x + y;
  }

  public int add(int x, int y, int z) {
  return x + y + z;
  }

  public float add(float x, float y) {
  return x + y;
  }

  public int add(int… value) {
  int temp = 0;
  for (int i=0; i<value.length; i++){
  temp+=value[i];
  }
  return temp;
  }

  public static void main(String[] args) {
  //实例化Caculator对象
  Caculator caculator = new Caculator();
  System.out.println(caculator.add(1, 2));
  System.out.println(caculator.add(1, 2, 3));
  System.out.println(caculator.add(1.2f, 2.3f));
  System.out.println(caculator.add(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
  }
  }

方法的重写：　Car类（父类）
　　
public class Car {
public void run (){
System.out.println(“car run”);
}
}
　　Motorcycle类
　　
public class Motorcycle extends Car{
@Override
public void run() {
System.out.println(“motorcycle run”);
}
}
　　Bicycle类
　　
public class Bicycle extends Car{
@Override
public void run() {
System.out.println(“bicycle run”);
}
}
　　Main类

public class Mian {
public static void main (String []args){
Car car =new Car();
car.run();

    Motorcycle motorcycle = new Motorcycle();
    motorcycle.run();

    Car bicycle = new Bicycle();
    bicycle.run();
}

}

五、解析面向对象的三大特征
面向对象三大特征：
1.封装
封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。封装是一种信息隐藏技术，在java中通过关键字private实现封装。什么是封装?封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。
代码例子：
public class Man
{
//对属性的封装，一个人的姓名，年龄，妻子都是这个对象(人)的私有属性
private String name;
private int age;
private Woman wife;
//对该人对外界提供方法的封装，可以设定妻子，姓名，年龄也可以获得男人的姓名和年龄
// 方法封装
public void setWife(Woman wife) {
this.wife = wife;
}
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 class Woman {
// 属性封装
private String name;
private int age;
private Man husband;
// 方法封装
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 Man getHusband() {
return husband;
}
public void setHusband(Man husband) {
this.husband = husband;
}
}

2.继承
Java中，一个类继承只能继承一个类。
子类可以继承到父类中的属性和方法，实现代码重用，减少代码的冗余子类可以再继承父类属性和方法的基础上，定义自己特有的属性和方法，完成对父类的扩展 ，子类特有的属性和方法必须要是声明成子类类型的变量才能调用， 如果一个子类对象的类型被自动转换成父类类型之后，还想调用子类特有的方法，就需要强制转换成子类类型
继承例子：
　 class People{
　 String name;
　 int age;
　　 int height;
　　 void say(){
　 System.out.println("我的名字是 " + name + "，年龄是 " + age + "，身高是 " + height);
　　 }
　　 }

class Teacher extends People{
　String school; // 所在学校
String subject; // 学科
　　 int seniority; // 教龄
　
　
　　void say(){
　　System.out.println(“我叫” + name + “，在” + school + “教” + subject + “，有” + seniority + “年教龄”);
　　 }
　　 void lecturing(){
　　 System.out.println(“我已经” + age + “岁了，依然站在讲台上讲课”);
　　}
　　 }

3.多态
多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）
多态的作用：消除类型之间的耦合关系。