java oop

時間 2019-11-21

標籤 java oop 欄目 Java 简体版

原文原文鏈接

一：oop 面向對象：java

剛開始學編程語言的時候，習慣過程編程，就象寫shell的時候也是用命令進行堆疊。可是這種若是修改起來比較麻煩，過一陣子，開始用函數式編程。python

可是也不方便，尤爲是在功能複雜的時候，寫的函數比較多，改起來也比較麻煩，也很差定位。到最終接觸到oop即面向對象編程。起初接觸oop的時候，感受一臉懵逼狀態。感受本身的不會寫代碼。linux

歸其緣由是：以前是函數調用，而oop是經過對象進行調用。在調用以前先初始化類的對象（在python裏叫作構造方法，在java裏是構造器），而後經過對象來調用類中的方法。shell

java是面向對象的編程語言，一切同類來實現。而python不是。編程

因此在oop是java的基礎。一切借對象，如同linux 一切皆文件！！dom

由類構造的對象的過程叫作建立類的對象的過程。編程語言

java中全部的代碼的編寫都在某個類中。在oop中編程中，沒有頂部的概念，在過程化編程中，從main方法開始進行編程，一次編寫本身的方法，在類中沒有這個所謂的頂部，用戶根據項目編寫不一樣的類型，在main方法中進行實例化對象進行方法的調用。函數式編程

 1 class Student{
 2     String Deatil(String x,String y){
 3         String sex=x;
 4         String name=y;
 5         return sex+' '+name;
 6     }
 7 }
 8 
 9 public class Main {
10 
11     public static void main(String[] args) {
12     // write your code here
13         Student stu=new  Student();
14         String ret=stu.Deatil("男","evil");
15         System.out.println(ret);
16 
17     }
18 }

類的特性：封裝、繼承、非多態。函數

封裝：也叫作數據隱藏。oop

從形式上來看：封裝不過是將數據和行爲組合在一個包中，並對對象的使用者隱藏了數據的實現方式。

實例域：對象中的數據稱爲實例域。

方法：操縱數據的過程叫作方法。

對於特定的類實例（對象），都有特定的實例域值。這些值的集合就是對象的狀態。

封裝的原則：絕對不能讓類中的方法直接訪問其餘類的實例域！程序僅經過對象方法與對象的數據進行交互。

繼承：面向對象的另外一個特性，能夠經過擴展一個類來創建另外一個新的類。在java中的類都是源自object。

新擴展的類有繼承的類全部方法和屬性，新類還能夠定義本身的方法和屬性。

二對象

對象的三大特性：

狀態--->每一個對象都保存着描述當前特徵信息。對象的狀態的改變一定是經過方法調用的行爲來實現。

標識--->每個對象都有一個惟一的身份。好比：我在京東上下的2次訂單，他們的訂單號就是不同。

行爲-->具備哪些方法調用。

這三個特性都彼此相互影響，當對象的狀態發生變化，他可調用的方法也不同，好比訂單：處於配送狀態！

就不可使用退貨或者修改訂單地址。反之，若是你的訂單對象空的（null）的話，那就沒有配送等狀態！

三：類之間的關係

1：繼承：「is-a」新類B繼承A類的方法，又擴展新的方法。

2：依賴："uses-a" 類之間的存在調用關係。好比A類的對象調用B類的對象。

3：聚合:"has-a" A類包含B類。

四：預約義類

java 是oop編程，可是並非全部的類都有面向對象的特徵，好比說Math 類，咱們不比初始化對象，能夠直接進行調用。

 1 class Student{
 2     double Deatil(){
 3         double re=Math.random();
 4 
 5         return re;
 6     }
 7 }
 8 
 9 public class Main {
10 
11     public static void main(String[] args) {
12         // write your code here
13         Student stu=new  Student();
14         double ret=stu.Deatil();
15         System.out.println(ret);
16 
17     }
18 }

五：方法的調用

調用類的方法，是經過類的對象來進行調用。經過對象調用類的方法。（靜態方法能夠用類進行調用）。

初始化類的對象，須要類的構造器初始化，構造器和類的名字同樣。構造對象須要加關鍵new。（外部引用數據須要關鍵new，內部數據（四項八類不須要關鍵字new））

 1 import java.util.Date;
 2 
 3 class Student{
 4     Date Deatil(){
 5         Date re=new Date();
 6 
 7         return re;
 8     }
 9 }
10 
11 public class Main {
12 
13     public static void main(String[] args) {
14         // write your code here
15         Student stu=new  Student();
16         Date ret=stu.Deatil();
17         System.out.println(ret);
18 
19     }
20 }

注意：

1：對象和對象變量：以下

 1 import java.util.Date;
 2 
 3 class Student{
 4     String Deatil(){
 5         Date re;
 6         re=re.toString();
 7         Date ret=new Date();
 8         return re;
 9     }
10 }

如上；咱們定義一個變量Date類型變量re，可是並無初始化。因此在引用Date的方法的時候會報錯。

對象變量和對象是不同，只有對象變量進行初始化以後，對象變量才能引用對象的方法。不然報對象未進行初始化。

2：對象的變量只是引用對象而已，而不是包含對象！在java中任何對象變量的值，都是對存儲在另外一個地方的對象引用，new操做符，只是返回該對象的一個引用值。

1  Date ret=new Date();

咱們能夠用null表示對象變量沒有引用對象。

六：訪問器和更改器

訪問器：像一些類中的get方法，只是訪問對象的狀態信息，並不作對象的狀態的更改叫作訪問器。

更改器：像一些類中的add、del等方法，更改對象的狀態信息的方法叫作更改器。

一般在訪問器的方法在前綴加get字樣，更改器也是同樣。。。

 1 import java.util.GregorianCalendar;
 2 import java.util.Date;
 3 
 4 class Student{
 5     Date Deatil(){
 6         GregorianCalendar re=new  GregorianCalendar();
 7         return re.getTime();
 8 
 9 
10     }
11 }
12 
13 public class Main {
14 
15     public static void main(String[] args) {
16         // write your code here
17         Student stu=new  Student();
18         Date ret=stu.Deatil();
19         System.out.println(ret);
20 
21     }
22 }

Date和CregorianCalendar轉換

 1 import java.util.GregorianCalendar;
 2 import java.util.Date;
 3 
 4 class Student{
 5     Date Deatil(){
 6         GregorianCalendar re=new  GregorianCalendar();
 7         return re.getTime();
 8 
 9 
10     }
11 }
12 
13 public class Main {
14 
15     public static void main(String[] args) {
16         // write your code here
17         Student stu=new  Student();
18         Date ret=stu.Deatil();
19         Get_Year get_y=new Get_Year();
20         int year=get_y.get_Year(ret);
21         System.out.println(ret);
22         System.out.println(year);
23 
24     }
25 }
26 class  Get_Year{
27     int get_Year(Date X){
28         GregorianCalendar cal=new GregorianCalendar();
29         cal.setTime(X);
30         return cal.get(cal.YEAR);
31     }
32 }

注意的是：日曆的獲取月份的時候，比當前的月份少1.

 1 import java.util.GregorianCalendar;
 2 import java.util.Date;
 3 
 4 class Student{
 5     Date Deatil(){
 6         GregorianCalendar re=new  GregorianCalendar();
 7         return re.getTime();
 8 
 9 
10     }
11 }
12 
13 public class Main {
14 
15     public static void main(String[] args) {
16         // write your code here
17         Student stu=new  Student();
18         Date ret=stu.Deatil();
19         Get_Year get_y=new Get_Year();
20         int year=get_y.get_Year(ret);
21         Get_M get_m=new Get_M();
22         int month=get_m.get_M(ret);
23         System.out.println(ret);
24         System.out.println(year);
25         System.out.println(month);
26 
27     }
28 }
29 class  Get_Year{
30     int get_Year(Date X){
31         GregorianCalendar cal=new GregorianCalendar();
32         cal.setTime(X);
33         return cal.get(cal.YEAR);
34     }
35 }
36 class  Get_M{
37     int get_M(Date X){
38         GregorianCalendar cal=new GregorianCalendar();
39         cal.setTime(X);
40         return cal.get(cal.MONTH);
41     }
42 }

獲取當前時間戳：

 1 import java.util.Date;
 2 import java.text.SimpleDateFormat;
 3 public class Main {
 4 
 5     public static void main(String[] args) {
 6         // write your code here
 7         Student stu=new  Student();
 8         Date ret=stu.Deatil();
 9         SimpleDateFormat fomate=new  SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
10         String str=fomate.format(ret);
11         System.out.println(str);
12 
13     }
14 }
15 
16 2017-10-04 00:50:31