1. 引數傳遞

1.1 類名作為形參和返回值

1、類名作為方法的形參

方法的形參是類名，其實需要的是該類的物件

實際傳遞的是該物件的【地址值】

2、類名作為方法的返回值

方法的返回值是類名，其實返回的是該類的物件

實際傳遞的，也是該物件的【地址值】

 1 class Cat {
 2 　　public void eat() {
 3 　　　　System.out.println("貓吃魚");
 4 　　}
 5 }
 6 class CatOperator {
 7 　　public void useCat(Cat c) { //Cat c = new Cat();
 8 　　　　c.eat();
 
 9 　　}
10 　　public Cat getCat() {
11 　　　　Cat c = new Cat();
12 　　return c;
13 　　}
14 }
15 public class CatDemo {
16 　　public static void main(String[] args) {
17 　　　　//建立操作類物件，並呼叫方法
18 　　　　CatOperator co = new CatOperator();
19 　　　　Cat c = new Cat();
20 　　　　co.useCat(c);
21 　　　　Cat c2 = co.getCat(); //new Cat()
 

22 　　　　c2.eat();
23 　　}
24 }

1.2 抽象類作為形參和返回值

抽象類作為形參和返回值

方法的形參是抽象類名，其實需要的是該抽象類的子類物件

方法的返回值是抽象類名，其實返回的是該抽象類的子類物件

 1 abstract class Animal {
 2 　　public abstract void eat();
 3 }
 4 class Cat extends Animal {
 5 　　@Override
 6 　　public void eat() {
 7 　　　　System.out.println("貓吃魚");
 8 　　}
 9 }
10 class
 
 AnimalOperator {
11 　　public void useAnimal(Animal a) { //Animal a = new Cat();
12 　　　　a.eat();
13 　　}
14 　　public Animal getAnimal() {
15 　　　　Animal a = new Cat();
16 　　return a;
17 　　}
18 }
19 public class AnimalDemo {
20 　　public static void main(String[] args) {
21 　　　　//建立操作類物件，並呼叫方法
22 　　　　AnimalOperator ao = new AnimalOperator();
23 　　　　Animal a = new Cat();
24 　　　　ao.useAnimal(a);
25 　　　　Animal a2 = ao.getAnimal(); //new Cat()
26 　　　　a2.eat();
27 　　}
28 }

1.3 介面名作為形參和返回值

介面作為形參和返回值

方法的形參是介面名，其實需要的是該介面的實現類物件

方法的返回值是介面名，其實返回的是該介面的實現類物件

 1 interface Jumpping {
 2 　　void jump();
 3 }
 4 class JumppingOperator {
 5 　　public void useJumpping(Jumpping j) { //Jumpping j = new Cat();
 6 　　　　j.jump();
 7 　　}
 8 　　public Jumpping getJumpping() {
 9 　　　　Jumpping j = new Cat();
10 　　return j;
11 　　}
12 }
13 class Cat implements Jumpping {
14 　　@Override
15 　　public void jump() {
16 　　　　System.out.println("貓可以跳高了");
17 　　}
18 }
19 public class JumppingDemo {
20 　　public static void main(String[] args) {
21 　　　　//建立操作類物件，並呼叫方法
22 　　　　JumppingOperator jo = new JumppingOperator();
23 　　　　Jumpping j = new Cat();
24 　　　　jo.useJumpping(j);
25 　　　　Jumpping j2 = jo.getJumpping(); //new Cat()
26 　　　　j2.jump();
27 　　}
28 }

2. 內部類

2.1 內部類的基本使用

內部類概念

　　在一個類中定義一個類。舉例：在一個類A的內部定義一個類B，類B就被稱為內部類

內部類定義格式

1 class 外部類名{
2 　　修飾符 class 內部類名{
3 　　}
4 }

內部類的訪問特點

　　內部類可以直接訪問外部類的成員，包括私有

　　外部類要訪問內部類的成員，必須建立物件

2.2 成員內部類

成員內部類的定義位置

　　在類中方法，跟成員變數是一個位置

外界建立成員內部類格式

1 外部類名.內部類名 物件名 = 外部類物件.內部類物件;

成員內部類的推薦使用方案

　　將一個類，設計為內部類的目的，大多數都是不想讓外界去訪問，所以內部類的定義應該私有化，私有化之後，再提供一個可以讓外界呼叫的方法，方法內部建立內部類物件並呼叫。

2.3 區域性內部類

區域性內部類定義位置

　　區域性內部類是在方法中定義的類

區域性內部類方式方式

　　區域性內部類，外界是無法直接使用，需要在方法內部建立物件並使用

　　該類可以直接訪問外部類的成員，也可以訪問方法內的區域性變數

 1 class Outer {
 2 　　private int num = 10;
 3 　　public void method() {
 4 　　　　int num2 = 20;
 5 　　　　class Inner {
 6 　　　　　　public void show() {
 7 　　　　　　　　System.out.println(num);
 8 　　　　　　　　System.out.println(num2);
 9 　　　　　　}
10 　　　　}
11 　　Inner i = new Inner();
12 　　i.show();
13 　　}
14 }
15 public class OuterDemo {
16 　　public static void main(String[] args) {
17 　　　　Outer o = new Outer();
18 　　　　o.method();
19 　　}
20 }

2.4 匿名內部類

匿名內部類的前提

　　存在一個類或者介面，這裡的類可以是具體類也可以是抽象類

匿名內部類的格式

1 new 類名 ( ) { 重寫方法 } new 介面名 ( ) { 重寫方法 }

匿名內部類的本質

　　本質：是一個繼承了該類或者實現了該介面的子類匿名物件

匿名內部類的細節

　　匿名內部類可以通過多型的形式接受

1 Inter i = new Inter(){
2 　　@Override
3 　　public void method(){
4 　　}
5 }

匿名內部類直接呼叫方法

 1 interface Inter{
 2 　　void method();
 3 }
 4 class Test{
 5 　　public static void main(String[] args){
 6 　　　　new Inter(){
 7 　　　　　　@Override
 8 　　　　　　public void method(){
 9 　　　　　　　　System.out.println("我是匿名內部類");
10 　　　　　　}
11 　　　　}.method(); // 直接呼叫方法
12 　　}
13 }

2.4 匿名內部類在開發中的使用

匿名內部類在開發中的使用

　　當發現某個方法需要，介面或抽象類的子類物件，我們就可以傳遞一個匿名內部類過去，來簡化傳統的程式碼

 1 interface jump{
 2     public abstract void jump();
 3 }
 4 
 5 class cat implements jump{
 6     @Override
 7     public void jump(){
 8         System.out.println("貓跳高");
 9     }
10 }
11 
12 class dog implements jump{
13     @Override
14     public void jump(){
15         System.out.println("狗跳高");
16     }
17 }
18 
19 class jo{
20     public void method(jump j){
21         j.jump();
22     }
23 }
24 
25 public class JumpingDemo {
26     public static void main(String[] args) {
27         jo j = new jo();
28         jump c = new cat();
29         j.method(c);
30         System.out.println("------");
31         jump d = new dog();
32         j.method(d);
33         System.out.println("------");
34         j.method(new jump() {
35             @Override
36             public void jump() {
37                 System.out.println("魚跳高");
38             }
39         });
40     }
41 }

3. 常用API

3.1 Math

1、Math類概述

　　Math 包含執行基本數字運算的方法

2、Math中方法的呼叫方式

　　Math類中無構造方法，但內部的方法都是靜態的，則可以通過 類名.進行呼叫

3、Math類的常用方法

3.2 System

System類的常用方法

3.3 Object類的toString方法

Object類概述

　　Object 是類層次結構的根，每個類都可以將 Object 作為超類。所有類都直接或者間接的繼承自該類， 換句話說，該類所具備的方法，所有類都會有一份

toString方法的作用

　　以良好的格式，更方便的展示物件中的屬性值

3.4 Object類的equals方法

equals方法的作用

　　用於物件之間的比較，返回true和false的結果

重寫equals方法的場景

　　不希望比較物件的地址值，想要結合物件屬性進行比較的時候。

3.5 Arrays

Arrays的常用方法

工具類設計思想

　　1、構造方法用 private 修飾

　　2、成員用 public static 修飾