黑马程序员 Java基础<三>--->面向对象

--------------android培训、java培训、学习型技术博客、期待与您交流！ --------------

1）面向对象概念：

      面向对象是一种软件开发思想。由于现实社会是由各种各样的事物所组成的，而我们编程又是在模拟现实社会，那么在程序中也要用一些东西来表示现实社会中的事物，这些东西就是程序中的对象。我们在程序中使用这些对象，对其特征和行为进行操作进行编程，这就是面向对象编程。

     类和对象：

          类：对现实世界中某类事物的描述,是抽象的，概念上的定义。

          对象：事物具体存在的个体

            类和对象的关系 ：对象是类的实例，类是对象的抽象。

 2）  面向对象特征：封装，抽象，继承，多态

         封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式。代码具有优良的模块性，实现高内聚，低耦合

     抽象：找出事物的共同之处，然后将其归为一类。

     继承：利用继承可以在原有的类的基础上创建新的类,并可以直接使用原有的类的方法和属性,这样要比重新建新类要简单的多.利用继承可以减少相似类的重复创建. 一个类用final修饰，则这样的类成为最终的类，有final修饰的类不可以被继承。

     多态 ：一个对象在程序不同运行时刻代表的多种状态，父类或者接口的引用指向子类对象，提高代码复用性，类与类之间产生关系。

           成员函数在多态调用时，编译看左边，运行看右边。

           多态中成员变量无论编译和运行，都参考左边（引用变量所属的类）。如：多态中的父类引用调用成员变量时，如果父类和子类有同名的成员变量，那么被调用的是父类中的成员变量。

class Fu 
{
        int i = 3; 
       public void test(){
        	int b=5;
        	System.out.println(b);
        }

}
class Demo extends Fu
{
         int i = 13;//成员变量
         
         public void test(){
         	int b=14; //局部变量
         	System.out.println(b);
         }
        public static void main(String[] args) 
        {
        	   
        	Fu d=new Demo();     //类型提升，向上转型
            System.out.println(d.i); //3
            d.test();   //14
        }
}

         权限大小

成员修饰符     public       protected          default(默认)            private

同一个类中       OK               OK                    OK                     OK

同一个包中       OK               OK                    OK                     NO

子类访问           OK               OK                    NO                     NO

不同包中           OK               NO                    NO                     NO

3)  构造代码快

          构造代码块中定义的是不同对象共性的初始化内容。
             作用：给对象进行初始化。
             对象一建立就运行，而且优先于构造函数执行。
             和构造函数的区别：
              构造代码块是给所有对象进行统一初始化，
              而构造函数是给对应的对象初始化。
              构造代码快中定义的是不同对象共性的初始化内容。

class Person
{
	private String name;
	private int age;
        //构造代码块	
	{
		//System.out.println("person code run");
		cry();
	}

	Person()
	{
		System.out.println("A: name="+name+",,age="+age);
		
	}
	/**/
	Person(String n)
	{
		name = n;
		System.out.println("B: name="+name+",,age="+age);

		//cry();
		
	}
	/*
	public void setName(String n)
	{
		name  = n;
	}
	public String getName()
	{
		return name;
	}
	*/
	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......");
	}
}

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

		

		Person p2 = new Person("lisi");
	
		//System.out.println(p2.getName());

		//Person p3 = new Person("wnagu",10);
	
		
	}
}

 

4)this与super关键字

            this:   a)指代当前对象，当局部变量和成员变量同名时，可以通过this关键字的用法来区分。

           b)在构造方法中来调用该类的其它构造方法，这是要求this语句必须 

            super:用于子类构造函数的第一条语句。目的是调用父类的构造函数。若子类没有加super，程序会默认调用父类无参的构造函数。

class Fu //extends Object
{
	int num ;
	Fu()
	{
		//super();
		num= 60;
		System.out.println("fu run");
	}
	Fu(int  x)
	{
		System.out.println("fu ...."+x);
	}
	
}

class Zi extends Fu
{
	Zi()
	{
		
		super();  
		//super(4);
		System.out.println("zi run");
	}
	Zi(int x)
	{
		this();
		//super();
		//super(3);
		System.out.println("zi..."+x);
	}
}

public class  ExtendsDemo4
{
	public static void main(String[] args) 
	{
		Zi z = new Zi(0);
		System.out.println(z.num);
	}
}

5)static关键字

             static关键字用来修饰类的成员，被这个关键字修饰的成员都和类加载有关。随类加载，只加载一次。

static代码块

class  Demo
{
	//static int i = 1;相当于：
	static int i;
	static{
		i = 1;	
	}
	static{
		System.out.println(i);
	}
}

 

 对象创建过程

 

               Person  p = new Person("zhangsan")      

                   a、把类名.class文件加载到内存中。

                   b、执行该类中的static代码块，如果有得话，给该类进行初始化。

                   c、在堆内存中开辟空间，分配内存地址。给对象

                  d、在堆内存中建立对象的特有属性。并进行默认初始化。

                  e、对属性进行显示初始化。

                  f、对对象进行构造代码块初始化。

                  g、对对象进行对应构造函数初始化。

                  h、将内存地址赋给栈内存中的对象名变量。

 

单例设计模式

         保证在整个程序中某个类只能存在一个对象，这个类不能再创建第二个对象。

 

饿汉式：在类一加载就会创建对象，（建议使用）

class Single
{
	private static final Single s = new Single();
	private Single(){}
	public static Single getInstance()
	{
		reture s;
	}
}

*/
//懒汉式   延迟加载的单例设计模式，在调用getIntance()方法时创建对象
class Single
{
	private static Single s = null;
	private Single(){}

	public static synchronized Single getInstance()
	{
		if(s==null)

		    s = new Single();
		
		return s;
	}
}<SPAN style="FONT-SIZE: 14px">      </SPAN>

内部类

      1）当内部类定义在外部类的成员位置上  ，建立内部类对象格式

                    外部类名.内部类名  变量名 =外部类对象.内部类对象

                     如 Outer.Inner in =new Outer().new Inner();

                     可以被成员修饰符所修饰。比如private，static           

           注意：

                 a） 当内部类中定义了静态成员时，该内部类必须是 static 的。

                 b） 当外部类中的静态方法访问内部类时，内部类也必须是 static 的。

                 c） 在实际应用中，内部类通常被定义为 private ，而很少定义为 public 。

     2)    内部类定义在局部,不可以被成员修饰符修饰。如public、private、static

              注意：内部类不可以访问它所在的局部中非最终变量。只能访问被 final修饰的局部变量。

     class Outer
{
	int x = 3;

	void method(final int a)
	{
		//方法中内部类访问的局部变量要用final修饰
		final int y = 4;
		class Inner
		{
			//定义内部类
			void function()
			{
				System.out.println(y);
				System.out.println(a);
			}
		}
	
		new Inner().function();
	}
}
class  InnerClassDemo3
{
	public static void main(String[] args) 
	{
		Outer out = new Outer();
		out.method(7);
		out.method(8);
	}
}

        

--------------android培训、java培训、学习型技术博客、期待与您交流！ --------------