黑马程序员 JAVA-面向对象（一）
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
在此，分享一下自己学习JAVA的学习心得。有不对的地方请帮忙改正，也希望对想学java的同学有帮助！
JAVA语言-----面向对象
面向对象的概念：
面向对象和面向过程都是一种思想，面向对象是相对面向过程而言的。面向过程是强调功能行为，而面向对象是将功能分装进对象，强调具备了功能的对象。面向对象基于面向过程的。
面向对象的特点：
（1）是一种符合人们思考习惯的思想；
（2）可以将复杂的事情简单化；
（3）将程序员从执行者转化成了指挥者；
（4）完成需求时：先要去找具有所需功能的对象来用；如果该对象不存在，那么创建一个具有所需功能的对象；这样简单开发并提高复用。
面向对象的特征：封装（encapsulation）、继承（inheritance）、多态（polymorphism）。
类与对象的关系：
Java中描述事物通过类的形式体现，类是具体事物的抽象，对象时该类事物实实在在存在的个体。
生活中描述事物无非就是描述事物的属性和行为，而Java中用class来描述事物也是如此：
（1）属性：对应类中的成员变量。
（2）行为：对应类中的成员函数。
定义类其实在定义类中的成员（成员变量和成员函数）。
注：成员变量和局部变量的区别？
成员变量：成员变量定义在类中，在整个类中都可以被访问。成员变量随着对象的建立而建立，存在于对象所在的堆内存中。成员变量有默认初始化值。
成员函数：局部变量只定义在局部范围内，如：函数内、语句内等；局部变量存在于占内存中；其作用的范围结束，变量空间会自动释放；局部变量没有默认初始化值。
Java练习代码：
class Car
{
String color = "red";//定义车子颜色
int num = 4;//定义车轮数量
void show()//定义一个show方法
{
System.out.println("color="+color+".."+"num="+num);//打印颜色和数量
}
}
class CarDemo
{
public static void main (String args[])
{
Car c = new Car( ) ;//实例化一个对象
c.color = "black";//对对象的属性进行修改
c.show()；//使用对象的功能
}
}知识点：匿名对象：是对象的简化形式。
匿名对象的使用情况：当对对象方法仅进行一次调用时；匿名对象作为实际参数进行传递时。
面向对象（封装）
封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：（1）将变化隔离；
（2）便于使用；
（3）提高复用性；
（4） 提高安全性。
封装原则：将不需要对外提供的内容都隐藏起来；把属性都隐藏，提供公共方法对其访问。
构造函数：
特点：（1）函数名与类名相同；（2）不用定义返回值类型；（3）不可以写return语句。
作用：给对象进行初始化。
注：（1）默认构造函数的特点;(2)多个构造函数是以重载的形式存在的。
java练习代码：
person (String name,int age)为类Person构造函数。
class Person
{
private String name;
private int age;
Person (String name ,int age)
{
this.name = name;//this代表对象p
this.age =age;
speak();
}
public void speak ()//定义一个speak方法
{
System.out.println("name="+name+".."+"age="+age);
}
}关键字：private（私有）、this、static（静态）
private关键字：是一个权限修饰符，用于修饰成员（成员变量和成员函数）。其中被私有化的成员只在本类中有效。
常用之一：将成员变量私有化，对外提供对应的set ,get 方法对其进行访问。提高对数据访问的安全性。
Java练习代码：
class person
{
private String name;//姓名
private int age;//年龄
private String sex;//性别
person(String name,String sex,int age)//构造函数
{
this.name = name;
this.sex = sex;
this.age = age;
}
public void speak()//方法，打印信息
{
System.out.println(this.name+" "+this.sex+" "+this.age);
}
}
class PersonDemo
{
public static void main(String[] args)
{
person p = new person();
p.name = "jolin";//设置姓名
p.sex = "woman";//设置性别
p.age = "36";//设置年龄
speak();//调用speak方法
}
}
this关键字特点：this代表其所在函数所属对象的引用。换言之，this代表本类对象的引用。
注：什么情况下使用this关键字？
当在函数内需要用到该函数的对象时，就用this。
Java练习代码：
class Person
{
private String name;
private int age;
Person (String name ,int age)
{
this.name = name;//this代表对象p
this.age =age;
speak();
}
public void speak ()
{
System.out.println("name="+name+".."+"age="+age);
}
}
class PersonDemo
{
public static void main(String[] args)
{
Person p = new Person("lina",36);//实例化对象，并设置属性
}
}
static关键字：是一个修饰符，用于修饰成员（成员变量和成员函数）。
被修饰后的成员具备以下特点：
（1）随着类的加载而加载；
（2）优先于对象存在；
（3）被所有对象所共享；
（4）可以直接被类名调用。
注：静态方法只能访问静态成员；
静态方法中不可以写this，super关键字(因为静态变量优先于对象存在)；主函数是静态的。
实例变量和类变量的区别：
（1）存放位置：类变量随着类的加载而存在于方法区中; 实例变量随着对象的建立而存在于堆内存中。
（2）生命周期： 类变量生命周期最长，随着类的消失而消失； 实例变量生命周期随着对象的消失而消失。
静态利弊：利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份，可以直接被类名调用。
弊端：生命周期过长。访问出现局限性。(静态虽好，只能访问静态。)
什么时候使用静态变量和方法：
1、当对象中出现共享数据时，该数据被静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中。
2、当功能内部没有访问到非静态数据(对象的特有数据)，那么该功能可以定义成静态的。
Java练习代码：
class Person
{
String name;
static String country = "CN";//country被静态修饰，被p和p1共享；
public void show()
{
System.out.println("name="+name+"..."+"country="+country);
}
}
class PersonDemo2
{
public static void main(String[] args)
{
Person p =new Person();//实例化一个p对象
p.name = "lina";
p.show();
Person p1 =new Person();//实例化一个盘对象
p1.name = "zhangguoli";
p1.show();
}
}
用上一个例子做示例：System.out.println(person.country);
静态的应用：
每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装。以便复用。
虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。发现了问题：
1，对象是用于封装数据的，可是ArrayTool对象并未封装特有数据。
2，操作数组的每一个方法都没有用到ArrayTool对象中的特有数据。
这时就考虑，让程序更严谨，是不需要对象的。可以将ArrayTool中的方法都定义成static的。直接通过类名调用即可。
将方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的。为了更为严谨，强制让该类不能建立对象。可以通过将构造函数私有化完成。
Java代码如下：
虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。发现了问题：
1，对象是用于封装数据的，可是ArrayTool对象并未封装特有数据。
2，操作数组的每一个方法都没有用到ArrayTool对象中的特有数据。
这时就考虑，让程序更严谨，是不需要对象的。可以将ArrayTool中的方法都定义成static的。直接通过类名调用即可。
将方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的。为了更为严谨，强制让该类不能建立对象。可以通过将构造函数私有化完成。
Java代码如下：
/**
这是一个对数组进行操作的工具类，该类中提供了获取最值、排序等功能。
@author 宋泽文
@version V1.0
*/
public class ArraysTool
{
private ArraysTool(){}
/**
获取整形数组中的最大值。
@param arr 接受一个int类型的数组
@return 返回该数组中的最大值。
*/
public static int getMax(int[] arr)
{
int max = 0;
for(int x=1;xarr[max])
max = x;
}
return arr[max];
}
/**
获取整形数组中的最小值。
@param arr 接受一个int类型的数组
@return 返回该数组中的最小值。
*/
public static int getMin(int[] arr)
{
int min = 0;
for(int x=1;xarr[y])
{
swap(arr,x,y);
}
}
}
printArray(arr);
}
/**
给int数组进行冒泡排序
@param arr 接受一个int类型的数组
*/
public static void bubleSort(int[] arr)
{
for(int x=0; xarr[y+1])
{
swap(arr,y,y+1);
}
}
}
printArray(arr);
}
/**
给数组中的元素进行位置的置换。
@param arr 接受一个int类型的数组。
@param a 要置换的位置
@param b 要置换的位置
*/
private static void swap(int[] arr,int a,int b)
{
int temp =arr [a];
arr[a] =arr[b];
arr[b] =temp;
}
/**
用于打印数组中的元素，打印形式[element1, element2,..]
*/
public static void printArray(int[] arr)
{
System.out.print("[");
for(int x=0;x
class ArraysToolDemo
{
public static void main(String[] args)
{
int[] arr = {1,5,8,0,9};
int max = ArraysTool.getMax(arr);//直接用类名调用
System.out.println("max="+max);
int min = ArraysTool.getMin(arr);//直接用类名调用
System.out.println("min="+min);
ArraysTool.selectSort(arr);
ArraysTool.bubleSort(arr);
/*
ArraysTool tool= new ArraysTool();
int max = tool.getMax(arr);
System.out.println("Max="+max);
int min = tool.getMin(arr);
System.out.println("Min="+min);
tool.bubleSort(arr);
tool.selectSort(arr);*/
}
}
静态代码块：
格式：
static
{
静态代码块的执行语句
}
静态代码块的特点：随着类的加载而执行，只执行一次，并优先于主函数执行。用于给类进行初始化。
class StaticCode
{
static//静态代码块‘a’
{
System.out.print('a');
}
}
class StaticCodeDemo
{
static//静态代码块‘b’
{
System.out.print('b');
}
public static void main(String[] args) //main函数
{
new StaticCode();
System.out.println("Hello World!");
}
static//静态代码块‘c’
{
System.out.print('c');
}
}
输出结果：bcaHello Word！
知识点：
主函数：
主函数是一个特殊的函数。作为程序的入口，可以被jvm调用。
public：代表着该函数访问权限是最大的。
static：代表主函数随着类的加载就已经存在了。
void：主函数没有具体的返回值。
main：不是关键字，但是是一个特殊的单词，可以被jvm识别。
（String[] arr）:函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。
主函数是固定格式的是为了jvm识别。jvm在调用主函数时，传入的是new String[0];