1:成員變量和局部變量的區別(理解)
(1)在類中的位置不同
成員變量：類中方法外
局部變量：方法定義中或者方法聲明上
(2)在內存中的位置不同
成員變量：在堆中
局部變量：在棧中
(3)生命週期不同
成員變量：隨着對象的創建而存在，隨着對象的消失而消失
局部變量：隨着方法的調用而存在，隨着方法的調用完畢而消失
(4)初始化值不同
成員變量：有默認值
局部變量：沒有默認值，必須定義，賦值，然後才能使用
2:封裝(理解)
A:隱藏實現細節，提供公共的訪問方式
B:提高代碼的複用性
C:提高代碼的安全性
D：隱藏實現細節，提供公共的訪問方式
E：private是封裝的一種體現。
(3)設計原則
把不想讓外界知道的實現細節給隱藏起來，提供公共的訪問方式
爲什麼要封裝（理解）？
1.將數據封裝起來更容易維護代碼。
2.將相關聯的變量和函數封裝起來，變量描述對象的屬性，函數描述對象的行爲，這更符合我們對客觀世界的認識。
3.限制了數據訪問，提高了代碼數據的安全性。
構造方法：
1.方法名與類名相同。
2.沒有返回值類型，連void都沒有。
3.沒有返回值
static（理解）:靜態變量，可以修飾成員變量，成員方法。
1.隨着類的加載而加載。
2.優先於對象存在
3.被類的所以對象所共享
4.可以通過類名調用。
靜態變量和成員變量的區別（理解）：
A:所屬不同
靜態變量：屬於類，類變量
成員變量：屬於對象，對象變量，實例變量
B:內存位置不同
靜態變量：方法區的靜態區
成員變量：堆內存
C:生命週期不同
靜態變量：靜態變量是隨着類的加載而加載，隨着類的消失而消失
成員變量：成員變量是隨着對象的創建而存在，隨着對象的消失而消失
D:調用不同
靜態變量：可以通過對象名調用，也可以通過類名調用
成員變量：只能通過對象名調用
繼承的理解（必須理解）
概述：把多個類中相同的成員變量和成員方法給提取出來定義到一個獨立的類中，然後讓多個類和該獨立的類產生關係。
好處：
A:提高了代碼的複用性
B:提高了代碼的維護性
C:讓類與類之間產生了關係，是多態的前提
類與類產生了關係，其實也是繼承的一個弊端：
類的耦合性增強了。
開發的原則：低耦合，高內聚。
耦合：類與類的關係
內聚：就是自己完成某件事情的能力
繼承的注意事項：
A:子類只能繼承父類所有非私有的成員(成員方法和成員變量)
B:子類不能繼承父類的構造方法，但是可以通過super關鍵字去訪問父類構造方法。
C:不要爲了部分功能而去繼承
D：從一定意義上說打破了封裝性
案列：
class Person {
//姓名
private String name;
//年齡
private int age;
public Person() {
}
public Person(String name,int age) { //"老子",88
this.name = name;
this.age = age;
}
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;
}
}
//定義學生類
class Student extends Person {
public Student() {}
public Student(String name,int age) { //"孔子",44
//this.name = name;
//this.age = age;
super(name,age);
}
}
//定義老師類
class Teacher extends Person {
}
class ExtendsTest4 {
public static void main(String[] args) {
//創建學生對象並測試
Student s1 = new Student();
s1.setName("哈哈");
s1.setAge(17);
System.out.println(s1.getName()+"---"+s1.getAge());
Student s2 = new Student("呵呵",22);
System.out.println(s2.getName()+"---"+s2.getAge());
}
}
1：方法重寫和方法重載的區別?方法重載能改變返回值類型嗎?
方法重寫：
在子類中，出現和父類中一模一樣的方法聲明的現象。
方法重載：
同一個類中，出現的方法名相同，參數列表不同的現象。
1:final關鍵字(掌握)
(1)是最終的意思，可以修飾類，方法，變量。
(2)特點：
A:它修飾的類，不能被繼承。
B:它修飾的方法，不能被重寫。
C:它修飾的變量，是一個常量。
多態（理解+掌握）
概述：同一個對象在不同時刻體現出不同的狀態。
案列
貓是貓，貓是動物。
水（固態，液態，氣態）
水(液體，固體，氣態)。
多態的前提：
要有繼承和實現關係
有方法的重寫
有父類指或者父類接口引用指向子類對象。
多態的分類：
a:具體類多態
class Fu {}
class Zi extends Fu {}
Fu f = new Zi();
b:抽象類多態
abstract class Fu {}
class Zi extends Fu {}
Fu f = new Zi();
c:接口多態
interface Fu {}
class Zi implements Fu {}
Fu f = new Zi();
(4)多態的好處：
A:提高代碼的維護性(繼承體現)
B:提高代碼的擴展性(多態體現)
(5)多態的弊端：
父不能使用子的特有功能。
案列：（貓狗）
動物類
class Animal {
public void eat(){
System.out.println("eat");
}
public void sleep(){
System.out.println("sleep");
}
}
狗類：
class Dog extends Animal {
public void eat(){
System.out.println(“狗看家”);
}
public void sleep(){
System.out.println("蹲着睡覺吧！");
}
}
貓類：
class Cat extends Animal {
public void eat() {
System.out.println("貓偷魚");
}
public void sleep() {
System.out.println("貓橫着睡覺");
}
}
//針對動物操作的工具類
class AnimalTool {
private AnimalTool(){}
/*
//調用貓的功能
public static void useCat(Cat c) {
c.eat();
c.sleep();
}
//調用狗的功能
public static void useDog(Dog d) {
d.eat();
d.sleep();
}
public static void useAnimal(Animal a) {
a.eat();
a.sleep();
}
}
測試類
class DuoTaiDemo2
{
public static void main(String[] args) {
//貓1
Cat c = new Cat();
c.eat();
c.sleep();
//貓2
Cat c2 = new Cat();
c2.eat();
c2.sleep();
//貓3
Cat c3 = new Cat();
c3.eat();
c3.sleep();
//...
System.out.println("--------------");
//useCat(c);
//useCat(c2);
//useCat(c3);
//AnimalTool.useCat(c);
//AnimalTool.useCat(c2);
//AnimalTool.useCat(c3);
AnimalTool.useAnimal(c);
AnimalTool.useAnimal(c2);
AnimalTool.useAnimal(c3);
System.out.println("--------------");
//我喜歡狗
Dog d = new Dog();
Dog d2 = new Dog();
Dog d3 = new Dog();
//AnimalTool.useDog(d);
//AnimalTool.useDog(d2);
//AnimalTool.useDog(d3);
AnimalTool.useAnimal(d);
AnimalTool.useAnimal(d2);
AnimalTool.useAnimal(d3);
System.out.println("--------------");
//豬
//定義一個豬類，它要繼承自動物，提供兩個方法，並且還得在工具類中添加該類方法調用
Pig p = new Pig();
Pig p2 = new Pig();
Pig p3 = new Pig();
//AnimalTool.usePig(p);
//AnimalTool.usePig(p2);
//AnimalTool.usePig(p3);
AnimalTool.useAnimal(p);
AnimalTool.useAnimal(p2);
AnimalTool.useAnimal(p3);
System.out.println("--------------");
}
/*
//調用貓的功能
public static void useCat(Cat c) {
c.eat();
c.sleep();
}
//調用狗的功能
public static void useDog(Dog d) {
d.eat();
d.sleep();
}
}
抽象（理解+掌握）
抽象的概念：
抽象是從衆多的事物中抽取出共同的、本質性的特徵，而捨棄其非本質的特徵。例如蘋果、香蕉、生梨、葡萄、桃子等，它們共同的特性就是水果。得出水果概念的過程，就是一個抽象的過程
抽象的語法遵循：
1、一個類中如果有抽象方法，則這個類必須是抽象類。
2、抽象類中可以沒有抽象方法。
3、抽象類是不能存在實例對象的，換句話說就是抽象類就是爲了被繼承而存在的。
4、一個子類如果繼承了抽象類，必須實現抽象類中定義的所有抽象方法。
5、抽象類可以繼承抽象類，可以不重寫父類的方法。
案列：
abstract不能和哪些關鍵字共存?
private 衝突
final 衝突
static 無意義
接口
接口是：是一系列方法的聲明，是一些方法特徵的集合，一個接口只有方法的特徵沒有方法的實現，因此這些方法可以在不同的地方被不同的類實現
java接口的用處主要體現在下面幾個方面：
（1）通過接口可以實現不相關類的相同行爲，而不需要了解對象所對應的類。
（2）通過接口可以指明多個類需要實現的方法。
（3）通過接口可以瞭解對象的交互界面，而不需瞭解對象所對應的類。
接口的用途：
實現類的多繼承，以解決Java只能單繼承，不支持多繼承的問題（理解好了有很大的幫助）
(2)接口的特點：
A:接口用關鍵字interface修飾
interface 接口名 {}
B:類實現接口用implements修飾
class 類名 implements 接口名 {}
C:接口不能實例化
D:接口的實現類
a:是一個抽象類。
b:是一個具體類，這個類必須重寫接口中的所有抽象方法。
3接口的成員特點：
A:成員變量
只能是常量
默認修飾符：public static final
B:構造方法
沒有構造方法
C:成員方法
只能是抽象的
默認修飾符：public abstract
類與類,類與接口,接口與接口
A:類與類
繼承關係，只能單繼承，可以多層繼承
B:類與接口
實現關係，可以單實現，也可以多實現。
還可以在繼承一個類的同時，實現多個接口
C:接口與接口
繼承關係，可以單繼承，也可以多繼承
抽象類和接口的區別：
A:成員區別
抽象類：
成員變量：可以變量，也可以常量
構造方法：有
成員方法：可以抽象，也可以非抽象
接口：
成員變量：只可以常量
成員方法：只可以抽象
B:關係區別
類與類
繼承，單繼承
類與接口
實現，單實現，多實現
接口與接口
繼承，單繼承，多繼承`
object類的簡單講解：
每個班都有Object作爲超類。 所有對象（包括數組）都實現了這個類的方法
每個類都直接或者間接繼承object類
Object()是無參構造所以很多類訪問的無參構造
object的一些常用的方法：
clone()
創建並返回此對象的副本。
boolean equals(Object obj)
指示一些其他對象是否等於此。
protected void finalize()
當垃圾收集確定不再有對該對象的引用時，垃圾收集器在對象上調用該對象。
getClass()
返回此 Object的運行時類。
int hashCode()
返回對象的哈希碼值。
void notify()
喚醒正在等待對象監視器的單個線程。
void notifyAll()
喚醒正在等待對象監視器的所有線程。
String toString()
返回對象的字符串表示形式。
void wait()
導致當前線程等待，直到另一個線程調用該對象的 notify()方法或
notifyAll()方法。
void wait(long timeout)
導致當前線程等待，直到另一個線程調用 notify()方法或該對象的
notifyAll()方法，或者指定的時間已過。
void wait(long timeout, int nanos)
導致當前線程等待，直到另一個線程調用該對象的 notify()方法或 notifyAll()方法，或者某些其他線程中斷當前線程，或一定量的實時時間。
String的簡單運用
String類的概述和使用(掌握)
(2)構造方法：
A:public String()
B:public String(byte[] bytes)
C:public String(byte[] bytes,int offset,int length)
D:public String(char[] value)
E:public String(char[] value,int offset,int count)
F:public String(String original)
A:==和equals()
String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2);// false
System.out.println(s1.equals(s2));// true
String s3 = new String("hello");
String s4 = "hello";
System.out.println(s3 == s4);// false
System.out.println(s3.equals(s4));// true
String s5 = "hello";
String s6 = "hello";
System.out.println(s5 == s6);// true
System.out.println(s5.equals(s6));// true
B:字符串的拼接
String s1 = "hello";
String s2 = "world";
String s3 = "helloworld";
System.out.println(s3 == s1 + s2);// false
System.out.println(s3.equals((s1 + s2)));// true
String的判斷功能
String類的判斷功能：
* boolean equals(Object obj):比較字符串的內容是否相同,區分大小寫
*
* boolean equalsIgnoreCase(String str):比較字符串的內容是否相同,忽略大小寫
*
* boolean contains(String str):判斷大字符串中是否包含小字符串
*
* boolean startsWith(String str):判斷字符串是否以某個指定的字符串開頭
*
* boolean endsWith(String str):判斷字符串是否以某個指定的字符串結尾
*
* boolean isEmpty():判斷字符串是否爲空。
*
String的獲取功能
----------
* int length():獲取字符串的長度。
*
* char charAt(int index):獲取指定索引位置的字符
*
* int indexOf(int ch):返回指定字符在此字符串中第一次出現處的索引。
* 爲什麼這裏是int類型，而不是char類型?
*
* 原因是：'a'和97其實都可以代表'a'
*
* int indexOf(String str):返回指定字符串在此字符串中第一次出現處的索引。
*
* int indexOf(int ch,int fromIndex):返回指定字符在此字符串中從指定位置後第一次出現處的索引。
*
* int indexOf(String str,int fromIndex):返回指定字符串在此字符串中從指定位置後第一次出現處的索引。
*
* String substring(int start):從指定位置開始截取字符串,默認到末尾。