選擇排序：數組中的每個元素和其他元素進行比較換位置 arr[i]>arr[j]
冒泡排序：相鄰元素換位置 arr[j]>arr[j+1]
變量直接聲明在類體裡面， 方法外面，代碼塊的外面 全局變量（成員變量）
變量除了全局變量就是局部變量
成員變量和局部變量的差別：
成員變量定義在類中方法外代碼塊的外面 局部變量定義在方法中或者代碼塊裡面
局部變量使用前必須要指派
成員變量進堆記憶體 局部變量進棧記憶體
this關鍵字：區分成員變量和局部變量同名情況 成員變量用this. 來調用
在構造方法之間調用 this();
二分查找前要記得排序。
繼承的好處：提高了代碼的複用性，提高了代碼的維護性，讓類與類之間産生了關系，是多态的前提
繼承的弊端：類的耦合性增加了（開發的原則是高内聚，低耦合）
繼承要注意的地方：子類隻能繼承父類所有的非私有的成員，子類不能繼承父類的構造方法，但可以通過super關鍵子去通路父類的構造方法
子類方法覆寫父類方法，必須保證權限大于等于父類權限
Java中有多繼承麼？
類沒有多繼承 接口之間有多繼承
接口和抽象類的差別：
相同點：都不能執行個體化 都必須被子類重寫抽象方法
不同點：
1.抽象類可以有構造方法，接口中不能有構造方法。
2.抽象類中可以有普通成員變量，接口中沒有普通成員變量
3.抽象類中可以包含非抽象的普通方法，接口中的所有方法必須都是抽象的
4. 抽象類中可以包含靜态方法，接口中不能包含靜态方法
5. 抽象類和接口中都可以包含靜态成員變量，抽象類中的靜态成員變量的通路類型可以任意，但接口中定義的變量隻能是public static final類型
6. 一個類可以實作多個接口，但隻能繼承一個抽象類。
抽象方法隻能放到抽象類中
public abstract class Demo {
public abstract void show();
}
接口常用的變量和方法
public interface Demo {
public static final int i=1;
public abstract void show();
}
多态中，成員特點
成員變量：(編譯運作全看父類)
編譯時，參考父類中有沒有這個變量，如果有，編譯成功，沒有編譯失敗
運作時，運作的是父類中的變量值
成員方法：(編譯看父類，運作看子類)
編譯時，參考父類中有沒有這個方法，如果有，編譯成功，沒有編譯失敗
運作時，運作的是子類的重寫方法
靜态成員變量和方法：
編譯和運作都看父類
Instanceof:比較引用資料類型
比較一個引用類型的變量是不是這個類型的對象
面向對象的三大特征：封裝、繼承、多态
封裝：封裝給對象提供了隐藏内部特性和行為的能力，對象提供了一些能被其他對象通路的方法來改變它内部的資料
繼承：繼承發生在子父類之間，子類繼承父類所有的可繼承的屬性和方法
多态：多态的前提是繼承，可以了解為同一種物質的多種形态
多态就是父類引用指向子類對象
多态弊端：不能調用子類特有的方法
構造方法在new的時候自動執行，隻執行一次
子類調用父類的構造方法
super()調用的是父類的空參數構造 super(參數)調用的是父類的有參數的構造方法
final修飾類、方法、屬性
final修飾類這個類不能被繼承 修飾方法不能被重寫 修飾變量為常量，隻能指派一次
如何實作對象的共享資料,在資料的前面加上static修飾
public class Person {
String name;
static String className;
}
public class Demo {
public static void main(String[] args) {
Person p1=new Person();
Person p2=new Person();
p1.name="哈哈";
p2.name="呵呵";
System.out.println(p1.name+"..."+p2.name);
//對象調用類的靜态成員變量
p1.className="基礎班";
System.out.println(p2.className);
//也可以直接類名調用
System.out.println(Person .className);
}
}
static關鍵字特點：
随着類的加載而加載 優先于對象存在 被所有對象所共享 可以直接被類名調用
匿名對象：沒有名字的對象
應用場景：隻調用一次的時候，匿名對象可以作為實際參數傳遞，可以作為方法的傳回值
問題：
10.選擇排序 {12,23,34,-23,56,25}
11.冒泡排序 {12,23,34,-23,56,25}
12.折半查找 {12,23,25,34,56} 折半查找前 必須要排好序
13.===========超市管理系統========== 實作增删改查
1.貨物清單 2.添加新貨物 3.删除貨物 4.修改貨物 5.退出系統
（商品編号 商品名稱 商品單價）
根據案例介紹，我們進行分析，首先需要一個功能菜單，然後輸入功能序号後，調用序号對應的功能方法，實作想要的操作。分析步驟如下
1.完成超市商品初始化。建立商品，将商品添加到集合
2.顯示來到超市能做的操作，也就是顯示主菜單
3.根據接收到的功能選項，執行對應的功能
3.1.庫存貨物查詢
3.2.添加新貨物
3.3.删除貨物
3.4.修改貨物
3.5.退出系統,結束main方法的運作
4.循環，回到 2.顯示主菜單
14.随機學生 利用集合
15.如何在建立子類的情況下 列印出父類的變量 子父類重名的情況下使用
16.原先手機有打電話，發短信 顯示來電号碼 新手機在原有的基礎上加了大頭貼和來電姓名
17.this關鍵字在構造方法之間調用 調用自己類的構造方法
18.描述學生和勞工這兩個類,将他們的共性name和age抽取出來放到父類中,并提供相應的get和set方法,
同時需要在建立學生和勞工對象就必須明确姓名和年齡.
19.某IT公司有多名員工,按照員工負責的工作不同,進行了劃分,JavaEE工程師,網絡維護工程師
工作内容:
JavaEE工程師:員工号為xxx的xxx員工,正在開發網站
網絡維護工程師:員工号為xxx的xxx員工,正在檢查網絡是否暢通
(新增 強化Answer13的問題)
學生管理系統之學号不存在問題(對應上面的商品編号是否存在)
學生管理系統之學号重複問題(對應上面的商品編号是否重複)
public class Student {
//學号
private String sid;
//姓名
private String name;
//年齡
private String age;
}
/*
學生管理系統
*/
public class StudentManager {
public static void main(String[] args) {
//建立集合對象，用于存儲學生資料
ArrayList<Student> array = new ArrayList<Student>();
//用循環完成再次回到主界面
while (true) {
//用輸出語句完成主界面的編寫
System.out.println("--------歡迎來到學生管理系統--------");
System.out.println("1 添加學生");
System.out.println("2 删除學生");
System.out.println("3 修改學生");
System.out.println("4 檢視所有學生");
System.out.println("5 退出");
System.out.println("請輸入你的選擇：");
//用Scanner實作鍵盤錄入資料
Scanner sc = new Scanner(System.in);
String line = sc.nextLine();
//用switch語句完成操作的選擇
switch (line) {
case "1":
addStudent(array);
break;
case "2":
deleteStudent(array);
break;
case "3":
// System.out.println("修改學生");
updateStudent(array);
break;
case "4":
findAllStudent(array);
break;
case "5":
System.out.println("謝謝使用");
System.exit(0); //JVM退出
}
}
}
//定義一個方法，用于添加學生資訊
/*
public static void addStudent(ArrayList<Student> array) {
//鍵盤錄入學生對象所需要的資料,顯示提示資訊，提示要輸入何種資訊
Scanner sc = new Scanner(System.in);
System.out.println("請輸入學生學号：");
String sid = sc.nextLine();
System.out.println("請輸入學生姓名：");
String name = sc.nextLine();
System.out.println("請輸入學生年齡：");
String age = sc.nextLine();
System.out.println("請輸入學生居住地：");
String address = sc.nextLine();
//建立學生對象，把鍵盤錄入的資料指派給學生對象的成員變量
Student s = new Student();
s.setSid(sid);
s.setName(name);
s.setAge(age);
s.setAddress(address);
//将學生對象添加到集合中
array.add(s);
//給出添加成功提示
System.out.println("添加學生成功");
}
*/
public static void addStudent(ArrayList<Student> array) {
//鍵盤錄入學生對象所需要的資料,顯示提示資訊，提示要輸入何種資訊
Scanner sc = new Scanner(System.in);
//為了讓sid在while循環外面被通路到，我們就把它定義在了循環外
String sid;
//為了讓程式能夠回到這裡，我們使用循環實作
while (true) {
System.out.println("請輸入學生學号：");
sid = sc.nextLine();
boolean flag = isUsed(array, sid);
if (flag) {
System.out.println("你輸入的學号已經被使用，請重新輸入");
} else {
break;
}
}
System.out.println("請輸入學生姓名：");
String name = sc.nextLine();
System.out.println("請輸入學生年齡：");
String age = sc.nextLine();
System.out.println("請輸入學生居住地：");
String address = sc.nextLine();
//建立學生對象，把鍵盤錄入的資料指派給學生對象的成員變量
Student s = new Student();
s.setSid(sid);
s.setName(name);
s.setAge(age);
s.setAddress(address);
//将學生對象添加到集合中
array.add(s);
//給出添加成功提示
System.out.println("添加學生成功");
}
//定義一個方法，判斷學号是否被使用
public static boolean isUsed(ArrayList<Student> array, String sid) {
//如果與集合中的某一個學生學号相同，傳回true;如果都不相同，傳回false
boolean flag = false;
for(int i=0; i<array.size(); i++) {
Student s = array.get(i);
if(s.getSid().equals(sid)) {
flag = true;
break;
}
}
return flag;
}
//定義一個方法，用于檢視學生資訊
/*
public static void findAllStudent(ArrayList<Student> array) {
//顯示表頭資訊
//\t 其實就是tab鍵的位置
System.out.println("學号\t\t\t姓名\t\t年齡\t\t居住地");
//将集合中資料取出按照對應格式顯示學生資訊，年齡顯示補充“歲”
for (int i = 0; i < array.size(); i++) {
Student s = array.get(i);
System.out.println(s.getSid() + "\t" + s.getName() + "\t" + s.getAge() + "歲\t\t" + s.getAddress());
}
}
*/
public static void findAllStudent(ArrayList<Student> array) {
//判斷集合中是否有資料，如果沒有顯示提示資訊
if (array.size() == 0) {
System.out.println("無資訊，請先添加資訊再查詢");
//為了讓程式不在往下執行，給出return;
return;
}
//顯示表頭資訊
//\t 其實就是tab鍵的位置
System.out.println("學号\t\t\t姓名\t\t年齡\t\t居住地");
//将集合中資料取出按照對應格式顯示學生資訊，年齡顯示補充“歲”
for (int i = 0; i < array.size(); i++) {
Student s = array.get(i);
System.out.println(s.getSid() + "\t" + s.getName() + "\t" + s.getAge() + "歲\t\t" + s.getAddress());
}
}
//定義一個方法，用于删除學生資訊
/*
public static void deleteStudent(ArrayList<Student> array) {
//鍵盤錄入要删除的學生學号,顯示提示資訊
Scanner sc = new Scanner(System.in);
System.out.println("請輸入你要删除的學生的學号：");
String sid = sc.nextLine();
//周遊集合将對應學生對象從集合中删除
for(int i=0; i<array.size(); i++) {
Student s = array.get(i);
if(s.getSid().equals(sid)) {
array.remove(i);
break;
}
}
//給出删除成功提示
System.out.println("删除學生成功");
}
*/
public static void deleteStudent(ArrayList<Student> array) {
//鍵盤錄入要删除的學生學号,顯示提示資訊
Scanner sc = new Scanner(System.in);
System.out.println("請輸入你要删除的學生的學号：");
String sid = sc.nextLine();
//在删除/修改學生操作前，對學号是否存在進行判斷
//如果不存在，顯示提示資訊
//如果存在，執行删除/修改操作
int index = -1;
for (int i = 0; i < array.size(); i++) {
Student s = array.get(i);
if (s.getSid().equals(sid)) {
// int index = i;
index = i;
break;
}
}
if (index == -1) {
System.out.println("該資訊不存在，請重新輸入");
} else {
array.remove(index);
//給出删除成功提示
System.out.println("删除學生成功");
}
}
//定義一個方法，用于修改學生資訊
public static void updateStudent(ArrayList<Student> array) {
//鍵盤錄入要修改的學生學号，顯示提示資訊
Scanner sc = new Scanner(System.in);
System.out.println("請輸入你要修改的學生的學号：");
String sid = sc.nextLine();
//鍵盤錄入要修改的學生資訊
System.out.println("請輸入學生新姓名：");
String name = sc.nextLine();
System.out.println("請輸入學生新年齡：");
String age = sc.nextLine();
System.out.println("請輸入學生新居住地：");
String address = sc.nextLine();
//建立學生對象
Student s = new Student();
s.setSid(sid);
s.setName(name);
s.setAge(age);
s.setAddress(address);
//周遊集合修改對應的學生資訊
for (int i = 0; i < array.size(); i++) {
Student student = array.get(i);
if (student.getSid().equals(sid)) {
array.set(i, s);
break;
}
}
//給出修改成功提示
System.out.println("修改學生成功");
}
}
public class Answer10 {
public static void main(String[] args) {
int [] arr={12,23,34,-23,56,25};
selectSort(arr);
show(arr);
}
public static void selectSort(int[] arr){
for (int i = 0; i < arr.length-1; i++) {
for (int j = i+1; j < arr.length; j++) {
if(arr[i]>arr[j]){
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
}
public static void show(int [] arr){
System.out.print("[");
for(int i=0;i<arr.length;i++){
if(i!=arr.length-1){
System.out.print(arr[i]+",");
}else{
System.out.print(arr[i]+"]");
}
}
}
}
public class Answer11 {
public static void main(String[] args) {
int [] arr={12,23,34,-23,56,25};
bubbleSort(arr);
show(arr);
}
public static void bubbleSort(int[] arr){
for (int i = 0; i < arr.length-1; i++) {
//每次内循環的比較，從0索引開始，每次都在遞減
for (int j = 0; j < arr.length-1-i; j++) { //冒泡減1是為了防止j+1越界異常
if(arr[j]>arr[j+1]){
int temp=arr[j+1];
arr[j+1]=arr[j];
arr[j]=temp;
}
}
}
}
public static void show(int [] arr){
System.out.print("[");
for(int i=0;i<arr.length;i++){
if(i!=arr.length-1){
System.out.print(arr[i]+",");
}else{
System.out.print(arr[i]+"]");
}
}
}
}
/*
* 折半公式(min+max)/2
* 指針思想
* 折半後的指針索引和被查找元素比較
* 元素>中間索引上的元素
* 小指針=中間+1
* 元素<中間索引上的元素
* 大指針=中間-1
* */
public class Answer12 {
public static void main(String[] args) {
int[] arr={12,23,25,34,56};
int index=binarySearch(arr,25);
System.out.println(index);
}
public static int binarySearch(int [] arr,int key){
//定義三個指針變量
int min=0;
int max=arr.length-1;
int mid=0;
while(min<=max){
//公式，計算中間索引
mid=(min+max)/2;
//讓被找元素，和中間元素進行比較
if(key>arr[mid]){
min=mid+1;
}else if(key<arr[mid]){
max=mid-1;
}else{
//找到元素，傳回元素索引
return mid;
}
}
return -1;
}
}
import java.util.ArrayList;
import java.util.Scanner;
public class Answer13 {
public static void main(String[] args) {
ArrayList<FruitItem> array=new ArrayList<>();
init(array);
while(true){
mainMenu();
int num=chooseFunction();
switch (num) {
case 1:
showFruitItem(array);
break;
case 2:
addFruit(array);
break;
case 3:
deleteFruit(array);
break;
case 4:
updateFruit(array);
break;
case 5:
System.out.println("你已退出本管理系統");
return ;
default:
System.out.println("請輸入正确的序号");
break;
}
}
}
public static void updateFruit(ArrayList<FruitItem> array){
System.out.println("您現在操作的是商品修改功能");
Scanner sc=new Scanner(System.in);
System.out.println("請輸入你要修改的商品編号");
int ID=sc.nextInt();
for(int i=0;i<array.size();i++){
FruitItem item=array.get(i);
if(item.ID==ID){
System.out.println("請輸入新的商品編号");
item.ID=sc.nextInt();
System.out.println("請輸入新的商品名稱");
item.brand=sc.next();
System.out.println("請輸入新的商品單價");
item.price=sc.nextDouble();
System.out.println("恭喜你修改商品成功");
return;
}
}
System.out.println("你輸入的商品編号不存在");
}
public static void deleteFruit(ArrayList<FruitItem> array){
System.out.println("您現在操作的是商品删除功能");
Scanner sc=new Scanner(System.in);
System.out.println("請輸入你要删除的商品編号");
int ID=sc.nextInt();
for(int i=0;i<array.size();i++){
FruitItem item=array.get(i);
if(item.ID==ID){
array.remove(i);
System.out.println("恭喜你删除商品成功");
return ;
}
}
System.out.println("你輸入的商品編号不存在");
}
public static void addFruit(ArrayList<FruitItem> array){
System.out.println("您現在操作的是商品添加功能");
Scanner sc=new Scanner(System.in);
FruitItem item=new FruitItem();
System.out.println("請輸入你要添加的商品編号");
item.ID=sc.nextInt();
System.out.println("請輸入你要添加的商品名稱");
item.brand=sc.next();
System.out.println("請輸入你要添加的商品單價");
item.price=sc.nextDouble();
array.add(item);
System.out.println("恭喜你添加商品成功");
}
public static void showFruitItem(ArrayList<FruitItem> array){
System.out.println();
System.out.println("=============商品庫存清單=============");
System.out.println("商品編号 商品名稱 商品單價");
for(int i=0;i<array.size();i++){
FruitItem fi=array.get(i);
System.out.println(fi.ID+" "+fi.brand+" "+fi.price);
}
}
public static int chooseFunction(){
return new Scanner(System.in).nextInt();
}
public static void mainMenu(){
System.out.println();
System.out.println("==============歡迎光臨Itcast水果超市==============");
System.out.println("1.貨物清單 2.添加新貨物 3.删除貨物 4.修改貨物 5.退出系統");
System.out.println("請您輸入要操作的需要");
}
public static void init(ArrayList<FruitItem> array){
FruitItem f1=new FruitItem();
f1.ID=1001;
f1.brand="西瓜";
f1.price=12.5;
FruitItem f2=new FruitItem();
f2.ID=1002;
f2.brand="蘋果";
f2.price=16.0;
FruitItem f3=new FruitItem();
f3.ID=1003;
f3.brand="人生果";
f3.price=50.0;
array.add(f1);
array.add(f2);
array.add(f3);
}
}
class FruitItem{
int ID;
String brand;
double price;
}
public class NewStudent {
private String name;
private int ag;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAg() {
return ag;
}
public void setAg(int ag) {
this.ag = ag;
}
}
import java.util.ArrayList;
import java.util.Random;
public class Answer14 {
public static void main(String[] args) {
ArrayList<NewStudent> array=new ArrayList<>();
addStudent(array);
showStudent(array);
randomStudent(array);
}
public static void randomStudent(ArrayList<NewStudent> array){
Random ran=new Random();
int index=ran.nextInt(array.size());
NewStudent ns=array.get(index);
System.out.println(ns.getName()+"..."+ns.getAg());
}
public static void showStudent(ArrayList<NewStudent> array){
for(int i=0;i<array.size();i++){
NewStudent s=array.get(i);
System.out.println(s.getName()+"...."+s.getAg());
}
}
public static void addStudent(ArrayList<NewStudent> array){
NewStudent ns1=new NewStudent();
ns1.setName("張三1");
ns1.setAg(151);
NewStudent ns2=new NewStudent();
ns2.setName("張三2");
ns2.setAg(152);
NewStudent ns3=new NewStudent();
ns3.setName("張三3");
ns3.setAg(153);
NewStudent ns4=new NewStudent();
ns4.setName("張三4");
ns4.setAg(154);
NewStudent ns5=new NewStudent();
ns5.setName("張三5");
ns5.setAg(155);
array.add(ns1);
array.add(ns2);
array.add(ns3);
array.add(ns4);
array.add(ns5);
}
}
public class Answer15 {
public static void main(String[] args) {
Zi zi=new Zi();
zi.show();
}
}
class Fu{
int i=1;
}
class Zi extends Fu{
int i=2;
public void show(){
int i=3;
System.out.println(i);
System.out.println(this.i);
System.out.println(super.i);
}
}
public class Answer16 {
public static void main(String[] args) {
AndroidPhone ad=new AndroidPhone();
ad.call();
ad.sendMessage();
ad.show();
}
}
class Phone{
public void call(){
System.out.println("打電話了");
}
public void sendMessage(){
System.out.println("發消息了");
}
public void show(){
System.out.println("顯示來電号碼了");
}
}
class AndroidPhone extends Phone{
public void show(){
super.show(); //調用了父類的方法 -----
System.out.println("大頭貼");
System.out.println("來電姓名");
}
}
public class Person {
private String name;
private int age;
public Person(){
//調用了有參數的構造方法 參數 張三 18傳給了變量name 和 age
this("張三",18);
}
public Person(String name,int age){
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;
}
}
public class Answer17 {
public static void main(String[] args) {
Person p=new Person();
System.out.println(p.getName()+"..."+p.getAge());
}
}
public class Person {
private String name;
private int age;
public Person(String name,int age){
super();
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;
}
}
public class Student extends Person{
public Student(String name, int age) {
super(name, age);
}
}
public class Worker extends Person{
public Worker(String name, int age) {
super(name, age);
}
}
public class Answer18 {
public static void main(String[] args) {
Student s=new Student("張三",18);
Worker w=new Worker("李四",20);
System.out.println(s.getName()+"..."+s.getAge());
System.out.println(w.getName()+"..."+w.getAge());
}
}
public abstract class Employee {
private String name;
private int age;
public Employee(String name, int age) {
super();
this.name = name;
this.age = age;
}
public abstract void work();
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 class JavaEE extends Employee{
public JavaEE(String name, int age) {
super(name, age);
}
public void work() {
System.out.println("員工号為"+super.getName()+"..."+"年齡為"+super.getAge()+",正在開發網站");
}
}
public class Maintainer extends Employee{
public Maintainer(String name, int age) {
super(name, age);
}
public void work() {
System.out.println("員工号為"+super.getName()+"..."+"年齡為"+super.getAge()+",正在檢查網絡是否暢通");
}
}
public class Answer19 {
public static void main(String[] args) {
JavaEE javaEE=new JavaEE("張三",18);
Maintainer maintainer=new Maintainer("李四", 20);
javaEE.work();
maintainer.work();
}
}