Java 學習筆記（2015.7.13~17）
Java 學習筆記（2015.7.13~17）
Java
this關鍵字
表示本類中的屬性，調用本類中的方法
class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;//調用本類中的屬性
this.age = age;//同上} //get&set方法：
public String getName() {
return name; }
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void tell() {
System.out.println("姓名："+this.getName()+"年齡："+this.getAge());
}
}調用構造方法
調用時必須寫在構造方法的第一行。
public Person(String name, int age) {
this();
//調用無參數構造方法
this.name = name;
this.age = age;
}
public Person() {
System.out.println(""無參數構造方法);
}表示當前對象
舉個栗子：
class Person {
public void tell() {
System.out.println(this);
}
}
public static void main(String args[]) {
Person p1 = new Person();
System.out.println(p1);
p1.tell();
}輸出的結果是一樣樣的，這裏this引用了當前對象也就是自己。
搭建Android開發集成環境
離線版Android SDK ，IDEA
day06
棧內存中保存的是堆內存空間的訪問地址。
封裝性，用private保護起來，不讓外部直接訪問，一般使用setter&getter方法獲得屬性。
String 兩種實例化方法的區別。
直接賦值，生成一個匿名對象。
標準的new構造方法
使用直接賦值即匿名對象的優勢：如果一個字符串已經被一個對象引用，則以後再有相同的字符串聲明時，就不會再重新開闢空間。
比較下面兩個程序
1
public class Test1 {
public static void main(String args[]) {
String str1 = "hello";
System.out.println("fun()方法調用之前：" + str1);
fun(str1);
System.out.println("fun()方法調用之後：" + str1);
}
public static void fun(String str2) {
str2 = "MLDN";
}
}輸出:
fun()方法調用之前：hello
fun()方法調用之後：hello
字符串的內容不可改變，修改字符串時實際上是new出了一個新字符串並改變了內存地址。形參指向了"MLDN"的內存地址。
2
class Demo {
String temp = "hello";
}
public class Test2 {
public static void main(String args[]) {
Demo d1 = new Demo();
d1.temp = "world";
System.out.println("fun()方法調用之前：" + d1.temp);
fun(d1);
System.our.prtinln("fun()方法調用之後：" + d1.temp);
}
public static void fun(Demo d2) {
d2.temp = "MLDN";
}
}輸出:
fun()方法調用之前：world
fun()方法調用之後：MLDN
本例修改的是對象的屬性！是堆內存對象內部的修改！ 哈哈哈，終於懂了
this關鍵字
表示類中的屬性
調用本類中的構造方法（必須寫在構造方法的第一行；構造方法間相互調用時 ）
表示當前對象
對象的比較
== 比較內存地址，equals比較內容。要想比較對象，必須比較其內容，若類中沒有重寫equals方法，則要比較其屬性內容。static關鍵字
static聲明的屬性叫做全局屬性或類屬性（類裏聲明的變量爲成員變量，方法裏聲明的變量爲局部變量）
static聲明的屬性是所有對象共享的，所以用
類名稱.static屬性的方式調用更好static聲明的方法叫做類方法，用類名引用
用static 聲明的方法，不會將對象的引用傳遞給它。講人話謝謝。
答：static聲明的方法不能調用非static的屬性和方法（門當戶對）。因爲程序中的所有屬性和方法必須在對象開闢開闢對內存後才能調用，而static類的方法在對象未被實例化時就可以用類名調用。因爲static屬性是類對象共有的，所以可以用來統計一個類生產了多少個實例化對象
day07
eclips快捷鍵
Alt+/ 自動聯想
1、代碼塊
1、普通代碼塊：直接在方法或語句中定義的代碼塊。
2、構造塊：構造代碼塊是直接寫在類中的代碼塊。
class Demo {
public Demo() {
System.out.println("2、構造方法。");
//定義構造方法
}
{System.out.println("1、構造塊");} //定義構造塊}
public class Test {
public static void main(String args[]) {
new Demo(); //實例化對象
new Demo();
new Demo();
}
}輸出：
1、構造塊
2、構造方法
1、構造塊
2、構造方法
1、構造塊
2、構造方法
可知構造塊優先於構造方法執行，而且每次實例化對象時都會執行。
3、靜態代碼塊：用static聲明的代碼塊
主方法所在類中的靜態代碼塊優先主方法執行，類中定義的靜態代碼塊優先於構造塊執行，而且靜態代碼塊只執行一次。
2、方法重載 overload
方法名相同，參數不同
Python使用位置參數，默認參數等處理
day08
1、package & import
注意：
使用系統中的類同樣需要import
java.lang包中的類可以直接使用，不需要導入
2、繼承 extends
條件：A 是一種 B ， class A extends B
一旦繼承，子類就自動擁有了父類中提供的成員變量以及方法
（構造方法除外）
注意： java只支持單繼承
3、訪問控制
| 修飾符 | 類本身 | 包中 | 繼承 | 其他 |
|---|---|---|---|---|
| private | YES | NO | NO | NO |
| default/package | YES | YES | NO | NO |
| protected | YES | YES | YES | NO |
| public | YES | YES | YES | YES |
public 或者 default修飾類（內部類除外）
注意： 一個源文件中只能有一個 public 修飾的類，並且這個類要與源文件同名。但是可以多個默認修飾的類
4、方法的重寫 override
前提：繼承
注意：
重寫的方法不能比被重寫的方法有更嚴格的權限控制
重寫方法必須和被重寫方法具有相同方法名稱、參數列表和返回類型
5、super
super:表示父類對象的引用
super():表示在子類中調用父類的構造方法
注意：創建出子類對象，必須先創建出它的父類對象
當this與super在一起的時候，兩個都要在第一行搞毛啊，所以讓super()使用隱式調用就好。
a、當子類跟父類都沒有可見的構造方法時
super();必須放在子類構造方法中第一行
b、如果子類中沒有顯性調用super（），默認調用父類中
無參的構造方法
c、如果子類中沒有顯性調用super（），父類中存在有參
的構造方法時，程序將出錯
結合 this
6、對象轉型
一個父類的引用類型變量可以“指向”其子類的對象。
一個父類的引用不可以訪問其子類對象新增加的成員（變量，方法）
向上轉型：父類引用指向之類對象
向下轉型：必須要先向上轉型
day09
1、訪問控制
get set方法
2、Object 如果一個類沒有聲明繼承某個類，它就默認繼承Object。
所有的類都是Object的子類
HashCode：方便查找
toString 有快捷方法
equals
注意：
a、如果兩個對象相互equals，它們的hashCode肯定相同
b、如果它們的hashCode值相等，兩對象不一定相等，此時
還需查看equals方法之後才能確認
c、重寫equals一般都要重寫hashCode
d、當兩個對象equals後，它們的hashCode就相同了
e、hashCode()是一個快捷方式，比如比較10個對象，先比較它們的hashCode值，不同的直接pass，然後再用equals比較留下來的對象
3、多態（動態綁定，持綁定）
只有在運行時區判斷對象的實際類型
多態存在的三個必要條件
a、要有繼承
b、要有重寫
c、要有父類聲明指向子類實現 （向上轉型）
4、抽象類 abstract
a、用abstract修飾的方法，成爲抽象方法；
只有方法的聲明，沒有方法的實現
b、含有抽象方法的類必須聲明爲抽象類
c、抽象類就是給別人繼承的
d、抽象類是一個殘缺不全的類，不能實例化
e、抽象類除了有抽象方法之外，也還有普通方法
f、一個類繼承了抽象類，必須重寫抽象類中提供的抽象方法
或者將自身也聲明爲抽象類
類中定義構造塊時無論如何必須在語句外加上{ }
內部類
內部類可直接訪問外部類的私有屬性。。。內部類的唯一好處就是可以方便地訪問外部類的私有屬性
使用static可以聲明內部類，用static聲明的內部類變成了外部類，但是用static聲明的內部類不能訪問非static的外部類屬性。
day10
1、Eclipse
ctrl + 1 ：系統提供解決方案
2、抽象類，多態，循環，獲取鍵盤輸入
3、final
final的成員變量的值不能夠被改變
final的方法不能夠被重寫
final的類不能夠被繼承
4、接口
java繼承的特性：java只支持單繼承
接口是爲了解決java中存在的語義上多繼承
接口本質上是一種特殊的抽象類
只有方法的定義（都是抽象方法）可以省略abstract
常量的定義（static final ）,可省略
訪問權限都是public
接口跟類：
類 impimplements 接口
一個類可以實現多個接口接口跟接口
接口 extends 接口接口跟實現類之間存在多態性
使用接口？還是抽象類？
interface同時賦予了接口和抽象類的好處
優先使用接口接口是單獨存在的，必須放在單個文件裏
注意：一個類實現多個不同的接口時，這些接口中儘量不要存在方法名相同的聲明。
5、內部類
a、非靜態的成員內部類
public class Outer {
int i = 100; //非靜態的成員內部類:類的內部，方法的外部
class Inner { //可以使用private default protected public
public void setI(){
// 非靜態的成員內部類可以訪問外部類的成員變量
System.out.println("" + i);
}
}
public void getI(){}
public static void main(String[] args) {
// 要想創建內部類對象，必須要先有外部類對象
Outer outer = new Outer();
// 外部類對象.new 內部類
Inner inner = outer.new Inner();
inner.setI();
}
}b、靜態的成員內部類
public class Outer {
static int i = 100; // 靜態的成員內部類:類的內部，方法的外部
static class Inner{
// 可以使用private default protected public
public void setI(){
// 靜態的成員內部類只能訪問外部類的靜態的成員變量
System.out.println("" + i);
}
}
public void getI(){}
public static void main(String[] args) {
// 要想創建內部類對象，必須要先有外部類對象
Inner inner = new Outer.Inner();
// 因爲是static的，使用 (類名.方法名)調用
inner.setI();
}
}c、局部內部類
public class Outer {
public void play(){
int j = 10;
class MyInner{
public void show(){
// 在局部內部類裏面調用方法中局部變量
// 需要將局部變量聲明爲final(默認了）
// 或者聲明爲成員變量
System.out.println(j);
}
}
// 局部內部類只能在當前範圍內使用
MyInner inner = new MyInner();
inner.show();
}
}d、匿名內部類
public class Outer {
public static void main(String[] args) {
// Animal animal = new Animal();
// animal.jump();
Jumper jumper = new Jumper() {
@Override
public void jump() {
System.out.println("再也跳不動了");
}
};//整個括號裏都是語句哦 jumper.jump();
}
}