Java學(xué)習(xí)記錄

idisfkj 發(fā)布于2019-08-16 10:46 / 1904人閱讀
摘要：面向?qū)ο缶幊痰娜拇筇卣鞣庋b，繼承，多態(tài)，抽象基礎(chǔ)語法數(shù)組或字符串組或循環(huán)用來迭代選擇類中構(gòu)造方法的原則是只實現(xiàn)自己的功能是一個類字符串常量池是堆中的一個存字符串值的一個集合他的賦值方式有兩種張三創(chuàng)建兩個對象字符串常量池和堆內(nèi)存中張
面向?qū)ο缶幊痰娜ㄋ模┐筇卣?br>封裝，繼承，多態(tài)（，抽象）
基礎(chǔ)語法：
數(shù)組（int[] a或 int a[]）、字符串組（String []a或 String a[] ）
循環(huán)
   for(int i;i

選擇
 if(){
}else{
}
swich(score){
case 1:....;break;
case 2:....;break;
}

類中構(gòu)造方法的原則是只實現(xiàn)自己的功能

String 是一個類,字符串常量池是堆中的一個存字符串值的一個集合,他的賦值方式有兩種


String name = new String ("張三"); 創(chuàng)建兩個對象字符串常量池和堆內(nèi)存中;

String name = "張三";創(chuàng)建一個對象，推薦使用


字符串存在于常量池中

類的操作
1.類是一個具有相同屬性的集合，對象是其中的一的個例
類中包含屬性和方法，公共的屬性有對象調(diào)用
class Person{
    //屬性的定義
    String name;
    int age;
    char sex;
    //方法的定義
    public void show(){
        System.out.println("我是"+name+",今年"+age+"歲了,"+"是一個"+sex+"人");
    }
}
public class Notes{
    public static void main(String []args){
        Person p = new Person();
        p.name = "張三";
        p.sex = "男";
        p.age = 10;
        p.show();
    }
}

2.封裝性
常用：屬性的封裝
 class Person{
    //屬性的定義
    private String name;
    private int age;
    private char sex;
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
    public void setSex(char sex){
        this.sex = sex;
    }
    public char getSex(){
        return sex;
    }
    //方法的定義
    public void show(){
        System.out.println("我是"+name+",今年"+age+"歲了,"+"是一個"+sex+"人");
    }
}

public class Notes{
    public static void main(String []args){
        Person p = new Person();
        p.setName("張三");
        p.setSex("男");
        p.setAge(10);
        p.show();
    }
}

3.構(gòu)造方法的重寫
默認(rèn)為無參函數(shù)
構(gòu)造方法和類名相同，為大寫開頭
重寫構(gòu)造方法后自動覆蓋掉無參，若想調(diào)用即需寫出無參構(gòu)造方法
構(gòu)造方法可以寫多個
class Person{
    //屬性的定義
    private String name;
    private int age;
    private char sex;
    public Person(){}
    public Person(String name){
        this.name = name;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
    public void setSex(char sex){
        this.sex = sex;
    }
    public char getSex(){
        return sex;
    }
    //方法的定義
    public void show(){
        System.out.println("我是"+name+",今年"+age+"歲了,"+"是一個"+sex+"人");
    }
}
public class Notes{
    public static void main(String []args){
        Person p = new Person();
        p.setName("張三");
        p.setSex("男");
        p.setAge(10);
        p.show();
        Person q = new Person("李四");
        q.setSex("女");
        q.setAge(10);
        q.show();
    }
}

4.方法的重載(overloading Method)
條件：方法名相同，參數(shù)不同
class Person{
    //屬性的定義
    private String name;
    private int age;
    private char sex;
    public Person(){}
    public Person(String name){
        this.name = name;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
    public void setSex(char sex){
        this.sex = sex;
    }
    public char getSex(){
        return sex;
    }
    //方法的定義
    public void show(){
        System.out.println("我是"+name+",今年"+age+"歲了,"+"是一個"+sex
        +"人,我的伴侶是李四");
    }
    public void show(String name){
        System.out.println("我是"+name+",今年"+age+"歲了,"
        +"是一個"+sex+"人,我的伴侶是"+name);
    }
}
public class Notes{
    public static void main(String []args){
        Person p = new Person();
        p.setName("張三");
        p.setSex("男");
        p.setAge(10);
        p.show();
        p.show("王五");
    }
}

5.匿名對象
1.沒有名稱 2.只能使用一次 
3.直接在堆中開辟內(nèi)存 4.使用后被回收
class Person{
    //屬性的定義
    private String name = "張三";
    private int age = 10;
    private char sex = "男";
    public Person(){}
    public Person(String name){
        this.name = name;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
    public void setSex(char sex){
        this.sex = sex;
    }
    public char getSex(){
        return sex;
    }
    //方法的定義
    public void show(){
        System.out.println("我是"+name+",今年"+age+"歲了,"+"是一個"+sex
        +"人,我的伴侶是李四");
    }
    public void show(String name){
        System.out.println("我是"+name+",今年"+age+"歲了,"
        +"是一個"+sex+"人,我的伴侶是"+name);
    }
}
public class Notes{
    public static void main(String []args){
        new Person().show();
    }
}

6.String類的編譯期和運行期
public class Notes{
    public static void main(String []args){
        //情況一：true
        String a = "s1";
        String a1 = "s"+1;//兩個常量連接
        System.out.println(a == a1);
        
        //情況二：false
        String b = "s1";
        int bb = 1;
        String b1 = "s"+bb;//因為此處的bb為變量
        System.out.println(b == b1);
        
        //情況三：true
        String c = "s1";
        final int cc = 1;//此處聲明了一個常量
        String c1 = "s" + cc;//在這里cc代表了一個常數(shù)
        System.out.println(c == c1);

        //情況四：false
        String d = "s1";
        final int dd = getDD();//此處需要到運行期才可以確定
        String d1 = "s" + dd;
        System.out.println(d == d1);
    }
    public static int getDD(){
        return 1;
    }
}

7.String類的操作方法
//1.根據(jù)下標(biāo)找字符
public class Notes{
    public static void main(String []args){
        String test = "i love java";
        char result = test.charAt(3);
        System.out.println("第4個字符是"+result);
    }
}

//2.字符串變字符數(shù)組
public class Notes{
    public static void main(String []args){
        String test = "i love java";
        char []result = test.toCharArray();
        for(char i:result)
            System.out.print(i+",");
    System.out.println();
    }
}

//3.字符串的截取
public class Notes{
    public static void main(String []args){
        String test = "i love java";
        String result = test.substring(6);
        System.out.println(result);
        result = test.substring(0,6);//包含起始位置不包含結(jié)束位置
        System.out.println(result);
    }
}

//4.字符串的拆分
public class Notes{
    public static void main(String []args){
        String test = "i love java";
        String []result = test.split(" ");
        for(String i:result)
            System.out.print(i+"|	");
        System.out.println("
==============");
        String result_1[] = test.split(" ",2);
        for(String i:result_1)
            System.out.print(i+"	");
        System.out.println();
    }
}

//5.字符串的查找,替換,大小寫轉(zhuǎn)換,長度計算
public class Notes{
    public static void main(String []args){
        String test = " i love java ";
        
        Boolean b = test.contains("a");
        System.out.println(b);
        
        int index = test.indexOf("l");
        System.out.println(index);
        
        index = test.indexOf("java");//第一字母出現(xiàn)的位置,該單詞不存在返回-1
        System.out.println(index);
        
        int index_1 = test.lastIndexOf("a");//從后向前查找
        System.out.println(index_1);
        
        String result = test.toUpperCase();
        System.out.println(result);
        
        result = result.toLowerCase();
        System.out.println(result);
        
        b = test.isEmpty();
        System.out.println(b);
        
        result = test.concat(" too!");        
        System.out.println(result);
        
        int cnt = test.length();
        System.out.println(cnt);
        
        result = test.trim();
        System.out.println(result);
        
        result = test.replace(" ","-");
        System.out.println(result);
        
    }
}

8.值傳遞與引用傳遞
//1.值傳遞，String也可以這樣表示
public class Notes{
    public static void main(String []args){
        int b = 1;
        method(b);    
        System.out.println(b);
    }
    public static void method(int c){
            c = 2;
    }
}

//2.方法傳遞
public class Notes{
    public static void main(String []args){
        Cat b = new Cat();
        b.age = 12;
        method(b);    
        System.out.println(b.age);
    }
    public static void method(Cat c){
            c.age = 20;
    }
}
class Cat{
    int age = 10;
}

9.對象的一對一關(guān)系
public class Notes{
    public static void main(String [] args){
        Husband h = new Husband("張三","男");
        Wife w = new Wife("李四",15);
        h.wife = w;
        w.husband = h;
        h.show();
        w.show();
        h.wife.show();
        w.husband.show();
        
    }
}

class Husband{
    String name;
    char sex;
    Wife wife;//關(guān)聯(lián)是將對方的類作為屬性導(dǎo)入，關(guān)聯(lián)妻子類
    public Husband(){}
    public Husband(String name, char sex){
        this.name = name;
        this.sex = sex;
    }
    public void show(){
        System.out.println("我是"+name+",我的妻子是"+wife.name);
    }
}

class Wife{
    //實際操作中應(yīng)該封裝
    String name;
    int age;
    Husband husband;//關(guān)聯(lián)是將對方的類作為屬性導(dǎo)入，關(guān)聯(lián)丈夫類
    public Wife(){}
    public Wife(String name, int age){
        this.name = name;
        this.age = age;
    }
    public void show(){
        System.out.println("我是"+name+",我的丈夫是"+husband.name);
    }
}

10.this關(guān)鍵字
調(diào)用類中的屬性
調(diào)用類中的方法或構(gòu)造方法
表示當(dāng)前對象
public class Notes{
    public static void main(String []args){
        Bear b = new Bear("熊二");
        Bear c = new Bear();
    }
}
class Bear{
    private String name;
    private char sex;
    public Bear(){
        this("熊大","公");//this直接調(diào)用本類中的構(gòu)造方法                              
    }
    public Bear(String name){
        this(name,"公");
    }
    public Bear(String name,char sex){
        this.name = name;
        this.sex = sex;
        this.bite();//調(diào)用本類中的方法，this可以省略
    }
    public void bite(){
        System.out.println("我是" + sex + "熊--" + name);
    }
}

11.static關(guān)鍵字
1.使用static的關(guān)鍵字修飾一個屬性，這個變量是一個全局變量
2.在類中定義一個方法為static那么無需本類中的對象即可調(diào)用該方法
3.使用static關(guān)鍵字修飾一個類
靜態(tài)方法和屬性在類加載后就存到方法區(qū)內(nèi)存中，此時還沒有產(chǎn)生對象，
普通的方法和屬性都是屬于對象的
聲明為static的方法：
僅能調(diào)用其他的static方法，可以被普通的方法調(diào)用
只能訪問static的數(shù)據(jù)
不能以任何的方式引用this或super（屬于對象）
public class Notes{
    public static void main(String []args){
    Mistress m1 = new Mistress("張三");
    Mistress m2 = new Mistress("李四");
    m1.desc();
    m2.desc();
    Mistress.profession = "小三";//使用類名修改靜態(tài)屬性，常用方法
    m1.desc();
    m2.desc();
    Mistress.promosion();
    m1.desc();
    m2.desc();
    }
}

class Mistress{
    String name;
    //String profession = "情人";
    static String profession = "情人";//變成靜態(tài)屬性，不屬于對象的屬性，屬于類； 
    public Mistress(String name){
        this.name = name;
    }
    public void desc(){
        System.out.println("我的名字是"+name+",我的職業(yè)是"+profession);
    }
    //使用static關(guān)鍵字修飾一個方法，該方法屬于類，不屬于對象
    public static void promosion(){
        System.out.println("轉(zhuǎn)正了");
        profession = "主婦";
    }
}

*/
/**
13.蛋疼的數(shù)羊
靜態(tài)變量的使用
*/
/*
public class Notes{
    public static void main(String []args){
        Sheep a = new Sheep();
        Sheep b = new Sheep();
        System.out.println(Sheep.cntSheep());
    }

}
class Sheep{
    private String name;
    private int age;
    static int cnt = 0;
    public Sheep(){
        this("喜羊羊",10);
    }
    public Sheep(String name){
        this(name,10);
    }
    public Sheep(String name, int age){
        this.name = name;
        this.age = age;
        cnt++;
    }
    public static int cntSheep(){
        return cnt;
    }
}

14.對象數(shù)組的使用
import java.util.Arrays;
public class Notes{
    public static void main(String []args){
        MonkeyManager.add(new Monkey("悟空"));
        MonkeyManager.add(new Monkey("悟飯"));
        MonkeyManager.add(new Monkey("悟靜","母"));
        MonkeyManager.add(new Monkey("淑敏","母"));
        MonkeyManager.list();
        MonkeyManager.delete("悟空");
        System.out.println("==============");
        MonkeyManager.list();        
        System.out.println("==============");
        Monkey m = MonkeyManager.find("淑敏");
        m.print();
        System.out.println("==============");
        MonkeyManager.set(new Monkey("悟靜","母"));
        MonkeyManager.list();    
        MonkeyManager.add(new Monkey("小紅","母"));
        MonkeyManager.add(new Monkey("小白","公"));
        MonkeyManager.add(new Monkey("小黑","公"));
        System.out.println("==============");
        MonkeyManager.list();    
    }
}
class MonkeyManager{
    private static int cnt = 0;
    private static int n = 5;
    private static Monkey [] monkeys = new Monkey[n];
    public static void add(Monkey monkey){
        if(cnt >= n){
            int new_lenth = monkeys.length*3/2+1;
            monkeys = Arrays.copyOf(monkeys, new_lenth);
        }
        monkeys[cnt] = monkey;
        cnt++;    
    }
    public static void list(){
        for(int i = 0; i < cnt; i++){
            monkeys[i].print();
        }
    }
    public static void delete(String name){
        for(int i = 0; i < cnt; i++){
            if(monkeys[i].getName().equals(name)){
                monkeys[i] = monkeys[cnt-1];
                monkeys[cnt-1] = null;
                cnt--;
            }
        }
    }
    public static Monkey find(String name){
        for(int i = 0; i < cnt; i++){
            if(monkeys[i].getName().equals(name)){
                return monkeys[i];
            }
        }
        return null;
    }
    public static void set(Monkey monkey){
        Monkey m = find(monkey.getName());
        m.setSex(monkey.getSex());
    }
}
class Monkey{
    private String name;
    private char sex;
    //省略get, set方法
    public Monkey(){
        this("齊齊","公");
    }
    public Monkey(String name){
        this(name,"公");
    }
    public Monkey(String name, char sex){
        this.name = name;
        this.sex = sex;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setSex(char sex){
        this.sex = sex;
    }
    public char getSex(){
        return sex;
    }
    public void print(){
        System.out.println("我是"+sex+"猴--"+name);
    }
}

15.可變參數(shù)，(int...num)相當(dāng)于數(shù)組，
如果有一個可變參數(shù)和不可變參數(shù)，不可變放在首位
靜態(tài)塊執(zhí)行一次
單例設(shè)計模式Test1.java學(xué)習(xí)記錄*/
/**
類的繼承
屬性包括：protected（必須繼承的屬性）,private,public,default
繼承使用父類的方法和屬性（非私有）
構(gòu)造方法無法被繼承
*/
 public class Notes {
        public static void main(String []args){
            HomeChicken hc = new HomeChicken("小黑");
            hc.desc( );
        }
    }
    class Chicken{
        protected String name;
        protected int age;
        protected Chicken(){
            this("小明",2);
        }
        protected Chicken(String name){
            this(name,10);
        }
        protected Chicken(String name, int age){
            this.name = name;
            this.age = age;
        }
        protected void desc(){
            System.out.println("我是一只雞，名字叫"+name+"，今年"+age+"歲了。");
        }
    }
    class HomeChicken extends Chicken{
        public HomeChicken(){
            super();
        }
        public HomeChicken(String name){
            super(name);
        }
        public HomeChicken(String name, int age){
            super(name, age);
        }
        public void desc(){//方法的重寫，方法名，返回值，參數(shù)列表相同
            super.desc();//super關(guān)鍵字，相當(dāng)于this
            System.out.println("我是一只家雞，名字叫"+name+"，今年"+age+"歲了。");
        }
    }

*/
/**
17.final關(guān)鍵字
1.修飾類不能被繼承
2.修飾變量為常量
(1).final int n = 3;
(2).在構(gòu)造方法中賦值
(3).對類中對象賦值是內(nèi)存地址不變，內(nèi)容可變
3.修飾方法不能被重寫
*/
/**
18.抽象類
(1).多個具有相同特征和行為的類的集合是抽象類
(2).使用abstract聲明
(3).不能被實例化
(4).不能使用final修飾
(5).可以沒有抽象方法
(6).有抽象方法必須是抽象方法     
(7).可以有構(gòu)造方法                                                                                                                                   
*/
/*
public class Notes{
    public static void main(String [] args){
        Godness g = new Godness();
        g.setName("圓圓");
        g.say();
        UglyWomen u = new UglyWomen();
        u.setName("芳芳");
        u.say();
    }
}

abstract class Women{
    private String name;
    private int age;

    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
    public abstract void say();
    //public abstract void desc();//必須覆蓋抽象類中的所有的抽象方法
}

class Godness extends Women{
    public void say(){
        System.out.println("我是女神，我叫"+getName());
    }
}

class UglyWomen extends Women{
    public void say(){
        System.out.println("我雖丑，但是丑女無敵，我是"+getName());
    }
}

*/
/**
19.接口
1.接口的概念
1）一組行為的規(guī)范、定義，沒有實現(xiàn)
2）使程序利于變化
3）面向?qū)ο笾械木?br>4）面向?qū)ο蟮膶嶋H法則，基于接口編程 
2.接口的定義
interface 聲明的類似與類的定義，其中只有常量和抽象方法，
不用abstract修飾
3.接口的規(guī)則
1）可以繼承多個接口interface A extends B,C,D{}
2）一個類可以實現(xiàn)多個接口，class A implements b,c,d{}
3）命名接口前面加I
4）抽象類實現(xiàn)接口不用實現(xiàn)接口的方法
5）接口中只能使用public，默認(rèn)為public abstract 可以省略
6）接口中的屬性都是常量，默認(rèn)為public static final都可以省略
常量名通常是全大寫
*/
/*
public class Notes{
    public static void main(String [] args){
        Goddess g = new Goddess();
        g.cry();
        g.eat();
        Girl gl = new Girl();
        gl.cry();
        gl.eat();
    }
}
interface IEat{
    public void eat();
}
interface IHit{
    public void cry();
}
class Goddess implements IHit,IEat{
    //實現(xiàn)接口中所有得到方法
    public void cry(){
        System.out.println("好疼呀！！");
    }
    public void eat(){
        System.out.println("一小口一小口的吃");
    }
}
class Girl implements IHit,IEat{
    //實現(xiàn)接口中所有得到方法
    public void cry(){
        System.out.println("臥槽，找死呀！！");
    }
    public void eat(){
        System.out.println("一大口一大口的吃");
    }
}

abstract class Person implements IEat,IHit{
    public void say();
    public void eat();
}

*/
/**
20.多態(tài)
1.多態(tài)是多種形態(tài)
2.兩種情況
1）方法的重寫和重載
2）對象的多態(tài)性
3.實際開發(fā)盡量使用父類引用
*/
/*
public class Notes{
    public static void main(String [] name){
        Person man = new Man();//父類的引用指向子類對象,向上轉(zhuǎn)型
        man.say();
        Person women = new Women();
        women.say();
        Man m = (Man)man;//大轉(zhuǎn)小，強制轉(zhuǎn)換；
        m.say();
        //Man mm = (Man)women;
        //java.lang.ClassCastException類型轉(zhuǎn)換失敗，不能強轉(zhuǎn)，運行失敗
    }
}
abstract class Person{
    private String name;
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public abstract void say();
}        
class Man extends Person{
    public void say(){
        System.out.println("人家是純爺們");
    }
}    
class Women extends Person{
    public void say(){
        System.out.println("人家是女神");
    }
}

*/
/**
21.instanceof關(guān)鍵字
父類優(yōu)先考慮接口
盡量不要繼承一個具體類
*/
/*
public class Notes{
    public static void main(String [] name){
        Person man = new Man();//父類的引用指向子類對象,向上轉(zhuǎn)型
        //man.say();
        say(man);
        Person women = new Women();
        //women.say();
        say(women);
        Man m = (Man)man;//大轉(zhuǎn)小，強制轉(zhuǎn)換；
        say(m);
        //m.say();
        //Man mm = (Man)women;
        //java.lang.ClassCastException類型轉(zhuǎn)換失敗，不能強轉(zhuǎn)，運行失敗
    }
    public static void say(Person p){
        p.say();
        //判斷p是否是Women對象，是返回真
        if(p instanceof Women){
            Women w = (Women)p;
            w.getAngry();
        }
    }
}
abstract class Person{
    private String name;
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public abstract void say();
}        
class Man extends Person{
    public void say(){
        System.out.println("人家是純爺們");
    }
}    
class Women extends Person{
    public void say(){
        System.out.println("人家是女神");
    }
    public void getAngry(){
        System.out.println("人家生氣了");    
    }
}

*/
/**
22.繼承的應(yīng)用與模版式設(shè)計
模版式設(shè)計是在父類中構(gòu)建一個框架，在子類中實現(xiàn)可變的功能
*/
/*
import java.util.Random;
public class Notes{
    public static void main(String []args){
        lingjiuPalace pl = new sheMale();
        pl.action();
    }
}

abstract class lingjiuPalace{
    public void action(){
        if(competition()){//調(diào)用自身的方法形成框架
            System.out.println("恭喜你，進(jìn)入靈鷲宮！");
        }else{
            System.out.println("抱歉，您失敗了！");
        }
    }
    public abstract boolean competition();
}
class sheMale extends lingjiuPalace{
    Random r = new Random();
    public boolean competition(){
        return r.nextBoolean();
    }
}

*/
/**
23.接口的應(yīng)用與策略設(shè)計模式
策略設(shè)計模式，封裝一系列的行為，抽象為接口，可變的行為
OO原則
1.面向接口的編程
2.封裝變化
3.多用組合，少用繼承
*/
/*
public class Notes{
    public static void main(String[]args){
        Person p = new Person("小白");
        p.setIsay(new BeforeGong());
        p.say();
        p.setIsay(new AfterGong());
        p.say();
    }
}
//這是接口的方式實現(xiàn)
interface Isay{
    public void say();
}
class BeforeGong implements Isay{
    public void say(){
        System.out.println("純爺們！");
    }
}
class AfterGong implements Isay{
    public void say(){
        System.out.println("宮女！");
    }
}
class Person{
    private String name;
    private Isay isay;//接口相當(dāng)于一個類型，作為一個屬性引入
    public void setIsay(Isay isay){
        this.isay = isay;
    }
    public Person(String name){
        this.name = name;
    }
    public void say(){
        isay.say();            
    }
}


//利用抽象類實現(xiàn)，調(diào)用方式省略了，只展示部分代碼
abstract class Person{
    private String name;
    public Person(String name){
        this.name = name;
    }
    public abstract void say();
}

class BeforeGongPerson extends Person{
    public BeforeGongPerson(String name){
        super(name);
    }
    public void say(){
        System.out.println("純爺們！");
    }
}

class AfterGongPerson extends Person{
    public AfterGongPerson(String name){
        super(name);
    }
    public void say(){
        System.out.println("宮女！");
    }
}

/**
24.Object類
1.所有類的父類
2.自動調(diào)用toString
3.equals(),自反性（自己和自己比）、對稱性（前后可以互換）、
傳遞性（a=b,b=c,則a=c）、一致性（如果字符布變，那比較結(jié)果不變））
4.使用Object類型傳輸數(shù)據(jù)
*/
/*
public class Notes{
public static void main(String [] args){
    Baboon bb = new Baboon("小白",7,"公");
    System.out.println(bb);
    Baboon b2 = new Baboon("小白",7,"公");
    System.out.println(bb.equals(b2));
    method(bb);
} 
public static void method(Object obj){
    if(obj instanceof Baboon){
        Baboon bb = (Baboon) obj;
        bb.eat();
    }
}
}
class Baboon{
private String name;
private int age;
private char sex;
public Baboon(String name, int age, char sex){
    this.name = name;
    this.age = age;
    this.sex = sex;
}
public void eat(){
    System.out.println("猴子喜歡吃香蕉！");
}

public String toString(){
    return "我是"+sex+"狒狒"+name+",今年"+age+"歲了。";
}

public boolean equals(Object obj){
    //內(nèi)存地址相等則為同一對象
    if(this==obj){
        return true;
    }
    
    if(obj instanceof Baboon){
        Baboon ob =(Baboon)obj;
        if(!this.name.equals(ob.name)){
            return false;
        }else if(this.age!=ob.age){
            return false;
        }else if(this.sex!=ob.sex){
            return false;
        }
        return true;
    }else{
        return false;
    }
}
}
*/
/**
25.簡單工廠模式
由工廠對象決定創(chuàng)建出哪一種產(chǎn)品類的實例
*/
/*
public class Notes{
    public static void main(String [] args){
        Doll cd = DollFactory.getDoll("cloth");
        if(cd.getInfo()!=null)
            System.out.println(cd.getInfo());
        Doll bd = DollFactory.getDoll("barbie");
        if(bd.getInfo()!=null)
            System.out.println(bd.getInfo());
    }
}

interface Doll{
    public String getInfo();
}

class DollFactory{
    public static Doll getDoll(String name){
        if("cloth".equals(name))
            return new ClothDoll();
        else if("barbie".equals(name))
            return new BarbieDoll();
        else return null;
    }
}

class ClothDoll implements Doll{
    public String getInfo(){
        return "我是一個布娃娃";
    }
}

class BarbieDoll implements Doll{
    public String getInfo(){
        return "我是一個芭比娃娃";
    }
}

*/
/**
26.靜態(tài)代理模式
在代理中可以設(shè)置一些控制方法
*/
/*
import java.util.Scanner;
public class Notes{
    public static void main(String [] args){
        Person p = new Person("小白");
        Matchmaker m = new Matchmaker(p);
        m.miai();
    } 
}

interface Subject{
    public void miai();
}

class Person implements Subject{
    private String name;
    public Person(String name){
        this.name = name;
    }
    public void miai(){
        System.out.println(name+"正在相親中···");
    }
}

class Matchmaker implements Subject{
    private Subject target;
    
    public Matchmaker(Subject target){
        this.target = target;
    }
    public void before(){
        System.out.println("為代理人匹配如意郎君");
    }
    public void after(){
        System.out.println("本次相親結(jié)束");
        
    }
    public void miai(){
        before();
        Scanner in = new Scanner(System.in);
        System.out.println("你給我多少錢？");
        int key = in.nextInt();
        if(key > 100000)
            target.miai();
        after();
    }
}

*/
/**
27.適配器模式
將一種類型轉(zhuǎn)換為可以利用的類型
*/
/*
public class Notes{
    public  static void main(String [] args){
        PowerA a = new PowerAImpl();
        start(a);
        PowerB b = new PowerBImpl();
        PowerAAdapeter pa = new PowerAAdapeter(b);
        start(pa);
    }
    public static void start(PowerA powera){
        powera.start();
    }
}
class PowerAAdapeter implements PowerA{
    private PowerB powerb;
    public PowerAAdapeter(PowerB pb){
        this.powerb = pb;
    }
    public void start(){
        powerb.connect();
    }
}
interface PowerA{
    public void start();
}

interface PowerB{
    public void connect();
}

class PowerAImpl implements PowerA{
    public void start(){
        System.out.println("電源A已經(jīng)開始工作···");
    }
}
class PowerBImpl implements PowerB{
    public void connect(){
        System.out.println("電源B已經(jīng)開始工作···");
    }
}

*/
/**
28.內(nèi)部類
1.類中內(nèi)部的類
*/
//1.成員內(nèi)部類
/*
public class Notes{
    public static void main(String [] args){
        
        Dog dg = new Dog("小白");
        dg.desc();
        dg.childTalk();
        /*外部定義內(nèi)部類
        Dog.ChildDog child = null;
        child = dg.new ChildDog();
        child.say();
        
    }
}

//內(nèi)部類（成員內(nèi)部類）
class Dog{
    private String name;
    public Dog(String name){
        this.name = name;
    }
    public void desc(){
        System.out.println("我是一只狗，主人叫我"+name);
    }
    
    
    
    class ChildDog{
        
        public void say(){
            System.out.println("我是一只狗狗，我媽是"+name);
        }
    }
    public void childTalk(){
        ChildDog cd = new ChildDog();
        cd.say();
    }
}

*/
//2.方法內(nèi)部類
public class Notes{
    public static void main(String [] args){
        Dog dg = new Dog("小白");
        dg.desc();
        Child cd = dg.childTalk();
        cd.talk();
    }
}

/*
方法內(nèi)部類
1.只能在定義內(nèi)部類的方法（childTalk）內(nèi)實例化
2.方法內(nèi)部類對象不能使用該方法（childTalk）內(nèi)的非final局部變量
*//*
interface Child{
    public void talk();
}
class Dog{
    private String name;
    public Dog(String name){
        this.name = name;
    }
    public void desc(){
        System.out.println("我是一只狗，主人叫我"+name);
    }
    Child child;
    //在方法里面聲明一個內(nèi)部類,其中使用的變量全部是final
    public Child childTalk(){
            class ChildDog implements Child {
                public void talk(){
                    System.out.println("我是一只狗狗，我媽是"+name);
            }
        }
        ChildDog c = new ChildDog();
        c.talk();
        return c;
    }
}*/

//3.靜態(tài)內(nèi)部類,一個靜態(tài)內(nèi)部類相當(dāng)于一個外部類
public class Notes{
    public static void main(String [] args){
        Dog.ChildDog child = new Dog.ChildDog();
        child.talk();
    }
}

class Dog{
    private String name;
    public Dog(){}
    public Dog(String name){
        this.name = name;
    }
    public void desc(){
        System.out.println("我是一只狗，主人叫我"+name);
    }
    //privat,static 只能使用在內(nèi)部類
    static class ChildDog{
        public void talk(){
            System.out.println("我是一只狗狗");
        }
    }    
}

//4.匿名內(nèi)部類
/*原則
1.不能有構(gòu)造方法，只能有一個實例
2.不能定義靜態(tài)成員，方法
3.不能是public，protected，static，private
4.一定在new后
5.局部的使用
*/
/*
public class Notes{
    public static void main(String [] args){
        //(1)繼承式內(nèi)部類
        Dog dog = new Dog("小白"){
            public void desc(){
                System.out.println("我是一只母狗，主人叫我"+getName());
            }
        };
        dog.desc();
        //(2)接口式內(nèi)部類
        Child child = new Child(){
            public void desc(){
                System.out.println("我是一只狗狗");
            }
        };
        child.desc();
        //(3)參數(shù)式的匿名內(nèi)部類
        dog.childTalk(new Child(){
            public void desc(){
                System.out.println("我是一只小狗狗");
            }        
        });
    }
    /*public static void childTalk(Child c){
        c.desc();
    }*//*
}
interface Child{
    public void desc();
}
class Dog{
    private String name;
    public Dog(){}
    public Dog(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void desc(){
        System.out.println("我是一只狗，主人叫我"+name);
    }
    public void childTalk(Child c){
        c.desc();
    }
}*/

/**
29.鏈表
*/
//簡單的遞歸實現(xiàn)
public class Notes{
    public static void main(String [] args){
        System.out.println(fact(5));
    }
    public static int fact(int num){
        if(num == 1)
            return 1;
        else{
            return fact(num-1)*num;
        }
    }
}


public class Notes{
    public static void main(String [] args){
        NodeManager nm = new NodeManager();
        nm.addNode("節(jié)點1");
        nm.addNode("節(jié)點2");
        nm.addNode("節(jié)點3");
        nm.addNode("節(jié)點4");
        nm.addNode("節(jié)點5");
        nm.addNode("節(jié)點6");
        nm.addNode("節(jié)點7");
        nm.printNode();
        nm.deleteNode("節(jié)點3");
        nm.printNode();
    }
}
//鏈表管理
class NodeManager{
    private Node root;
    public void addNode(String name){
        if(root==null){
            root = new Node(name);
        }else{
            root.add(name);
        }
    }
    public void deleteNode(String name){
        if(root!=null){
            if(root.name.equals(name)){
                root = root.next;
            }
            else{
                root.del(name);
            }
        }
        
    }
    public void printNode(){
        if(root!=null){
            System.out.print(root.name);
            root.print();
            System.out.println();
        }
    }
    class Node{
        private String name;
        private Node next;
        public Node(String name){
            this.name = name;
        } 
        public void add(String name){
            if(this.next==null){
                this.next = new Node(name);
            }else{
                this.next.add(name);
            }
        }
        public void del(String name){
            if(this.next!=null){
                if(this.next.name.equals(name)){
                    this.next = this.next.next;
                }
                else{
                    this.next.del(name);
                }
            }
        }
        public void print(){
            if(this.next!=null){
                System.out.print("-->"+this.next.name);
                this.next.print();
            }
        }
    }
}