-----------android培训、java培训、java学习型技术博客、期待与您交流!------------
在此,分享一下自己学习JAVA的学习心得。有不对的地方请帮忙改正,也希望对想学java的同学有帮助!
JAVA语言-----面向对象
面向对象的概念:
面向对象和面向过程都是一种思想,面向对象是相对面向过程而言的。面向过程是强调功能行为,而面向对象是将功能分装进对象,强调具备了功能的对象。面向对象基于面向过程的。
面向对象的特点:
面向对象的特征:封装(encapsulation)、继承(inheritance)、多态(polymorphism)。
类与对象的关系:
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();//使用对象的功能
}
}
知识点:匿名对象:是对象的简化形式。
面向对象(封装)
构造函数:
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(静态)
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方法
}
}
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);//实例化对象,并设置属性
}
}
实例变量和类变量的区别:
(1)存放位置:类变量随着类的加载而存在于方法区中; 实例变量随着对象的建立而存在于堆内存中。
(2)生命周期: 类变量生命周期最长,随着类的消失而消失; 实例变量生命周期随着对象的消失而消失。
静态利弊:利处:对对象的共享数据进行单独空间的存储,节省空间。没有必要每一个对象中都存储一份,可以直接被类名调用。
弊端:生命周期过长。访问出现局限性。(静态虽好,只能访问静态。)
什么时候使用静态变量和方法:
1、当对象中出现共享数据时,该数据被静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中。
2、当功能内部没有访问到非静态数据(对象的特有数据),那么该功能可以定义成静态的。
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();
}
}
注:静态成员变量除了可以被对象调用外,还可以直接被类名调用。格式:类名.静态成员变量。
虽然可以通过建立ArrayTool的对象使用这些工具方法,对数组进行操作。发现了问题:
1,对象是用于封装数据的,可是ArrayTool对象并未封装特有数据。
2,操作数组的每一个方法都没有用到ArrayTool对象中的特有数据。
这时就考虑,让程序更严谨,是不需要对象的。可以将ArrayTool中的方法都定义成static的。直接通过类名调用即可。
将方法都静态后,可以方便于使用,但是该类还是可以被其他程序建立对象的。为了更为严谨,强制让该类不能建立对象。可以通过将构造函数私有化完成。
Java代码如下:
<pre name="code" class="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;x<arr.length;x++)
{
if(arr[x]>arr[max])
max = x;
}
return arr[max];
}
/**
获取整形数组中的最小值。
@param arr 接受一个int类型的数组
@return 返回该数组中的最小值。
*/
public static int getMin(int[] arr)
{
int min = 0;
for(int x=1;x<arr.length;x++)
{
if(arr[x]<arr[min])
min = x;
}
return arr[min];
}
/**
给int数组进行选择排序
@param arr 接受一个int类型的数组
*/
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);
}
}
}
printArray(arr);
}
/**
给int数组进行冒泡排序
@param arr 接受一个int类型的数组
*/
public static void bubleSort(int[] arr)
{
for(int x=0; x<arr.length;x++)
{
for(int y=0; y<arr.length-x-1;y++)
{
if(arr[y]>arr[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<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+", ");
else
System.out.println(arr[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);*/
}
}
静态代码块:
<pre name="code" class="java"><pre name="code" class="java">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];