java基礎---抽象和封裝
1.為什麽使用面向對象？
現實世界是由什麽組成的，世界由對象組成
面向對象的思想符合人類思維習慣，面向對象的思想描述面向對象的世界
2.軟件出現的目的
n用計算機的語言描述現實世界
n用計算機解決現實世界的問題
3.面向對象設計和開發程序的好處
n交流更加流暢
n提高設計和開發效率
4.一個現實世界的問題
寵物——現實世界的對象
如何在計算機中描述它們?
從現實中抽象出類分三步：1. 找出它的種類2. 找出它的屬性3. 找出它的行為
第一步：發現類（根據“對象”抽象出“類”）
class Dog {
}
第二步：發現類的屬性（只放和業務相關的屬性）
class Dog {
String name = "旺財"; // 昵稱
int health = 100; // 健康值
int love = 0; // 親密度
String strain = "拉布拉多犬"; // 品種
}
第三步：發現類的方法
class Dog {
String name = "旺財"; // 昵稱
int health = 100; // 健康值
int love = 0; // 親密度
String strain = "拉布拉多犬
/* 輸出狗的信息 */
public void print() {
// 輸出狗信息的代碼
}
5.類圖
舉例：實現寵物領養
public class Dog {
// 狗狗實體類
// field
public String name;
public int health;
public int love;
public String strain;
// methods
public void print() {
System.out.println("姓名" + name + "
+ strain);
}
}
public class Penguin {
// 企鵝實體類
// field
public String name;
public int health;
public int love;
public String gender;
// methods
public void print() {
System.out.println("姓名" + name + "健康值" + health + "可愛值" + love + "種類"
+ gender);
}
}
import java.util.Scanner;
public class Adopt {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String name = null;
Dog dog = null;
Penguin penguin = null;
int choice = 0;
String answer = "y";
while (answer.equals("y")) {
System.out.println("請輸入領養寵物的名字");
name = input.next();
System.out.println("請輸入您要領養寵物的類型;1-狗;2-企鵝");
choice = input.nextInt();
switch (choice) {
case 1:
// 領養狗
answer = "n";
System.out.println("請輸入狗狗的種類,1-拉布拉多;2-哈士奇");
choice = input.nextInt();
dog = new Dog(); // 創建新的空間
dog.name = name;
if (choice == 1) {
dog.strain = "拉布拉多";
} else if (choice == 2) {
dog.strain = "哈士奇";
}
dog.love = 60;
dog.health = 60;*/
break;
case 2:
// 領養企鵝
answer = "n";
System.out.println("請輸入企鵝的性別;1-Q仔;2-Q妹");
choice = input.nextInt();
penguin = new Penguin();
penguin.name = name;
if (choice == 1) {
penguin.gender = "Q" + "仔";
} else if (choice == 2) {
penguin.gender = "Q" + "妹";
}
penguin.love = 60;
penguin.health = 60;
break;
default:
System.out.println("對不起,輸入有誤,請重新輸入");
break;
}
System.out.println("還要繼續領養嗎? y-繼續;n-退出");
answer = input.next();
}
// 輸出
if (dog != null) {
dog.print();
}
if (penguin != null) {
penguin.print();
}
}
}
心得：根據現實世界的信息，用程序的角度去描述出來
因為Dog dog = null;為空，只做了一個房間，並沒有賦值；所以使用dog.什麽的時候需要new一個對象（不能給房間直接賦值）
如何查看領養了那個寵物，查看那個房間沒有空著。則代表領養到了...
如果想重復領養，目前達不到，存放企鵝和狗狗的只有一個房間。多次領養無意義...
列表可以幫助實現
6.整理代碼快捷鍵
Ctrl+shift+f
7.如何修改快捷鍵
Windows--->preference-->查找輸入keys--->進行修改
8.封裝-----構造方法
上述對寵物的初始化不方便，如果狗狗有100個屬性則需要寫100次dog.xx；且每次初始化dog，每次都需要重復寫那麽多。比較繁瑣，應符合寫少做多。
對象初始化
Penguin pgn=new Penguin();
pgn.name = "qq";
pgn.sex = "Q仔";
能否在創建對象的同時就完成賦值?構造方法（new完直接賦值）
構造方法是提前把屬性寫好
舉例：無參構造方法
public class Dog {
// dog
// field
public String name;
public int health;
public int love;
public String strain;
//構造方法
//構造方法沒有返回值
public Dog(){
name="旺仔";
health=60;
love=90;
strain="中華田園犬";
}
// methods
public void print() {
System.out.println("姓名" + name + "健康值" + health + "可愛值" + love + "種類"
+ strain);
}
}
public class Penguin {
// 企鵝
// field
public String name;
public int health;
public int love;
public String gender;
//構造方法
//構造方法沒有返回值
public Penguin(){
name="QQ";
health=60;
love=60;
gender="Q仔";
}
// methods
public void print() {
System.out.println("姓名" + name + "健康值" + health + "可愛值" + love + "種類"
+ gender);
}
}
import java.util.Scanner;
public class Adopt {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String name = null;
Dog dog = null;
Penguin penguin = null;
int choice = 0;
String answer = "y";
while (answer.equals("y")) {
System.out.println("請輸入領養寵物的名字");
name = input.next();
System.out.println("請輸入您要領養寵物的類型;1-狗;2-企鵝");
choice = input.nextInt();
switch (choice) {
case 1:
// 領養狗
answer = "n";
System.out.println("請輸入狗狗的種類,1-拉布拉多;2-哈士奇");
choice = input.nextInt();
dog = new Dog(); // 創建新的空間
break;
case 2:
// 領養企鵝
answer = "n";
System.out.println("請輸入企鵝的性別;1-Q仔;2-Q妹");
choice = input.nextInt();
penguin = new Penguin();
break;
default:
System.out.println("對不起,輸入有誤,請重新輸入");
break;
}
System.out.println("還要繼續領養嗎? y-繼續;n-退出");
answer = input.next();
}
// 輸出
if (dog != null) {
dog.print();
}
if (penguin != null) {
penguin.print();
}
}
}
9.無參類型構造方法
系統提供默認無參構造方法
語法:
訪問修飾符 構造方法名 ( ) {
//初始化代碼
}
示例:
public Penguin() {
}
10. 帶參數的構造方法
所謂沒有參數的構造方法就是指，需要自己做一個對象，不是按照意願造出來的，而是系統提供什麽就必須安要求來...
舉例：
public class Dog {
// dog
// field
public String name;
public int health;
public int love;
public String strain;
// 帶參數構造方法
// this-當前對象
public Dog(String name,int health,int love,String strain){
this.name=name;
this.health=health;
this.love=love;
this.strain=strain;
}
// methods
public void print() {
System.out.println("姓名" + name + "健康值" + health + "可愛值" + love + "種類"
+ strain);
}
}
public class DogTest {
public static void main(String[] args) {
// 帶參數構造方法
Dog dog=new Dog("阿福",100,20,"沙皮");
dog.print();
}
}
心得：
帶參數的構造方法可以按照自己的心意去做，所以需要輸入一些東西，有什麽屬性輸什麽屬性
需要把參數的信息挨個賦值給類的屬性，利用this
This.name指的是public String name,然後把傳過來的參數 給類的成員變量this.name=name
當沒有無參數的方法時main不能添加Dog dog=new Dog();
11.帶參數構造方法常見錯誤
舉例：
public class Dog {
// dog
// field
public String name;
public int health;
public int love;
public String strain;
// 帶參數構造方法
// this-當前對象
public Dog(String name,int health,int love,String strain){
this.name=name;
this.health=health;
this.love=love;
this.strain=strain;
}
// methods
public void print() {
System.out.println("姓名" + name + "健康值" + health + "可愛值" + love + "種類"
+ strain);
}
}
public class DogTest {
public static void main(String[] args) {
Dog dog=new Dog();
dog.print();
}
}
錯在哪裏？
1.前面一個類，後面一個測試類
測試類裏面調用的是不帶參數的構造方法，但本類裏並沒有提供不帶參數的構造方法，故出錯
2.當無參方法和有參數方法同時出現時，調用無參方法也會成功
12.不帶參數的構造方法有倆個特點
1.系統默認提供無參構造方法
2.當系統還有帶參數的構造方法時，系統不在提供默認的無參構造方法
13.構造方法重載
變量不能同名、類不能同名、為什麽方法可以同名？因為方法的重載
舉例：
public class Demo {
/*方法的重載 overload
* 1-兩個方法 方法名相同
* 2-參數不同
* 3-與返回值 訪問控制符無關
* */
public void print(){
System.out.println("打印");
}
public String print(int d){
System.out.println("打印");
return null;
}
}
14.構造方法重載的調用
pgn = new Penguin();
pgn.print();
pgn = new Penguin("美美", 80, 20, "Q仔");
pgn.print();
public Penguin () {
name = "qq";
love = 20;
sex = "Q仔";
}
public Penguin (String name,int health,int love,String sex ) {
this.name = name;
this.health = health;
this.love = love;
this.sex = sex;
}
15.static關鍵字
可以修飾成員變量、方法
修飾成員變量，通過類名直接訪問成員變量
可以繞過new，直接拿類來訪問不用拿對象來訪問它。
無論修飾成員變量，還是成員方法static都寫在類型的前面；在使用的時候不需要new對象
1-修飾成員變量 類名.fileldName
2-修飾成員方法 類名.methodName
3-修飾靜態代碼塊
舉例：變量
package demo1;
public class Penguin {
// static
//屬性
public static String MALE="Q仔";
public static String FEMALE="Q妹";
}
package demo1;
public class PenguinTest {
public static void main(String[] args) {
//屬性
System.out.println(Penguin .MALE);
System.out.println(Penguin.FEMALE);
}
}
心得：一般用static修飾的都大寫
不用new和對象直接把屬性使用
舉例：方法
package demo1;
public class Penguin {
/*//方法
public static void test(){
System.out.println("test static method");
}
}
package demo1;
public class PenguinTest {
public static void main(String[] args) {
//方法
Penguin.test();
}
}
舉例：靜態代碼塊
package demo1;
public class Penguin {
//無參數
public Penguin(){
System.out.println("無參...");
}
//靜態代碼塊
//優先於構造方法去執行
static{
System.out.println("代碼塊");
System.out.println("靜態代碼塊");
System.out.println("************");
}
}
package demo1;
public class PenguinTest {
public static void main(String[] args) {
Penguin a=new Penguin();
}
}
16.為什麽要使用封裝
屬性隨意訪問，不合理的賦值；如何解決，使用封裝
舉例：
package demo4;
public class Dog {
private String name;
private int love;
private int health;
private String strain;
/*
*
* set和get方法
*
* */
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getLove() {
return love;
}
public void setLove(int love) {
if(love<0||love>100) {
System.out.println("親密度只能在0-100之間");
this.love=60;
}else{
this.love = love;
}
}
public int getHealth() {
return health;
}
public void setHealth(int health) {
if(health<0||health>100) {
System.out.println("健康值只能在0-100之間");
this.health=60;
}else{
this.health = health;
}
}
public String getStrain() {
return strain;
}
public void setStrain(String strain) {
this.strain = strain;
}
/*
*
* 帶參數的構造方法
*
* */
public Dog(String name, int love, int health, String strain) {
super();
this.name = name;
this.love = love;
this.health = health;
this.strain = strain;
}
/*
*
* 不帶參數的構造方法
*
*
* */
public Dog() {
super();
// TODO Auto-generated constructor stub
}
/*
*
* toString() 自動生成
*
* */
@Override
public String toString() {
return "Dog [name=" + name + ", love=" + love + ", health=" + health
+ ", strain=" + strain + "]";
}
}
package demo4;
import java.util.Scanner;
public class Adopt {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String name = null;
Dog dog = null;
Penguin penguin = null;
int choice = 0;
String answer = "y";
while (answer.equals("y")) {
System.out.println("請輸入領養寵物的名字");
name = input.next();
System.out.println("請輸入您要領養寵物的類型;1-狗;2-企鵝");
choice = input.nextInt();
switch (choice) {
case 1:
// 領養狗
answer = "n";
System.out.println("請輸入狗狗的種類,1-拉布拉多;2-哈士奇");
dog = new Dog(); // 創建新的空間
choice = input.nextInt();
if (choice == 1) {
dog.setStrain("拉布拉多"); 調用set方法
} else if (choice == 2) {
dog.setStrain("哈士奇");
}
dog.setName(name);
System.out.println("請輸入狗狗的健康值");
dog.setHealth(input.nextInt());
System.out.println("請輸入狗狗的可愛值");
dog.setLove(input.nextInt());
break;
case 2:
// 領養企鵝
answer = "n";
System.out.println("請輸入企鵝的性別;1-Q仔;2-Q妹");
choice = input.nextInt();
penguin = new Penguin();
if (choice == 1) {
penguin.setGender(Penguin.MALE);
} else if (choice == 2) {
penguin.setGender(Penguin.FEMALE);
}
penguin.setName(name);
System.out.println("請輸入企鵝的健康值");
penguin.setHealth(input.nextInt());
System.out.println("請輸入企鵝的可愛值");
penguin.setLove(input.nextInt());
break;
default:
System.out.println("對不起,輸入有誤,請重新輸入");
break;
}
System.out.println("還要繼續領養嗎? y-繼續;n-退出");
answer = input.next();
}
// 輸出
if (dog != null) {
System.out.println(dog.toString());
} else if (penguin != null) {
System.out.println(penguin.toString());
}
}
}
心得：健康值屬性不能被賦值-100，不能修改。想要實現不被修改，在測試類裏隨意添加這樣是不合理的。不允許修改，故需要封裝
封裝分二步：1-將屬性的訪問符改為private
2-set 設置 修改
3-get 讀 獲取
做限制可以在set方法裏做限制
Penguin.MALE 值被固定，不被修改
17.快捷鍵
Alt+shift+s
Get 、set、無參方法、帶參方法可以幫助生成
但是自定義的方法和屬性需要自己寫
18.什麽是封裝
封裝：將類的某些信息隱藏在類內部，不允許外部程序直接訪問，而是通過該類提供的方法來實現對隱藏信息的操作和訪問
19. 如何使用封裝
修改屬性的可見性
1在getter/setter方法中加入屬性控制語句（設為private）
2創建公有的getter/setter方法（用於屬性的讀寫）
2在getter/setter方法中加入屬性控制語句（對屬性值的合法性進行判斷）
20. this的用法
調用屬性
this.health = 100;
this.name = "大黃";
調用方法
this.print();
調用構造方法
this();
this("小黑",100,100,"雄");
this();如果使用，必須是構造方法中的第一條語句
舉例：
不能在普通方法裏調用this();
只能在構造方法中調用this();
不能在無參中調用帶參，只能在帶參中調用無參數方法
21. 總結
抽象：用程序的語言描述現實世界
1-找到類
2-屬性
3-方法
構造方法
作用：初始化對象屬性
1-無參數
Public 類名（）{
}
2-帶參數
Public 類名（String name）{
This.name=name；
}
A系統默認提供無參數的構造方法
B當系統提供了帶參數的構造方法時，不在提供無參數方法
封裝
1-將屬性public變為private
2-增加get/set方法，讀取/寫入
3-重新修改set方法
Static
1-屬性
2-方法
Person p=new Person（）；
p.field ；
p.method；
--------------------------------------------
Person.filed；
Person.method（）；
3-靜態代碼塊
優先於構造方法去執行
Static{
}
方法的重載
1-同一個類中
2-倆個或多個同名方法
3-參數不同
4-與訪問修飾符和返回值無關
java基礎---抽象和封裝