黑马程序员_java面向对象(一)

                                         ------- android培训、java培训、期待与您交流！ ----------

一：构造函数

       特点：

           ①函数名与类名相同

           ②不用定义返回值类型

           ③不可以些return语句

       作用：

            给对象进行初始化(对象一建立就会调用与之对应的构造函数)

       注意：

           ①多个构造函数是以重载的形式存在的

           ②当一个类中没有定义构造函数时,系统会默认给类加一个空参数构造函数

           ③当在类中自定义了构造函数,默认的构造函数就没有了

       构造函数和一般函数在写法上与不同,在运行上也有不同：

           ①构造函数是在对象一建立就运行,给对象初始化,而一般方法是对象调用才执行

           ②一个对象建立,构造函数只运行一次,而一般函数可以被对象调用多次

二：构造代码块

       作用：

            给对象初始化,对象一建立就运行,而且优先于构造函数执行

       和构造函数区别：

            构造代码块是给所有对象进行统一初始化,而构造函数是给对应的对象初始化

            构造代码块中定义的是不同对象共性的初始化内容

三：this关键字

       this代表它所在函数所属对象的引用,简单的说哪个对象在调用this所在的函数,this

       就代表哪个对象

 

       this语句：用于构造函数之间进行相互调用

       this语句只能定义在构造函数的第一行,因为初始化有优先执行

   

/*
  this语句： 用于构造函数之间互相调用
  this语句只能定义在构造函数的第一行,因为初始化要优先执行
*/

class Person
{
	private int age;
	private String name;

	Person(int age)
	{
		this.age=age;
	}

	Person(int age,String name)
	{	
		//this.age=age;
		this(age);   //this 语句    即相当于  p(25)
		this.name=name;
	}

	public void speak()
	{
		System.out.println("age="+age+"  name="+name);
	}
}


class  Test2
{
	public static void main(String[] args) 
	{
		Person p=new Person(25,"lilei");
		p.speak();		
	}
}

 

四：static关键字

       静态使用注意事项：

           ①静态方法只能访问静态成员

           ②非静态方法既可以访问静态也可以访问非静态

           ③静态方法中不可以定义this,super关键字,因为静态优先于对象存在,所以静态不可以出现this

 

       静态什么时候使用：

           ①什么时候定义静态变量

              当对象中出现共享数据时,该数据被静态所修饰,对象中的持有数据要定义成非静态存在于堆

              内存中

           ②什么时候定义静态函数

              当功能内部没有访问到非静态数据那么该功能可以定义成静态的         

class StaticCode
{
	private String name="haha";
	//构造函数
	StaticCode()
	{
		System.out.println("a");
	}

	//静态代码块  (只要该类被加载就执行,而且只执行一次)
	static
	{
		System.out.println("b");
	}

	//构造代码块  (只要对象一创建就执行 优先于 构造函数)
	{
		System.out.println(this.name);
	}

	//构造函数
	StaticCode(String a)
	{
		System.out.println("d");
	}
}

class StaticDemo
{
	public static void main(String[] args)
	{
		new StaticCode("ab");  //输出：b  haha  d
 
		//new StaticCode();  //输出： b  c  a
		//System.out.println("--------");
		//StaticCode s=new StaticCode(5);//输出：c  d  
		//System.out.println("--------");
		//StaticCode s1=new StaticCode();//输出：c  a
	}
}

 五：java程序帮助文档的制作(javadoc命令)

class Help
{
	public static void main(String[] args)
	{
		int[] arr={3,25,23,65,20,11,22};
		int max=SortHelp.getMax(arr);
		System.out.println(max);
        
		SortHelp.printArr(arr);
		SortHelp.selectSort(arr);
		SortHelp.printArr(arr);
	}
}

/**
  这是一个进行数组相关操作的工具类,有查找最大值、最小值
  利用选择、冒泡方法来排序的方法和打印出数组的方法

  @author  bruthe
  @version  v1.0

*/

//生成帮助文档的类的权限必须的最大的  所以必须是public
public class SortHelp
{
	/**
	  这里对构造函数进行了私有化,使得该类不能被对象化
	*/
	private SortHelp()
	{
	}
	
	/**
	  这个函数的功能是输出数组的最大值
	  @param  arr  接受一个整形数组	
	   @return 返回一个数组的最大值
	*/
	public static int getMax(int[] arr)
	{
		int max=0;
		for(int x=0;x<arr.length-1;x++)
		{
			if(arr[x]>arr[max])
			max=x;
		}
		return arr[max];
	}

	/**
	  这个函数的功能是输出数组的最小值
	  @param  arr  接受一个整形数组	
	  @return 返回一个数组的最小值
	*/
	public static int getMin(int[] arr)
	{
		int min=0;
		for(int x=0;x<arr.length-1;x++)
		{
			if(arr[x]<arr[min])
			min=x;
		}
		return arr[min];
	}

	/**
	  这个函数的功能是利用选择排序的方法对数组进行排序
	  @param  arr  接受一个整形数组	
	*/
	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);
				}
			}
		}
	}

	/**
	  这个函数的功能是利用冒泡排序的方法对数组进行排序
	  @param  arr  接受一个整形数组	
	*/
	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);
				}
			}
		}
	}

	/**
	  这个函数的功能是对数组中的两个元素进行交换位置
	  @param  arr  接受一个整形数组	
	  @param  a    要交换位置的元素
	  @param      要交换位置的元素
	*/
	private static void swap(int[] arr,int a,int b)
	{
		int temp=arr[a];
		arr[a]=arr[b];
		arr[b]=temp;
	}
	
	/**
	  这个函数的功能打印出已知数组
	  @param  arr  接受一个整形数组	
	*/
	public static void printArr(int[] arr)
	{
		System.out.print("{");
		for(int x=0;x<arr.length-1;x++)
		{
			if( x!=arr.length-1 )
			{
				System.out.print(arr[x]+", ");
			}else
			{
				System.out.println(arr[x]);
			}			
		}
		System.out.print("}");
		System.out.println();
	}
}

   程序运行过程及结果：

   javadoc    -d  myhelp  -a  author  -v version  SortHelp.java

   这样程序就会在当期目录下生成 myhelp文件的关于SortHelp程序帮助文档

六：继承及抽象类

      因为父类的数据子类可以直接获取,所以子类对象在建立时,需要先查看父类是如何对这些数据进行

      初始化的,所以子类在对象初始化时,要先访问一下父类中的构造函数

 

       如果要访问父类中指定的构造函数,可以通过手动定义super语句的方式来指定

      注意：super语句一定定义在子类构造函数的第一行

      结论：
           ①子类的所有的构造函数,默认都会访问父类中空参数的构造函数
               因为子类每一个构造函数内的第一行都有一句隐私super()

            ②当父类中没有空参数的构造函数时,子类必须手动通过super或者this语句形式来指定要访问

               的构造函数

           ③子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数
              子类中至少会有一个构造函数会访问父类中的构造函数

七：抽象类

       当多个类中出现相同功能,但是功能主题不同
       这时可以进行向上抽取,只抽取功能定义而不抽取功能主体

 

      抽象类的特点：
           ①抽象方法一定在抽象类中
           ②抽象方法和抽象类都由abstract关键字所修饰
           ③抽象类不可以用 new 创建对象,因为调用抽象方法没有意义
           ④抽象类中的抽象方法要被使用,必须由子类复写所有抽象方法后,再建立子类对象去调用
               如果子类只覆盖了部分抽象方法,那么该子类还是一个抽象类
               所以抽象类的子类必须全部复写该抽象类的全部抽象方法
           ⑤抽象类中也可以有非抽象方法
           ⑥抽象类是不可以实例化的(abstract只修饰类和方法)

abstract class Student
{
	//abstract不能和static一起修饰
	abstract  void study();
	abstract  void study1();
	void show()
	{
		System.out.println("show show ");
	}
}

class BaseStudent extends Student
{
	//抽象类的子类必须全部复写该抽象类的全部抽象方法
	void study()
	{
		System.out.println("base student");
	}

	void study1()
	{
		System.out.println("base1 student");
	}
}

class AdvStudent extends Student
{
	void study()
	{
		System.out.println("advanced student");
	}
	void study1()
	{
		System.out.println("advanced1 student");
	}
}

class AbstractDemo
{
	public static void main(String[] args)
    {
		AdvStudent a=new AdvStudent();
		a.study();  //程序输出： advanced student
	}
}

 八：final及接口

        final：最终,作为一个修饰符

        ① 可以修饰类、函数、变量
        ② 被final修饰的类不可以被继承
             为了避免被继承,被子类复写功能  可以在类前添加 final
        ③被final修饰的方法不可以被复写
        ④被final修饰的变量是一个常量 只能赋值一次,既可以修饰成员变量,也可以修饰局部变量
            final int y=4;          y=4;(错误的,只能赋值依次)

 

        接口：不可以创建对象,因为接口中有抽象方法
                  子类需要对接口中的所有方法进行覆盖后,子类才可以实例化,否则子类还是一个抽象类
 
        类可以实现多个接口,即java支持 "多实现"     接口间可以有继承关系  接口可以多继承
        class 修饰类   interface修饰接口(特殊的类)

interface InfA
{
	public static final int NUM=3;
	public abstract void show();
}

class Test implements InfA
{
	public void show()
	{
	}
}

class InterfaceDemo
{
	public static void main(String[] args)
	{
		Test t=new Test();
		System.out.println(t.NUM);     //输出：3
		System.out.println(Test.NUM);  //输出：3
		System.out.println(InfA.NUM);  //输出：3
	}
}

interface A
{
	public abstract void show1();
}
interface B
{
	public abstract void show2();
}

//接口间也是可以继承的  接口是可以进行多继承的,但是类不行
interface C extends A,B
{
}

 

                                       ------- android培训、java培训、期待与您交流！ ----------