黑马Java——面向对象

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

面向对象
理解；
面向对象相对于面向过程而言，它们都是一种思想。面向过程强调的是实现功能
行为的过程。面向对象是将功能封装进对象，强调是具备实现某功能的对象，
特点：
复合人们思考习惯，将复杂事件简单化，将程序员从执行者转换为指挥者
完成需求时，先去找具体所需的功能的对象，如果没有则创建一个，简化开发提高复用


开发过程：不断创建对象，使用对象，指挥对象完成事情
设计过程：管理和维护对象之间的关系
特征：封装（encapsulation）、继承（inheritance）、多态（polymorphism）


类与对象
类就是对现实生活中对一类事物的描述。
对象就是这类事物，实实在在存在的个体，具体体现


类的定义
就是描述事物，定义属性和行为，属性和行为，在类中就是叫成员变量，成员方法


成员变量和局部变量的区别
范围：成员变量定义在类中，这个类中都可以访问，局部变量定义在你局部范围内，如函数内，语句内
内存位置：成员变量随对象建立而建立，存在于对象所在的堆内存中，随着对象的消失被垃圾回收器处理。
 局部变量存在栈内存中。成员变量又默认初始化值，局部变量没有默认初始化值


对象的创建和使用
class Person
{
String name="小红";
int age=18;
void show()
{
System.out.println("name="+name+"age="+age);
}
}
class PersonDemo
{
public static void main(Strng[] args)
{
Person p = new Person();//创建对象
p.name="小明";//修改对象成员变量
p.show();//调用对象成员方法
}
}


匿名对象
概念：是对象的简化形式
用法：
1、当对对象方法仅进行一次调用时
2、可以作为实际参数进行传递
class Car
{
String color="绿色";
int num=4;
void run()
{
System.out.println(color+"----"+num);
}
}
class CarDemo
{
public static void main(Strig[] args)
{
new Car().num=5;
show(new Car());
}
public static void show(Car c)
{


c.color="红色";
c.run();
}
}


封装
概念：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
优点：将变化隔离便于使用，提供复用性和安全性。
原则：将不需要对外提供的内容隐藏起来，将属性隐藏提供公共访问方法对其访问




private(私有)关键字
概念：是一个权限修饰符，用于修饰类中的成员变量和成员函数，成员私有后即被
private修饰后只在类中有效。私有仅仅是封装的一种表现形式。
用法之一：一般将成员变量私有后，对外提供set,get方法对其进行访问和设置。
 
构造函数
概念：函数名与类名相同，不用定义返回值类型，不能写return语句
作用：给对象初始化。
注意:当一个类中没有定义构造函数时，系统默认会给类加一个空参数的构造函数-->类名（）{}，
     如果类中定义了构造函数后，默认的就没有了。多个构造函数是以重载的方式存在的
     构造函数的重载可以用于对不同对象的初始化。
构造函数与一般函数区别
1、写法上不同，构造函数不用定义返回值类型，不能写return语句
2、运行上不同，构造函数在对象一建立就运行，且一个对象只运行一次，而一般函数
   可以被一个对象多次调用
class Person
{
private String name;
private int age;

Person()
{
System.out.println("A:name="+name+",age="+age);
cry();
}
Person(String n)
/**/
{
name=n;
System.out.println("B:name="+name+",age="+age);
cry();
}
Person(String n,int a)
{
name=n;
age = a;
System.out.println("C:name="+name+",age="+age);
cry();
}
public void cry()
{
System.out.println("cry!!");
}
}


class  PersonDemo2
{
public static void main(String[] args) 
{
Person p1 = new Person();

//Person p2 = new Person("sdfsf");这是对于不同对象使用不同的构造函数初始化


//Person p3 = new Person("wer",20);
}
}




this关键字
概念：this代表其所在函数所属对象的引用，也就是本类对象的引用
用法：当在函数内需要用到调用该函数的对象时，就用this
如：
class Person
{
private String name;
private int age;
Person(String name)
{
this.name=name;
System.out.println("name="+this.name+"---age="+this.age);
}


}


class  PersonDemo4
{
public static void main(String[] args) 
{
Person p = new Person("dlsfkj");
Person p2= new Person("张三");
}
}
this语句用在函数间调用


this语句只能定义在构造函数的第一行，因为初始化的动作要先执行
class Person
{
private String name;
private int age;

Person()
{
System.out.println("qqqqq");
//Person("dd");这种不允许，相当于死循环调用下面的，下面的又调用上面的，一直循环
}
Person(String name)
{
this();
this.name = name;
}
Person(String name, int age)
{
//this.name = name;可以发现这里的name赋值在上面的构造函数就也已经做过了，所以可以用this来直接调用上面的构造函数给name  赋值
this(name);//相当于new Person(name)-->调用上面的Person(String name)
this.age = age;
}
public void getAge()
{
System.out.println(name);
}
}


class PersonDemo6 
{
public static void main(String[] args) 
{
Person p = new Person("sdfs",90);
p.getAge();
Person p2 = new Person("师傅的说法",90);
p2.getAge();


}
}
输出结果为：
qqqqq
sdfs
qqqqq
师傅的说法


static（静态）关键字
概念：静态修饰的内容有成员变量和成员函数
用法：当对象中出现共享数据时，该数据被静态所修饰，存放于方法区。
对象中的特有数据定义为非静态存在于堆内存.当函数内部没有
访问到非静态数据时候，该函数可以定义为静态函数
优点:
随着类的加载而加载，优先于对象存在，被这个类的所有对象共享，可以直接被类名调用


实例变量(成员变量)和类变量(静态成员变量)的区别：
1、存放位置，类变量随着类的加载而存在于方法区中，
实例变量随着对象的建立而存在于堆内存中
2、生命周期：类变量生命周期最长，随着类的消失而消失
实例包揽了随着对象的消失而消失


静态使用注意事项：
1、静态方法只能访问静态成员
   非静态方法既可以访问静态也可以访问非静态
2、静态方法中不可以定义this,super关键字
因为静态优先于对象存在，，所以静态方法中不可以出现this
例如：
class Person 
{
String name;//成员变量，实例变量
static String country = "CN";//静态的成员变量，类变量


public static void speak()
{
//System.out.println("name="+name+country);这里是不可以的因为name不是静态变量
//System.out.println(this.name);也是不行
System.out.println(country);
}
}
3、主函数是静态的


利:对对象的共享数据进行单独空间的存储，节省内存空间
   可以直接被类名调用
弊：生命周期过长，访问出现局限性。（静态虽好，只能访问静态）


静态的应用——工具类
每个应用程序中都有共性的功能
可以将这些功能进行抽取，独立封装
以便复用


虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。
发现了问题：
1、对象是用于封装数据的，可是ArrayTool对象并未封装特有数据
2、操作数组的每个方法都没有利用到ArrayTool对象中的特有数据。


这时可以考虑，让程序更严谨，是不需要对象的。
可以将ArrayTool中的方法都定义成static的，直接通过类名既可以调用


将函数静态后，可以方便与使用，但是该类还是可以被其他程序建立对象的
为了更加严谨，强制让该类不能建立对象。
可以通过将构造函数私有化完成。


*/


class  ArrayTool
{
//将构造函数私有化，强制让类不能建立对象
private ArrayTool(){}


//取数组中最大值
public static int getMax(int[] arr)
{
int max= 0;
for(int x =1; x<arr.length;x++)
{
if(arr[x]>arr[max])
max=x;
}

return arr[max];
}
//取数组中最小值
public static int getMin(int[] arr)
{
int min=0;
for (int x=1;x<arr.length ;x++ )
{
if(arr[x]<arr[min])
arr[min]=arr[x];
}
return arr[min];
}
//选择排序
public static void selectSort(int[] arr)
{
for (int x=0;x<arr.length-1 ;x++ )
{
for (int y=x+1;y<arr.length ;y++ )
{
if(arr[x]>arr[y])
{
swap(arr,x,y);
}
}
}
}


//冒泡排序
public static void bubbleSort(int[] arr)
{
for (int x=0;x<arr.length-1 ;x++ )
{
for (int y=0;y<arr.length-x-1 ;y++ )
{
if(arr[y]>arr[y+1])
swap(arr,y,y+1);
}
}

}


//查找val第一次出现在数组中的位置
public static int getIndex(int[] arr,int val)
{
for (int x=0;x<arr.length ;x++ )
{
if(arr[x]==val)
return x;
}
return -1;
}


//折半查找
public static int halfSearch(int[] arr,int val)
{
int max,min,mid;
max=arr.length-1;
min=0;

while (min<=max)
{
mid=(max+min)>>1;
if(val>arr[mid])
min=mid+1;
else if(val<arr[mid])
max=mid-1;
else
return mid;
}
return -1;
}
//置换两个数，由于这个函数不用被外部调用，所以静态
private static void swap(int[] arr,int a,int b)
{
arr[a]=arr[a]^arr[b];
arr[b]=arr[a]^arr[b];
arr[a]=arr[a]^arr[b];
}


//顺序打印数组
public static void printArray(int[] arr)
{
System.out.print("[");
for(int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.print(arr[x]+"]");
}
System.out.println();
}


}


这样一来对数组的操作就归结到了这个ArrayTool中，只要用ArrayTool.对应函数就可以直接调用
功能，并且该类中的构造函数已经被私有化了，所以这个类就不能创建对象，只能单独的作为调用
工具的一个类。


静态代码块
 格式：
 static
 {
静态代码块中的执行语句。
 }
 特点：随着类的加载而执行，只执行一次，并优先于主函数
 用于给类进行初始化


 执行顺序
  静态代码块(给类初始化)-->构造代码块(给所有对象初始化)-->对应构造函数(给对应对象初始化)
class StaticCode
{
//构造函数给对没有传值的对象初始化
StaticCode()
{
System.out.println("b");
}
//静态带代码块给类初始化
static
{
System.out.println("a");
}
//构造代码块给对象初始化
{
System.out.println("c");
}
// 给传值的对象初始化
StaticCode(int x)
{
System.out.println(x);
}
}


class  StaticCodeDemo
{
public static void main(String[] args) 
{
StaticCode t = new StaticCode(6);
}
}
输出结果为:
a
c
6