黑马程序员——面向对象的基本概念知识---
---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a
href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流！
一、什么是面向对象
1.面向对象相对于过程而言，过程是强调功能的行为，如推开门，关闭们的一系列动作过程
面向对象强调对象的行为，找到门对象，就知道门的推开，关闭的行为,不关心门的转轴原理，
面向过程是面向对象的基础，复杂的事情简单化，角色从执行者转变成指挥者。
一句话谈对象：万物皆对象
2.面向对象三大特征：封装、继承、多态
封装：将对象的属性和实现细节隐藏起来，仅对外提供公共访问方式。
好处：变化隔离，便于使用，提高重用性，提高安全性。
原则：把属性隐藏，对外提供访问方法，不需要对我提供的内容都隐藏起来。
例如：经理招聘专业开发人员，负责完成项目，开发过程，细节技术对经理而言封装起来了，关心的是项目结果。
使用电脑，主机内部组件结构不需要知道。
继承：将类的共性描述提取出来，单独进行描述作为基类。如子类继承父类共性的描述，使用父类的方法和数据。
子类继承父类：super()：访问父类空参数 的构造函数，所有子类构造函数默认第一行有一个隐式super（），
父类中数据子类可以直接获取，子类在对象初始化时要先访问父类的构造函数，先初始化父类构造函数，才能使用。
例如：猫，狗 继承动物类，各自有shout 叫的方法。
class Person{
String name;//姓名
int age; //年龄
}
class Student extends Person{
// String name;
// int age;
super();
void work(){
System.out.println("学生的任务是好好学习");
}
}
class Teacher extends Person{
// String name;
// int age;
super();
void work(){
System.out.println("老师教书育人");
}
}
public class ExtendDemo {
public static void main(String[] args) {
Student s = new Student();
s.name = "zhangsan";
s.age = 15;
s.work();
}
}
行对话有多种行为(方法)。
例如：老板对员工说"九点开始工作"，销售人员做销售工作，技术部开始研发技术，经理管理项目，员工就是抽象事物，老板只
需对员工发布命令，所有职员就开始不同的工作。
多态体现：父类型的引用指向其子类型的对象,调用的方法是该子类型的方法。
多态原则：必须有关系，比如继承、或者实现关系。
多态好处：提高程序扩展性。
多态的弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法
。
public abstract class Car{ //定义抽象车类
/*属性*/
public void run();//让车子跑起来来
}
class BMW extends Car{
public void run(){
System.out.println("宝马在以200迈的速度在run");
}
}
class BYD extends Car{
public void run(){
System.out.println("比亚迪80马力开跑...");
}
}
public class Person{
private Car Car; ---基类引用
public Person(){
}
public Person(Car Car){ 传人Car 类型
this.Car = Car;
}
public void drive(){
Car.run();
}
public void setCar(Car Car){//运用参数多态,以后不管买什么车都可以
this.Car = Car;
}
public static void main(String args[]){
Person p =new Person();
BYD byd = new BYD();//刚开始没钱就买辆比亚迪吧
p.setCar(byd); //基类的引用指向车这个对象
p.drive();
Benz benz = new Benz{();//现在有钱换车了
p.setCar(benz);
p.drive();
}
}
二、类和对象的关系
类是描述事物对象的属性和行为，描述共有的一些特性，类中必须有对象才有意义。
对象描述生活中的事物，具体存在的实体,映射到Java中就是Class定义的类
对象就是放在堆里面new 出来的实体对象 。
属性对应的是类中的成员变量，行为是成员变量的方法。
三、成员变量(实例变量)与局部变量、静态变量、静态方法(Static修饰)、finnly修饰和符匿名对象
成员变量：1.作用于整个类中，定义在方法外部，存在于堆内存中，因对象的存在而存在，随着对象的消失而消失。
2.实例变量所属对象的属性，必须创建对象才分配内存空间，才可以通过对象使用。
局部变量：作用于语句块内部或方法体中，存放于栈内存中，使用前必须声明类型和初始化值，周期随着方法调用完而销毁。
静态变量：1.被Static所修饰，不再属于该类对象的属性，而是属于该类的属性，共享这个变量属性，也叫类变量。
2.静态变量存储在方法区中，可以直接类名来调用。
3.静态变量随类加载而加载，随着类消失而消失，周期较长。
静态方法：1.被Static修饰的方法叫做静态方法，属于类，也叫类方法，只能访问静态成员，不能出现this/super 等关键字。
2.静态方法和非静态方法都会加载到方法区中，静态方法调用格式是：类名.静态方法
5.finaly修饰符：finaly 修饰的变量时，引用变量不能变，引用变量的对象内容是可以改变的，修饰方法不能被子类继承，重写
。
6.匿名对象：对象的简写
作用一：当对对象方法只进行一次调用时，可以用匿名对象完成，可以简化,调用属性是没有意义的。如果对这个对象的成员进行
多次调用，必须给对象起个名。
作用二:匿名对象可以进行参数传递
static：关键字，是一个修饰符，用于修饰成员(成员变量和成员函数)和方法。
特点：
1，想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。
2，修饰静态方法只能访问静态成员，可以被类直接调用，格式是类名.静态方法态方式。
3，随着类的加载而加载，优先对象存在。
弊端：
1，有些数据是对象特有的数据，是不可以被静态修饰的。因为那样的话，特有数据会变成对象的共享数据。这样对事物的描述就
出了问题。例如：每个人的名称属性属于他自己，你可以改自己的名字但不可以改他人的名字。所以，在定义静态时，必须要明
确，这个数据是否是被对象所共享的。
2，静态方法只能访问静态成员，不可以访问非静态成员。
因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。
3，静态方法中不能使用this，super关键字。
因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。
4，主函数也是静态的。
public class car{
private int num=5;
private String color="red";
public static void main(String[] args) {
// TODO Auto-generated method stub
Car c=new Car();
showCar(c);
//ShowCar(new Car);
System.out.print("车的数量是："+c.num+"颜色是："+c.color);
}
public static void showCar(Car c){ //接收汽车类型，传入进去
c.num =2;
c.color="black";
}
四。构造函数、构造代码块、静态代码块、与一般方法
构造函数：1.与类名相同，对象一建立就会调用与之对应的对象的构造函数，给对象初始化。
2.类中如果没有构造函数，系统默认会定义一个构造函数,一个对象建立，构造函数只运行一次，一般方法可以被对象
调用多次。
构造代码块：对所有对象进行统一初始化，不同对象具备共性的定义在代码块中，局部代码块，限定变量的周期。如不同的孩子
都会哭。
静态代码块：1.对类进行初始化，静态代码块,随着类的加载而加载,且只加载一次。
2.静态代码块优先于构造代码块，优先于构造方法执行。对象创建几次，构造代码块就调用几次。
顺序：静态代码块 >构造代码块>构造函数
this关键字：表示本类当前函数所属对象的引用。简单说那个对象调用this所在的构造函数。this就代表这个对象，用于构造函
数之间调用。
this只能定义在构造函数的第一行，初始化的动作先执行
this应用：当定义类中功能时，该函数内部要调用该函数的对象时，this表示该对象，演示
class Person{
private String name;
private int age;
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;
}
person(){
System.out.print("人一出生会哭");
speak();
}
person(String name){
System.out.print("姓名"+name);
speak();
}
person(String name,int age){
System.out.print("人的姓名"+this.name+"年龄"+this.age);
speak();
}
public boolean compare(Person p) //传入人这个对象
this.age=p.age
}
public void speak(){
System.out.print("cry")
}
calss PersonaDemo1{
public static void main(String[] args) {
Person p1=new PerSon(20);
Person p2=new PerSon(25);
boolean b=p1.compare(p2) //this 当前p1的年龄与传入p2的年龄比较
}
五、Java堆与栈、方法区的区别，各自优缺点。
栈区：1.存放局部变量或对象的引用
2.连续的存储空间
3.先进后出，后进先出(瓶子里放东西，倒出来)，调用完释放内存。
优点：存取速度比堆要快，仅次于寄存器，栈的数据可以共享。
缺点：栈存取的数据大小 生存期要先确定。
堆区：1.存放new出来的对象或数组
2.不是连续存储空间
3.对象生命周期由Java虚拟机垃圾回收机制统一管理。
优点：堆的内存是动态分配大小，生存期不用告诉编译器，Java垃圾收集器回自动处理不使用的数据
运行时动态分配内存，存取速度慢
方法区：存放Static静态变量、方法，常量池（Sting类型）
栈举例：
int a = 3;
int b = 3；
编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找栈中是否有3这个值，如果没找到，就将3存放进来
，然后将a指向3。接着处理int b = 3；在创建完b的引用变量后，已经存在3这个对象 直接指向3（数据共享）
System.out.print(a=b); 正确，应为a和b指向同一个对象。栈中无论创建多少个引用，如果指向是一样，只存有一个对象。
堆：
String str1 =new String ("abc");
String str2 =new String ("abc"); new 个对象在堆中
System.out.println(str1.equals(str2)); //true equals比较两个对象相等
原因：每new一次都会创建新对象，不管指向的值是否相等，此时str1、str2是两个对象
六.重载与覆盖(重写)区别：
重载：1.表示一个类中有多个同名方法，但方法参数列表个数、类型不同
2.不能通过访问权限，返回类型、抛出异常进行重载
覆盖：1.子类重写父类的方法，已达到不同的作用，继承或扩展方法
2.覆盖的方法返回值必须与被覆盖的返回一致，比如父类返回int 型，子类也必须是int型
3.覆盖的方法所抛出的异常必须和被覆盖(父类)所抛出的异常一致，或者是其子类。
4.被覆盖(父类)的方法如果是private 私有的，子类只能重新定义一个方法，不能重写。
---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a
href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流！
323
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
