選擇
if(){
}else{
}
swich(score){
case 1:....;break;
case 2:....;break;
}
類中構造方法的原則是只實現自己的功能
String 是一個類,字符串常量池是堆中的一個存字符串值的一個集合,他的賦值方式有兩種
String name = new String ("張三"); 創建兩個對象字符串常量池和堆內存中;
String name = "張三";創建一個對象，推薦使用
字符串存在于常量池中
類的操作
1.類是一個具有相同屬性的集合，對象是其中的一的個例
類中包含屬性和方法，公共的屬性有對象調用
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.構造方法的重寫
默認為無參函數
構造方法和類名相同，為大寫開頭
重寫構造方法后自動覆蓋掉無參，若想調用即需寫出無參構造方法
構造方法可以寫多個
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)
條件：方法名相同，參數不同
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.直接在堆中開辟內存 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代表了一個常數
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.根據下標找字符
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.字符串變字符數組
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);//包含起始位置不包含結束位置
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.字符串的查找,替換,大小寫轉換,長度計算
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");//第一字母出現的位置,該單詞不存在返回-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.對象的一對一關系
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;//關聯是將對方的類作為屬性導入，關聯妻子類
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{
//實際操作中應該封裝
String name;
int age;
Husband husband;//關聯是將對方的類作為屬性導入，關聯丈夫類
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關鍵字
調用類中的屬性
調用類中的方法或構造方法
表示當前對象
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直接調用本類中的構造方法
}
public Bear(String name){
this(name,"公");
}
public Bear(String name,char sex){
this.name = name;
this.sex = sex;
this.bite();//調用本類中的方法，this可以省略
}
public void bite(){
System.out.println("我是" + sex + "熊--" + name);
}
}
11.static關鍵字
1.使用static的關鍵字修飾一個屬性，這個變量是一個全局變量
2.在類中定義一個方法為static那么無需本類中的對象即可調用該方法
3.使用static關鍵字修飾一個類
靜態方法和屬性在類加載后就存到方法區內存中，此時還沒有產生對象，
普通的方法和屬性都是屬于對象的
聲明為static的方法：
僅能調用其他的static方法，可以被普通的方法調用
只能訪問static的數據
不能以任何的方式引用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 = "小三";//使用類名修改靜態屬性，常用方法
m1.desc();
m2.desc();
Mistress.promosion();
m1.desc();
m2.desc();
}
}
class Mistress{
String name;
//String profession = "情人";
static String profession = "情人";//變成靜態屬性，不屬于對象的屬性，屬于類；
public Mistress(String name){
this.name = name;
}
public void desc(){
System.out.println("我的名字是"+name+",我的職業是"+profession);
}
//使用static關鍵字修飾一個方法，該方法屬于類，不屬于對象
public static void promosion(){
System.out.println("轉正了");
profession = "主婦";
}
}
*/
/**
13.蛋疼的數羊
靜態變量的使用
*/
/*
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.對象數組的使用
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.可變參數，(int...num)相當于數組，
如果有一個可變參數和不可變參數，不可變放在首位
靜態塊執行一次
單例設計模式Test1.java學習記錄*/
/**
類的繼承
屬性包括：protected（必須繼承的屬性）,private,public,default
繼承使用父類的方法和屬性（非私有）
構造方法無法被繼承
*/
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(){//方法的重寫，方法名，返回值，參數列表相同
super.desc();//super關鍵字，相當于this
System.out.println("我是一只家雞，名字叫"+name+"，今年"+age+"歲了。");
}
}
*/
/**
17.final關鍵字
1.修飾類不能被繼承
2.修飾變量為常量
(1).final int n = 3;
(2).在構造方法中賦值
(3).對類中對象賦值是內存地址不變，內容可變
3.修飾方法不能被重寫
*/
/**
18.抽象類
(1).多個具有相同特征和行為的類的集合是抽象類
(2).使用abstract聲明
(3).不能被實例化
(4).不能使用final修飾
(5).可以沒有抽象方法
(6).有抽象方法必須是抽象方法
(7).可以有構造方法
*/
/*
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）一組行為的規范、定義，沒有實現
2）使程序利于變化
3）面向對象中的精髓
4）面向對象的實際法則，基于接口編程
2.接口的定義
interface 聲明的類似與類的定義，其中只有常量和抽象方法，
不用abstract修飾
3.接口的規則
1）可以繼承多個接口interface A extends B,C,D{}
2）一個類可以實現多個接口，class A implements b,c,d{}
3）命名接口前面加I
4）抽象類實現接口不用實現接口的方法
5）接口中只能使用public，默認為public abstract 可以省略
6）接口中的屬性都是常量，默認為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{
//實現接口中所有得到方法
public void cry(){
System.out.println("好疼呀??！");
}
public void eat(){
System.out.println("一小口一小口的吃");
}
}
class Girl implements IHit,IEat{
//實現接口中所有得到方法
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.多態
1.多態是多種形態
2.兩種情況
1）方法的重寫和重載
2）對象的多態性
3.實際開發盡量使用父類引用
*/
/*
public class Notes{
public static void main(String [] name){
Person man = new Man();//父類的引用指向子類對象,向上轉型
man.say();
Person women = new Women();
women.say();
Man m = (Man)man;//大轉小，強制轉換；
m.say();
//Man mm = (Man)women;
//java.lang.ClassCastException類型轉換失敗，不能強轉，運行失敗
}
}
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關鍵字
父類優先考慮接口
盡量不要繼承一個具體類
*/
/*
public class Notes{
public static void main(String [] name){
Person man = new Man();//父類的引用指向子類對象,向上轉型
//man.say();
say(man);
Person women = new Women();
//women.say();
say(women);
Man m = (Man)man;//大轉小，強制轉換；
say(m);
//m.say();
//Man mm = (Man)women;
//java.lang.ClassCastException類型轉換失敗，不能強轉，運行失敗
}
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.繼承的應用與模版式設計
模版式設計是在父類中構建一個框架，在子類中實現可變的功能
*/
/*
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()){//調用自身的方法形成框架
System.out.println("恭喜你，進入靈鷲宮！");
}else{
System.out.println("抱歉，您失敗了！");
}
}
public abstract boolean competition();
}
class sheMale extends lingjiuPalace{
Random r = new Random();
public boolean competition(){
return r.nextBoolean();
}
}
*/
/**
23.接口的應用與策略設計模式
策略設計模式，封裝一系列的行為，抽象為接口，可變的行為
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();
}
}
//這是接口的方式實現
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;//接口相當于一個類型，作為一個屬性引入
public void setIsay(Isay isay){
this.isay = isay;
}
public Person(String name){
this.name = name;
}
public void say(){
isay.say();
}
}
//利用抽象類實現，調用方式省略了，只展示部分代碼
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.自動調用toString
3.equals(),自反性（自己和自己比）、對稱性（前后可以互換）、
傳遞性（a=b,b=c,則a=c）、一致性（如果字符布變，那比較結果不變））
4.使用Object類型傳輸數據
*/
/*
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){
//內存地址相等則為同一對象
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.簡單工廠模式
由工廠對象決定創建出哪一種產品類的實例
*/
/*
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.靜態代理模式
在代理中可以設置一些控制方法
*/
/*
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("本次相親結束");
}
public void miai(){
before();
Scanner in = new Scanner(System.in);
System.out.println("你給我多少錢？");
int key = in.nextInt();
if(key > 100000)
target.miai();
after();
}
}
*/
/**
27.適配器模式
將一種類型轉換為可以利用的類型
*/
/*
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已經開始工作···");
}
}
class PowerBImpl implements PowerB{
public void connect(){
System.out.println("電源B已經開始工作···");
}
}
*/
/**
28.內部類
1.類中內部的類
*/
//1.成員內部類
/*
public class Notes{
public static void main(String [] args){
Dog dg = new Dog("小白");
dg.desc();
dg.childTalk();
/*外部定義內部類
Dog.ChildDog child = null;
child = dg.new ChildDog();
child.say();
}
}
//內部類（成員內部類）
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.方法內部類
public class Notes{
public static void main(String [] args){
Dog dg = new Dog("小白");
dg.desc();
Child cd = dg.childTalk();
cd.talk();
}
}
/*
方法內部類
1.只能在定義內部類的方法（childTalk）內實例化
2.方法內部類對象不能使用該方法（childTalk）內的非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;
//在方法里面聲明一個內部類,其中使用的變量全部是final
public Child childTalk(){
class ChildDog implements Child {
public void talk(){
System.out.println("我是一只狗狗，我媽是"+name);
}
}
ChildDog c = new ChildDog();
c.talk();
return c;
}
}*/
//3.靜態內部類,一個靜態內部類相當于一個外部類
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 只能使用在內部類
static class ChildDog{
public void talk(){
System.out.println("我是一只狗狗");
}
}
}
//4.匿名內部類
/*原則
1.不能有構造方法，只能有一個實例
2.不能定義靜態成員，方法
3.不能是public，protected，static，private
4.一定在new后
5.局部的使用
*/
/*
public class Notes{
public static void main(String [] args){
//(1)繼承式內部類
Dog dog = new Dog("小白"){
public void desc(){
System.out.println("我是一只母狗，主人叫我"+getName());
}
};
dog.desc();
//(2)接口式內部類
Child child = new Child(){
public void desc(){
System.out.println("我是一只狗狗");
}
};
child.desc();
//(3)參數式的匿名內部類
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.鏈表
*/
//簡單的遞歸實現
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("節點1");
nm.addNode("節點2");
nm.addNode("節點3");
nm.addNode("節點4");
nm.addNode("節點5");
nm.addNode("節點6");
nm.addNode("節點7");
nm.printNode();
nm.deleteNode("節點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();
}
}
}
}
