重點掌握
1、類的定義
訪問權限控制符
? ? ? ? ? ? ? ? ? ? ? ? ?public? ? ? protected? ? ?default? ? ??private?
同一個類? ? ? ? ? ?可? ? ? ? ? ? ? ? ?可? ? ? ? ? ? ? ??可? ? ? ? ? ?可
同一個包? ? ? ? ? ? 可? ? ? ? ? ? ? ??可? ? ? ? ? ? ? ??可? ? ? ? ? ?
不同包但繼承? ? ?可? ? ? ? ? ? ? ??可
全局? ? ? ? ? ? ? ? ? ? 可
static 修飾符
如果一個類用static修飾，表示他是靜態的
static可以用來修飾類的成員方法、類的成員變量,代碼塊
一、實體類創建
第一種方式:無參構造+get/set
package com.neuedu.test.chap06;
public class XiYouJi {
//姓名
private String name;
//戰斗力
private int sword;
//耐力
private int endurance;
//武器
private String arms;
? ? //年令
private int age;
public XiYouJi() {
super();
System.out.println("無參構造方法被調用");
}
public String getMingzi() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getSword() {
return sword;
}
public void setSword(int sword) {
this.sword = sword;
}
public int getEndurance() {
return endurance;
}
public void setEndurance(int endurance) {
this.endurance = endurance;
}
public String getArms() {
return arms;
}
public void setArms(String arms) {
this.arms = arms;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
注意：方法調用：
實例化對象
類名??對象名= new?? 類名();
public static void main(String[] args) {
//創建對象一般有兩種方式
//第一種 清水房+逐步采購? 無參構造+各個屬性的set方法? =》各個屬性的設置
//缺點：逐步構建 代碼不夠簡潔
//優點：修改不會影響原有代碼
//適用于屬性經常變動的
XiYouJi swk = new XiYouJi();
swk.setName("孫悟空");
swk.setSword(5);
swk.setEndurance(5);
swk.setArms("金箍棒");
swk.setAge(18);
XiYouJi ts = new XiYouJi();
ts.setName("唐僧");
ts.setSword(0);
ts.setEndurance(5);
XiYouJi zbj = new XiYouJi();
zbj.setName("豬八戒");
zbj.setSword(2);
zbj.setEndurance(4);
swk.setArms("耙子");
}
}
構造方法
用來創建對象
特點：1）方法名與類名相同
2）沒有返回值 類型，并且沒有void占位
3）不需要return
分類：
分為無參構造和有參構造
如果我們實例化對象時如下寫：
類名? 對象名=new 類名();? 實際調用的是無參構造方法
如果你不寫無參構造 ，系統會為你自動生成一個。如果你寫了，就會調用你新寫的這個。
構造方法的重載
有參構造可以限制參數個數，通過重載實現
有參構造無參構造屬于方法重載
學生試驗：
把類的無參方法注釋掉，看發生什么現象
發現調用無參構造方法的地方報錯。
結論：
如果你在類中寫了有參構造，那么系統不會再幫你生成無參構造了，你如果還想用無參構造 ，就需要重載一下無參構造方法。
無參構造：
創建方式：右鍵-source-generate constructor from superclass
public XiYouJi() {
super();
System.out.println("無參構造方法被調用");
}
XiYouJi swk = new XiYouJi();
debug測試一下
學生練習：無參方法創建對象和對象賦值
有參構造：
創建方式：右鍵-source-generate constructor using fields
系統生成代碼如下：
//有參構造-經常用來一次性初始化參數
public XiYouJi(String name, int sword, int endurance, String arms, int age) {
super();
this.name = name;
this.sword = sword;
this.endurance = endurance;
this.arms = arms;
this.age = age;
}
調用方式：
@Test
public? void test2() {
//精裝房 拎包入住 有參構造 -創建同時把各個屬性初始化
//有參構造如何編寫
//優點：一次性構建，方便，代碼簡潔
//缺點：修改麻煩
//適用于屬性不經常變動的情況
XiYouJi swk2 = new XiYouJi("孫悟空", 5, 5, "金箍棒",18);
System.out.println(swk2.sword);
}
學生練習：
練習有參方法創建對象和為對象賦值
注意：
一旦編寫了有參構造，系統不會再為我們生成無參構造，如果想用無參構造，需要顯式編寫
其他方法的創建：
除了構造方法外，很多時候我們還需要編寫自己的業務方法。這些方法用于做業務。
課堂簡單演示：
1）編寫一個商品的類，要求包含商品名稱和商品價格，并且編寫一個方法能夠在控制臺輸出“商品名：價格”。并在主函數中調用
輸出示例：
可樂：2.5
鼠標：50
package com.neuedu.test.chap06;
/**
* 1）編寫一個商品的類，
* 要求包含商品名稱和商品價格，
* 并且編寫一個方法能夠在控制臺輸出“商品名：價格”。
* 并在主函數中調用
* @author Administrator
*
*/
public class Product {
//商品名稱
private String proName;
//商品價格
private double proPrice;
//編寫一個方法能夠在控制臺輸出“商品名：價格”。
public? void printDetail(){
System.out.println(this.proName+":"+this.proPrice);
}
public Product(String proName, double proPrice) {
super();
this.proName = proName;
this.proPrice = proPrice;
}
//并在主函數中調用
/*輸出示例：
可樂：2.5
鼠標：50*/
public String getProName() {
return proName;
}
public double getProPrice() {
return proPrice;
}
public static void main(String[] args) {
//實例化一個可樂商品
Product keli=new Product("可樂",2.5);
//調用可樂的方法打印可樂的詳情
keli.printDetail();
Product mouse=new Product("鼠標",50);
mouse.printDetail();
}
}
上面都演示的無返回值類型的方法，下面學習有返回值類型的方法
課堂練習，作業題2
定義一個矩形類Rectangle：
2.1? 有2個屬性：長length、寬width
2.2? 通過構造方法Rectangle(int width, int length)，分別給兩個屬性賦值
2.3? 定義三個方法：getArea()求面積、getPer()求周長，showAll()分別在控制臺輸出長、寬、面積、周長。
2.4? 創建一個Rectangle對象，并輸出相關信息
public class Rectangle {
//長
private double length;
//寬
private double width;
public Rectangle(double length, double width) {
super();
this.length = length;
this.width = width;
}
/**
* getArea()求面積
*/
public double getArea(){
double area=length*width;
return area;
}
? /**
? ? * getPer()求周長
? ? */
public double getPer(){
double girth=(this.length+this.width)*2;
return girth;
}
/**
* showAll()分別在控制臺輸出長、寬、面積、周長。
*/
public void showAll(){
System.out.println("長"+length);
System.out.println("寬"+width);
double result=getArea();
System.out.println("面積"+result);
double result2=getPer();
System.out.println("周長"+result2);
}
public static void main(String[] args) {
Rectangle rc=new Rectangle(13.4,5);
rc.showAll();
}
}
java 面向對象三大特征：
封裝? 繼承 多態
封裝
所謂封裝是把對象的屬性和行為結合在一個獨立的系統單位內部
盡可能隱蔽對象的內部細節，只向外部提供接口
繼承（inheritance）：
也稱泛化，繼承性是子類自動共享父類屬性和方法的機制，在定義和實現一個類的時候，可以在一個已經存在的類的基礎之上來進行，把這個已經存在的類所定義的內容作為自己的內容，并加入自己若干新的內容
多態（polymorphism）：
指同一個命名可具有不同的語義
OO方法中，常指在一般類中定義的屬性或方法被特殊類繼承之后，可以具有不同的數據類型或表現出不同的行為，對于子類，可用不同的方法替代實現父類的服務的方法
static關鍵字
可以修飾的元素
屬性
注意：只能修飾屬性，不能修飾局部變量。
方法
代碼塊
static修飾屬性：
所有對象共享，稱為靜態變量或類變量
不用static修飾的屬性稱為實例變量
static修飾方法：
不需要實例化，可以直接訪問，稱為靜態方法或類方法
static修飾語句塊：
類中由static關鍵字修飾的，不包含在任何方法體中的代碼塊，稱為靜態代碼塊
*static修飾的屬性、方法和代碼塊的特點
****用static修飾的屬性
它們在類被載入時創建，只要類存在，static變量就存在。
靜態變量和非靜態變量的區別是：靜態變量被所有的對象所共享，在內存中只有一個副本，它當且僅當在類初次加載時會被初始化。而非靜態變量是對象所擁有的，在創建對象的時候被初始化，存在多個副本，各個對象擁有的副本互不影響。
直接訪問：類名.屬性
靜態方法
靜態方法不需要實例化，可以直接訪問，訪問方式：
直接訪問：類名.方法名()
實例化后訪問：對象名.方法名() （不建議使用）
靜態語句塊
一個類中由static關鍵字修飾的，不包含在任何方法體中的代碼塊
當類被載入時，靜態代碼塊被執行，且只被執行一次
靜態塊經常用來進行類屬性的初始化
用static修飾的方法和不用static修飾的方法調用上的區別:
package com.neuedu.test.chap06;
import java.util.UUID;
public class StaticDemo {
//網站訪問計數器
//如果要把他變成共享計數器 他的值會動態變化
public static int count;
// 用static修飾的方法是靜態方法
public static String uudiUtil() {
// uuid生成器
return UUID.randomUUID().toString();
}
public StaticDemo() {
super();
System.out.println("構造方法被調用");
}
//在類實例化時就調用
//會在所有方法（包括構造方法）執行前被調用
//他適合做一些基本初始化(準備)工作
static{
System.out.println("我先被調用!");
}
public void print(){
System.out.println("print");
}
}
不用static修飾的方法調用是用：
第一步：把類實例化成對象
第二步：調用對象的方法
作業：
本章課后作業
選做題1
1)設計一個類Student，該類包括姓名、學號和成績。
2)設計一個方法，按照成績從高到低的順序輸出姓名、學號和成績信息。
public class Student {
/*
* 1)設計一個類Student，該類包括姓名、學號和成績。
* 2)設計一個方法，按照成績從高到低的順序輸出姓名、學號和成績信息。
*/
private String name;
private int id;
private int score;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int id, int score) {
super();
this.name = name;
this.id = id;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
//把成績亂序的數組轉化成按成績排序的數組
public void sortByScore(Student[] studs){
for(int i=1;i<studs.length;i++){
? for(int j=0;j<studs.length-i;j++){
? if(studs[j].getScore()<studs[j+1].getScore()){
? Student temp=studs[j];
? studs[j]=studs[j+1];
? studs[j+1]=temp;
? }
? }
}
}
public static void main(String[] args) {
Student s1=new Student("顧俊寧",100,84);
Student s2=new Student("李洋",101,94);
Student s3=new Student("王琦舒",102,66);
Student s4=new Student("高榮斌",104,82);
Student s5=new Student("劉元昊",105,98);
//System.out.println("s1---->"+s1);
//把上面四個學生放數組里
Student[] students=new Student[]{s1,s2,s3,s4,s5};
Student s=new Student();
s.sortByScore(students);
for(Student stu:students){
System.out.println(stu.getName());
System.out.println(stu.getScore());
System.out.println("----------->");
}
}
}
選做題
2、定義一個汽車類Vehicle，要求如下：[選做題]
2.1屬性包括：汽車品牌brand（String類型）、顏色color（String類型）和速度speed（double類型），并且所有屬性為私有。
2.2至少提供一個有參的構造方法（要求品牌和顏色可以初始化為任意值，但速度的初始值必須為0）。
2.3為私有屬性提供訪問器方法。注意：汽車品牌一旦初始化之后不能修改。
2.4定義一個一般方法run()，用打印語句描述汽車奔跑的功能
2.5定義測試類VehicleTest，在其main方法中創建一個品牌為“benz”、顏色為“black”的汽車。
package com.neuedu.chap06.homework;
public class Vehicle {
private String brand;
private String color;
private double speed=0;
public Vehicle(String brand, String color) {
super();
this.brand = brand;
this.color = color;
this.speed = 0;
}
public String getBrand() {
return brand;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public double getSpeed() {
return speed;
}
public void setSpeed(double speed) {
this.speed = speed;
}
public static void main(String[] args) {
Vehicle y=new Vehicle("benz","black");
y.run();
}
public void run(){
System.out.println("顏色為："+color+brand+"以"+speed+"的速度奔跑");
}
}
