--------------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
2) 內部類定義在局部,不可以被成員修飾符修飾。如public、private、static
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培訓、學習型技術博客、期待與您交流！
--------------
