面向對象
1、對於面向對象思想，強調的是對象（實體）
特點：面向對象就是一種常見的思想，符合人們的思考習慣
面向對象的出現，將複雜問題簡單化
面向對象的出現，讓曾經過程的執行者變成了對象的指揮者
2、類與對象：用java語言將現實生活中對事物的描述通過類的形式表現出來。（對事物的描述往往只關注兩方面：屬性和行爲)
類：對事物的描述(事物的屬性和行爲)
對象：該事物的實例,在java中用new來創建
匿名對象：沒名字的對象 例：new Car();
對象創建圖解
一個對象的內存圖解
兩個對象的內存圖解
三個對象的內存圖解
匿名對象：就是創建對象的時候,沒有名字的對象
匿名對象在實際開發中,只使用一次,不要使用多次 ,否則可能會造成內存溢出的現象;
代碼演示
package org.westos.noname;
/**
* 匿名對象:
* 就是創建對象的時候,沒有名字的對象
* @author Administrator
*
*/
//定義一個學生類
class Student{
String name ;
int age ;
public void show() {
System.out.println(name+"---"+age);
}
}
//學生類的測試類
public class StudentDemo {
public static void main(String[] args) {
//創建一個學生類對象
Student s = new Student() ;//該對象名s
s.name = "高圓圓" ;
s.age = 28 ;
s.show();
System.out.println("------------------");
//匿名對象(開發中經常使用),沒有名字的對象
System.out.println(new Student());//org.westos.noname.Student@70dea4e
new Student().name = "趙又廷" ;
/**
* 匿名對象在實際開發中,只使用一次,不要使用多次 ,否則可能會造成內存溢出的現象;
*/
new Student() ; //一直給堆內存開闢空間
new Student () ;
}
}構造函數：
函數名與類名相同、不用定義返回值類型、沒有具體的返回值類型
作用：給對象進行初始化，多個構造函數以重載的形式存在
一個類中如果沒有構造函數，那麼系統將會自動調用該類的默認構造函數(該默認構造函數是無參的)，如果有自定義的構造函數，那麼系統就不會調用默認構造函數。
構造函數與一般函數的區別：構造函數，對象在創建的時候就會調用所對應構造函數來對對象進行初始化，而一般函數在對象創建後等到需要函數功能時才調用。
注意事項：
1)之前沒有寫無參構造,系統會默認提供無參構造
2)如果我們定義了無參構造或者有參構造,系統不會再提供無參構造;定義一個類的時候,永遠給出無參構造函數;
無參構造函數
package org.westos.構造方法;
/**
* 構造方法作用:
* 就是給對象進行初始化
*
* 構造方法也屬於類的組成:
* 成員變量
* 構造方法
* 成員方法
*
* 構造方法:
* 1)方法名和類名相同
* 2)構造方法,連void都沒有
* @author Administrator
*
*/
//創建一個學生類
class Student{
//構造方法
public Student() {
System.out.println("這是一個無參構造方法...");
}
}
public class ConstructorDemo {
public static void main(String[] args) {
//創建一個學生對象
Student s = new Student() ;
System.out.println(s);//包名.類名@十六進制數據;
}
}有參構造函數
package org.westos.構造方法;
/**
* 構造方法的注意事項:
* 1)之前沒有寫無參構造,系統會默認提供無參構造
* 2)如果我們定義了無參構造或者有參構造,系統不會再提供無參構造;定義一個類的時候,永遠給出無參構造函數;
*
*
* 構造方法是可以重載的:
*
* 面試題:
* 有一個學生類:Student 裏面有一些屬性
* 在測試類中創建學生類對象,經歷了哪些屬性:
* Student s = new Student() ;
*
* @author Administrator
*
*/
//創建一個老師類
class Teacher{
private String name ;
private int age ;
//SetXXX()/GetXXX()方法:公共訪問方法
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;
}
//無參構造
public Teacher() {
System.out.println("老師類的無參構造..");
}
//有參構造
public Teacher(String name) { //第一種有參構造函數
this.name = name;
System.out.println("帶一個String類型參數的有參構造");
}
public Teacher(int age) { //第二種有參構造函數
this.age =age ;
System.out.println("帶一個int類型參數的有參構造");
}
//帶兩個參數
public Teacher(String name,int age) { //第三種有參構造函數
this.name =name ;
this.age = age ;
System.out.println("帶兩個參數的有參構造...");
}
}
//測試類
public class ConstructorDemo2 {
public static void main(String[] args) {
//創建一個老師類對象
Teacher t = new Teacher() ;
t.setName("張三");
t.setAge(27);
System.out.println(t.getName()+"----"+t.getAge());
System.out.println("----------");
/**
* 給成員變量有兩種方式:
* 1)setXXX()公共的訪問方法
* 2)可以通過有參構造函數進行賦值
*/
t = new Teacher("高圓圓") ; //第一種有參構造函數
t.setAge(28);
System.out.println(t.getName()+"----"+t.getAge());
System.out.println("----------------");
t= new Teacher(27) ; //第二種有參構造函數
t.setName("趙又廷");
System.out.println(t.getName()+"----"+t.getAge());
System.out.println("----------------");
Teacher t2 = new Teacher("高圓圓", 27) ; //第三種有參構造函數
System.out.println(t2.getName()+"----"+t2.getAge());
}
this關鍵字
1)每個類的每個非靜態方法(沒有被static修飾)都會隱含一個this引用名稱，它指的是調用這個方法的對象(當前對象)。
2)當在方法中去使用本類中的非static屬性時，都會隱含地使用this關鍵字。
3)this可以看作是一個變量，它就是當前對象的引用
this關鍵字的用法一：
當類中某個非靜態方法中的參數名跟該類中的某個成員變量名相同時，爲了避免參數的作用範圍覆蓋了成員變量的作用範圍，必須明確地使用this關鍵字來指定成員變量。
package org.westos.this關鍵字;
/**
* 定義變量,方法,類,接口,做到見名知意
* 在手機類的公有方法中,對應的局部變量名稱應該做到見名知意
*
* 雖然做到見名知意了,但是局部變量會將成員變量隱藏掉,Java提供一個關鍵字:this
*
* this:代表是當前類的對象,或者是當前類對象的引用,解決了局部變量隱藏成員變量的情況
*
* @author Administrator
*
*/
//手機類
class Phone{
//私有修飾
private String brand ;
private int price ;
private String color ;
//成員方法
//提供公共的訪問方法
public void setBrand(String brand) {
// brand = brand ;
this.brand = brand;
}
//獲取手機品牌
public String getBrand() {
return brand ;
}
public void setPrice(int price) {
// price = price ;
this.price = price ;
}
public int getPrice() {
return price ;
}
public void setColor(String color) {
//color = color ;
this.color = color ;
}
public String getColor() {
return color ;
}
}
//測試類
public class Test {
public static void main(String[] args) {
//創建手機類對象
Phone p = new Phone() ;
p.setBrand("華爲");
p.setPrice(1999);
p.setColor("黑白");
System.out.println(p.getBrand()+"---"+p.getPrice()+"----"+p.getColor());
System.out.println("-----------------------");
Student s = new Student() ;
s.setName("高圓圓");
s.setAge(28);
s.setsId("xx002");
s.setGender('女');
s.setTitle("學習委員");
System.out.println(s.getName() + "----" + s.getAge() + "----" + s.getsId() + "----" + s.getGender() + "----"
+ s.getTitle());
}
}this關鍵字的用法二
如果某個構造方法中的第一條語句爲this(…)的形式，
那麼這個構造方法將調用本類中的其他構造方法
package org.westos.this關鍵字;
/**
* 學生類:
* 姓名,年齡,學號,性別,title(學生的職位)
* 學習,打遊戲...
*
*
* :
*
* @author Administrator
*
*/
public class Student {
//成員變量
private String name ;
private int age ;
private String sId;
private char gender ;
private String title ;
////提供setXXX/getXXX()方法 :先手寫 ,快捷鍵:alt+shift+s+r
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;
}
public String getsId() {
return sId;
}
public void setsId(String sId) {
this.sId = sId;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
//學習
public void study() {
System.out.println("學生愛Java...");
}
//打遊戲
public void playGame() {
System.out.println("學生玩戰地一戰風雲...");
}
}圖解
static關鍵字
1)在類中，用static聲明的成員變量稱爲靜態成員變量，它是該類的公用變量，對於該類的所有對象來說，static成員變量只有一份。
2)用static聲明的方法稱爲靜態方法，該方法獨立存在於類中，所以也稱爲類方法。
靜態方法中只能調用本類的靜態成員變量和靜態方法。（簡記：靜中只能有靜，動中既可以有動，也可以有靜）
靜態方法中不能使用this和super關鍵字。
3)靜態成員可以通過類名.靜態成員的方式去訪問或類的實例(對象.靜態成員)去訪問。
4)static關鍵字的特點：
- static優先於對象存在，因爲static所修飾的成員隨着類的加載而加載，之後纔會去創建類的實例(對象)。
- static所修飾的成員可以被所有對象所共享。static所修飾的是共享數據，而對象中存儲的是特有數據。
- 如果數據是靜態的,它可以被類名直接調用。被靜態修飾的方法: 類名.方法名()； 被靜態修飾的變量:類名.變量名;
5)注意事項
靜態方法中不能直接調用非靜態方法和非靜態成員變量，如果靜態方法中要調用靜態成員，則必須實例化靜態成員所在的類，即創建非靜態成員所在類的對象，用對象去掉用非靜態成員。
例：
class Demo{
public void function(){}
public static void function2(){
Demo a=new Demo();
a.function(); //用對象去間接調用非靜態方法
}
}代碼：
示例2
package org.westos.static關鍵字;
//自定義一個類
class Demo{
//非靜態的
int num = 100 ;
static int num2 = 200 ;
public void show() {
System.out.println(num);
System.out.println(num2);
}
public static void method() {
System.out.println("method demo...");
}
}
public class StaticDemo2 {
public static void main(String[] args) {
//創建Demo類的對象
Demo d = new Demo() ;
d.num = 50 ;
d.show();
System.out.println(Demo.num2);//直接用類名調用static成員變量
d.method(); //用對象調用static方法
Demo.method(); //直接用類名調用static方法
}
}
package org.westos.static關鍵字;
/**
* static用法:
*
* 一個類中可有靜態變量,也可以有非靜態變量
* 可以有靜態成員方法,也可以有非靜態成員方法
* 靜態的方法只能訪問靜態變量和靜態的方法
* 非靜態的方法,既可以訪問靜態變量，靜態方法，也可以非靜態的變量，非靜態的方法
*
* 簡單記:靜態只能訪問靜態
*
* @author Administrator
*
*/
class Student{
int num = 100 ;
public static int num2 = 200 ;
public void show() { //非靜態的
System.out.println(num);//隱式的去訪問成員變量 ,隱藏了一個關鍵字:this
// System.out.println(num2);隱式的去訪問成員變量 ,隱藏了一個關鍵字:this
System.out.println(this.num2);//顯示的去訪問靜態成員變量
function() ;//訪問靜態成員方法
}
public static void function() {
// show() ; show()爲非靜態的方法，靜態只能訪問靜態方法,不能訪問非靜態的方法
function2() ;//靜態方法可以去訪問靜態的方法
}
}
public static void function2() {
}
//測試類
public class StaticDemo3 {
public static void main(String[] args) {
//創建學生類對象
Student s = new Student() ;
s.show();
s.function();
s.function2();
}
}成員方法
類的組成中有一個成員:成員方法
成員方法的分類:
1)按照返回值劃分
void的形式:沒有具體的返回值
非void形式:有具體返回值
2)按照參數進行劃分
空參
有參
package org.westos.成員方法;
/**
* 類的組成中有一個成員:成員方法
* 成員方法的分類:
* 1)按照返回值劃分
* void的形式:沒有具體的返回值
* 非void形式:有具體返回值
* 2)按照參數進行劃分
* 空參
* 有參
* @author Administrator
*
*/
//創建一個學生類
class Student {
private String name ;
private String age ;
public Student() { //alt+shift+s+c
}
//成員方法
//有返回值沒有參數的
public String show() {
return "helloworld";
}
//沒有返回值,有參數的情況
public void method(String s) {
System.out.println(s);
}
//沒有返回值,沒有參數的情況
public void function() {
System.out.println("function student...");
}
//有返回值,有參數的情況
public String function2(String s1,String s2) {
return s1+s2;//返回值類型爲String
}
}
//測試類
public class Test {
public static void main(String[] args) {
//創建學生類對象
Student s = new Student() ;
String str = s.show() ;
System.out.println(str);
s.method("Java");
s.function();
String str2 = s.function2("hello", "world") ;
System.out.println(str2);
}
}
變量(variable)
成員變量和局部變量的區別
1)在類中位置不同
成員變量:在類中,方法外
局部變量:在方法聲明上(方法頭的括號中)或者在方法的定義中(方法體中)
2)在內存中的位置不同:
成員變量:堆內存
局部變量:棧內存
3)生命週期不同:
成員變量:成員變量是隨着類的加載而加載,隨着類的消失而消失
局部變量:隨着方法的調用而存在,隨着方法的調用完畢而消失
4)初始化值不同
成員變量:系統默認初始化,
局部變量:定義一個局部變量,在使用之前必須先進行初始化,如果不初始化,則無法使用
代碼示例:
package org.westos.variable;
class Variable{
//成員變量
int num = 10;
public void show() {
System.out.println(num);
}
}
//測試類
public class VariableDemo {
public static void main(String[] args) {
int num2 = 100 ;
System.out.println(num2);
//創建Vaiable類對象
Variable v = new Variable() ;
//使用對象名去訪問這個類中的成員變量和成員方法
System.out.println(v.num);
v.show();
}
}
standardclass
代碼:
package org.westos.standclass;
/***
* 一個標準類的寫法:
* 學生類
* 成員變量:姓名,年齡,性別
* 成員方法:set/getXXX()
* 學習,睡覺...
* 構造方法:
* 無參構造:
* 有參構造
* @author Administrator
*/
class Student{
//成員變量
private String name ;
private int age ;
private char gender ;
//無參構造方法
public Student() {}
//有參構造
public Student(String name,int age,char gender) {
this.name = name ;
this.age = age ;
this.gender = gender ;
}
//setXXX/getXXX()方法
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 setGender(char gender) {
this.gender= gender ;
}
public char getGender() {
return gender ;
}
//學習
public void study() {
System.out.println("學生在學習...");
}
public void sleep() {
System.out.println("學生困了,就需要睡覺...");
}
}
//測試類
public class StudentDemo {
public static void main(String[] args) {
//方式1:創建學生類對象
//無參構造+set/getXXX()相結合的方式
Student s = new Student() ;
s.setName("高圓圓");
s.setAge(28);
s.setGender('女');
System.out.println(s.getName()+"----"+s.getAge()+"---"+s.getGender());
System.out.println("----------------------------");
//方式2:直接通過有參構造形式
Student s2 = new Student("高圓圓", 27, '女') ;
System.out.println(s2.getName()+"----"+s2.getAge()+"---"+s2.getGender());
}
}形式參數的問題
形式參數的問題:
如果是基本數據類型,形式參數的改變對實際參數沒有影響
如果是引用類型,形式參數的改變會直接影響實際參數
代碼示例:
package org.westos.args;
/**
* 形式參數的問題:
* 如果是基本數據類型,形式參數的改變對實際參數沒有影響
* 如果是引用類型,形式參數的改變會直接影響實際參數
* @author Administrator
*
*/
class Demo{
//求和的成員方法
public int sum(int a,int b) { //形式參數爲基本類型 :
return a+b ;
}
}
//一個學生類
class Student{
public void show() {
System.out.println("好好學習,天天向上....");
}
}
class StudentDemo{
//method方法中形式參數是一個引用類型:需要的是學生類對象 Student s = new Student () ;
public void method(Student s) {//形式參數爲引用類型
s.show();
}
}
//測試類
public class ArgsTest {
public static void main(String[] args) {
//創建Demo類對象
Demo d = new Demo() ;
System.out.println(d.sum(10, 20)) ;
System.out.println("-------------------------");
//需求:調用StudentDemo中的method方法:如何調用
//1)創建StudentDemo類對象
StudentDemo sd = new StudentDemo() ;
//2)形式參數是Student類型,所以創建Student類的對象
Student s = new Student() ;
sd.method(s);
}
}