Java基礎複習
/*
三元運算子:
三元運算子的格式：
布林表示式?值1:值2
教務系統
學生 繳費
1
0
*/
public class Demo1 {
public static void main(String[] args) {
String str = "hello";
System.out.println(str.matches("\\w{6}")?"正確":"錯誤");
int a =3;
System.out.println(3>a?"第一個":"第二個");
int temp = 1;
System.out.println(temp==1?"繳費":"未繳費");
}
}
package cn.itcast.review;
/*
continue: 跳過本次迴圈語句，繼續下一次迴圈。
continue的作用範圍： 只能適用於迴圈語句。
一旦執行了continue語句，那麼在迴圈體內continue之後的迴圈 語句跳過執行。
continue迴圈體之後的語句不起作用。
break: 用於結束一個迴圈語句或者是一個switch語句.
break作用範圍： 只能用於迴圈語句或者是switch語句。結束當前迴圈，對整個函式是沒有影響的
return 整個函式都會結束掉的
*/
public class Demo2 {
/*
* continue
* for(int i = 0 ; i<5 ; i++){
if(i==1){
continue;
}
System.out.println("i="+i);
}
*/
//break
/*outer:for(int j = 0 ; j<2; j++){ // j=0 j=1
inner:for(int i = 0 ; i<3 ; i++){ //i=0
System.out.println("hello world");
break outer; //結束當前所在的迴圈。 如果配合標識的使用，可以作用於外層的for迴圈。
}*/
for(int i = 0 ; i<3 ; i++){
System.out.println("hello world");
return;
}
System.out.println("哈哈");//不能輸出
}
}
package cn.itcast.review;
/*
函式的過載: 在一個類中出現了兩個 或兩個以上 的同名函式稱作為函式的過載。
函式過載的作用： 一個函式名可以應對各種不同型別的引數。
函式過載的要求
1. 函式名一致。
2. 形參列表不一致（形參的個數不一致或者是形參對應 的型別不一致）
3. 與返回值型別無關。
函式重寫：子父類出現了同名的函式稱作為函式的重寫。
函式重寫必須要是在繼承的關係才存在的。
函式重寫的需求： 父類的功能無法滿足子類的需求。
函式重寫的要求
1. 子父類的函式名與形參列表必須一致。
2. 子類的許可權修飾符必須 要大於或者等於父類的許可權修飾符。
3. 子類的返回值型別必須要小於或者等於父類的返回型別。
4. 子類丟擲的異常型別必須要小於或者等於父類丟擲的異常型別。
*/
class Animal{
}
class Cat extends Animal{}
class Fu{
public Animal eat(int num){
System.out.println("父類的eat方法");
return new Animal();
}
}
class Zi extends Fu{
public Animal eat(int num){
System.out.println("子類的eat方法..");
return new Animal();
}
}
public class Demo3 {
public static void main(String[] args) {
/*int[] arr = {1,2,4};
double[] arr2 = {2.14,3.14,5.0};
sort(arr);
sort(arr2);*/
Zi z = new Zi();
z.eat(11);
}
public static void sort(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 sort(double[] arr){
for(int i = 0 ; i< arr.length-1; i++){
for(int j = i+1 ; j<arr.length ; j++){
if(arr[i]>arr[j]){
double temp = arr[i];
arr[i] = arr[j];
arr[j]= temp;
}
}
}
}
}
package cn.itcast.review;
import java.util.Arrays;
/*
氣泡排序 ： 相鄰的兩個元素比較，符合條件交換 位置。
*/
public class Demo4 {
public static void main(String[] args) {
int[] arr = {2,5,10,8,1}; //所謂的排序就是將一個個的最大元素放在對應 的位置上。
for(int j = 0 ; j<arr.length -1; j++){ // 控制的輪數，每一輪都可以找出一個最大值。
//把最大值放在最後一個位置
for(int i = 0 ; i<arr.length-1-j ; i++){ //控制的是相鄰的兩個元素比較。
//相鄰的兩個元素比較
if(arr[i] >arr[i+1]){
int temp =arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
}
/* //把老二放在倒數第二個位置上
for(int i = 0 ; i<arr.length-1-1 ; i++){
//相鄰的兩個元素比較
if(arr[i] >arr[i+1]){
int temp =arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
//把老三放在倒數第三個位置上
for(int i = 0 ; i<arr.length-1-2 ; i++){
//相鄰的兩個元素比較
if(arr[i] >arr[i+1]){
int temp =arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
//把老四放在倒數第四個位置上
for(int i = 0 ; i<arr.length-1-3 ; i++){
//相鄰的兩個元素比較
if(arr[i] >arr[i+1]){
int temp =arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
*/
System.out.println("陣列的元素： "+Arrays.toString(arr));
}
}
package cn.itcast.review;
/*
折半查詢法(二分法) ：折半查詢法使用的前提是資料必須 是有序的。
折半查詢法的思路：定義三個變數記錄最大，最小，中間的查詢範圍索引值，每次都是使用中間索引值與要查詢目標進行對比，如果不是符合的目標那麼就
縮小查詢的範圍。
*/
public class Demo5 {
public static void main(String[] args) {
int[] arr = {12,15,17,19,30};
int index = halfSearch(arr,0);
System.out.println("idnex:"+ index);
}
public static int halfSearch(int[] arr,int target){
int max = arr.length - 1;
int min = 0;
int mid = (max+min)/2;
while(true){
if(target>arr[mid]){
min = mid+1;
}else if(target<arr[mid]){
max = mid-1;
}else{
return mid;
}
//重新計算中間值
mid = (min+max)/2;
//找不到
if(max<min){
return -1;
}
}
}
}
package cn.itcast.review;
class Person{
int id;
String name;
@Override
public String toString() {
return "編號："+this.id+" 姓名："+this.name;
}
}
public class Demo6 {
public static void main(String[] args) {
Person p = new Person();
p.id= 110;
p.name = "狗娃";
System.out.println(p);
}
}
package cn.itcast.review;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
/*
匿名物件： 沒有引用型別變數指向的物件就稱作為匿名物件。
匿名物件的主要作用： 簡化書寫。
匿名物件主要用於兩種應用場景：
1. 如果一個物件的方法只會呼叫一次的時候，然後該物件就不再使用了，這時候就就可以使用匿名物件。
2. 作為引數傳遞。
*/
public class Demo7 {
public static void main(String[] args) throws IOException {
// Runtime runtime = Runtime.getRuntime();
// Runtime.getRuntime().exec("C:\\Windows\\notepad.exe");
// FileReader fileReader = new FileReader("F:\\a.txt");
BufferedReader bufferedReader = new BufferedReader(new FileReader("F:\\a.txt"));
}
}
package cn.itcast.review;
/*
封裝：
封裝的步驟：
1. 私有化要封裝的屬性。
2. 根據需求提供對應的get或者是set方法。
封裝的好處：
1. 提高資料的安全性。
2. 操作簡單。
3。 隱藏實現。
封裝一定會用的場景：如果是實體類的成員屬性，我們在現實開發中全部都封裝起來。
*/
class Member{
private String name;
private String sex;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void setSex(String sex){
if("男".equals(sex)||"女".equals(sex)){
this.sex = sex;
}
}
public String getSex(){
return sex;
}
}
public class Demo8 {
public static void main(String[] args) {
Member m = new Member();
m.setName("狗娃");
m.setSex("男");
}
}
package cn.itcast.review;
/*
構造程式碼塊：給物件進行統一的初始化工作。
應用場景： 如何建立任意物件的時候都需要呼叫某個方法為該物件進行初始化時，這時候就可以使用構造程式碼塊。
靜態程式碼塊:
靜態程式碼塊是靜態程式碼塊所屬的類被載入到記憶體的時候執行的。
靜態程式碼塊的應用場景： 以後主要用於準備一個專案的初始化工作。
比如： 從配置配置檔案中讀取資料庫使用者名稱與密碼。
*/
class Baby{
int id;
String name;
//構造程式碼塊的程式碼其實是在建構函式中執行的。
{
cry();
}
static{
System.out.println("靜態程式碼塊執行了...");
}
public Baby(int id, String name) {
this.id = id;
this.name = name;
}
public Baby(){
}
public void cry(){
System.out.println("哭...");
}
@Override
public String toString() {
return " 編號："+this.id+" 姓名："+ this.name;
}
}
public class Demo9 {
public static void main(String[] args) {
Baby b1 = new Baby();
Baby b2 = new Baby(110, "狗娃");
}
}
package cn.itcast.review;
/*
instanceof 判斷指定的物件是否屬於某種類別。
instanceof 使用前提： 判斷的物件與類別必須存在繼承或者實現的關係。
instanceof 使用格式：
物件 instanceof 類別。
有多型才可能使用到instanceof關鍵字，
主要的應用場景： 資料型別強轉之前的判斷。
*/
class Fish extends Animal{
}
class Mouse extends Animal{}
public class Demo10 {
public static void main(String[] args) {
/*Fish f = new Fish();
Animal a = new Animal();
System.out.println("魚是屬於動物類嗎？"+ (f instanceof Animal));
System.out.println("魚是屬於老鼠嗎?"+ (a instanceof Fish));*/
Animal a = getAnimal(1);
if(a instanceof Fish){
Fish f =(Fish) a;
}else if(a instanceof Mouse){
Mouse m = (Mouse)a;
}
}
public static Animal getAnimal(int i){
if(i==0){
return new Fish();
}else{
return new Mouse();
}
}
}
package cn.itcast.review;
import java.util.ArrayList;
import java.util.LinkedList;
/*
抽象類的應用場景：描述一類事物的時候，如果該類確實存在某種行為，但是目前這種行為的是不具體的
這時候就可以把這種行為描述成抽象 的行為，這時候使用抽象。
抽象類在現實開發中的應用場景：
父類私有的成員不能被繼承。
繼承的問題： 隱式繼承。 需要方法來使用，不能直接訪問 如下name.
*/
//工作
class Worker{
private String name;
public void setInfo(String name){
this.name = name;
System.out.println("姓名："+ this.name);
}
}
class Teacher extends Worker{
}
public class Demo11 {
public static void main(String[] args) {
Teacher t = new Teacher();
//t.name ="狗娃";
t.setInfo("老鍾");
}
}
package cn.itcast.review;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
/*
多型： 父類的引用型別變數指向了子類的物件，或者是介面的引用型別變數指向介面實現類的物件。
應用：
1. 多型應用於形參型別的時候，可以接收更多型別的引數，
sort(List list)
sort(ArrayList list)
sort(LinkedList list)
2. 多型用於返回值型別的時候可以返回更多型別的引數。
迭代器的作用： 用於獲取集合中的元素。
內部類：
內部類的好處： 內部類可以直接訪問外部類的成員。
*/
interface MyList{
List subList(int fromIndex, int toIndex);
}
public class Demo12 {
public static void main(String[] args) {
/*Collections.sort(new ArrayList());
Collections.sort(new LinkedList());*/
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(10);
list.add(19);
list.add(12);
list.add(6);
Iterable<Integer> it = (Iterable<Integer>) list.iterator();
List<Integer> list2 = list.subList(1, 3);
}
}
package cn.itcast.review;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
/*
匿名物件：沒有引用型別變數指向的物件就稱作為匿名物件。
匿名內部類：沒有類名的類就稱作為匿名內部類。
匿名內部類使用前提： 必須存在繼承或者實現關係。
因為匿名內部類沒有類名，所以建立匿名內部類物件的時候就必須要藉助與它父類的名字或者它父介面的名字來建立。
但是匿名內部類只不過是沒有類名，其他的一概成員都是具備的。
匿名內部類的應用場景： 主要是作為引數傳遞使用。
*/
interface Dao{
public void add();
}
class Outer{
public void print(){
new Dao(){ //這裡不是建立介面 的物件，是建立了Dao實現類的物件，但是這個類是一個匿名內部類而已，沒有類名借用了父介面 的名字而已。
//大括號中就寫匿名內部類的成員。
int num =10;
@Override
public void add() {
System.out.println("新增學生 ..");
}
}.add();
}
}
public class Demo13 {
public static void main(String[] args) {
/*Outer outer = new Outer();
outer.print();*/
JButton button = new JButton("aa");
button.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("aaa");
}
});
}
}
package cn.itcast.review;
/*
執行緒：
多執行緒的存在的意義： 解決了一個程序允許多個任務可以同時執行。
多執行緒的建立方式：
方式一: 繼承Thread。
1. 自定義一個類繼承Thread.
2. 重寫Thread的run方法，把自定義執行緒的任務程式碼放在run方法上。
3. 建立Thread類的子類物件，並且呼叫start方法開啟執行緒。
方式二： 實現Runnable介面。。
1. 自定義一個類實現Runnable介面.
2. 實現Runnable的run方法。把自定義執行緒的任務程式碼放在run方法上。
3. 建立Runnable實現類的物件。
4. 建立Thread的物件，然後把Runnable實現類的物件作為引數傳遞。
5. 呼叫Thread物件的start方法開啟執行緒。
java中的同步機制：
出現執行緒安全問題的根本原因：
1. 存在兩個或者兩個以上的執行緒共享著資源。
2. 操作資源的程式碼塊必須有語句。
1. 同步程式碼塊
同步程式碼塊的格式：
synchronized(鎖物件){
需要被同步的程式碼塊...
}
同步程式碼塊要注意的細節：
1.鎖物件可以是任意的物件。
2. 鎖物件必須 是多執行緒共享的資源。否則鎖不住。
3. 沒有執行緒安全問題的時候不要使用鎖，因為會導致效率降低。
4. 呼叫sleep方法並不會釋放鎖物件，但是呼叫wait方法的執行緒就會釋放鎖物件。
2. 同步函式
修飾符 synchronized 返回值型別 函式名(形參列表..){
}
注意：
1. 同步函式的鎖物件是不能任意的，非靜態同步函式的鎖物件是this物件，靜態函式的鎖物件是當前位元組碼物件。
2. 同步函式的鎖不能由你指定，是固定的。
*/
class MyThread2 implements Runnable{
@Override
public void run() {
for(int i = 0 ; i < 100 ; i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
class MyThread extends Thread{
@Override
public void run() {
//把自定義執行緒的任務程式碼程式碼寫在這裡。。
for(int i = 0 ; i < 100 ; i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
public class Demo14 {
public static void main(String[] args) {
MyThread thread1 = new MyThread();
thread1.start(); //開啟了自定義的執行緒。執行緒一旦開啟就會執行run方法中的程式碼塊。
MyThread2 thread2 = new MyThread2();
//建立Thread的物件
Thread t = new Thread(thread2);
//呼叫Thread物件的start方法
t.start();
}
}
package cn.itcast.review;
import java.util.HashSet;
import java.util.Iterator;
/*
集合
單例集合
----------| Collection 單列集合的根介面
----------------| List 如果是實現了List介面集合類具備的特點： 有序，可重複。
-------------------| ArrayList 底層使用Object陣列實現的。 特點： 查詢速度快，增刪慢。
-------------------| LinkedList 底層是使用了連結串列資料資料結構實現的。 特點： 查詢慢，增刪快。
-------------------| Vector(瞭解) 底層使用Object陣列實現的， 實現與ArrayList是一樣，只不過是執行緒安全的，操作效率低。
----------------| Set 如果是實現了Set介面集合類具備的特點： 無序，不可重複。
------------------| HashSet 底層使用的是雜湊表實現的。
------------------| TreeSet 底層使用二叉數實現。
雙列集合：
--------| Map (只需要把Map介面的方法全部練習一次即可。)
-----------| HashMap 底層使用的是雜湊表實現的。
-----------| TreeMap 底層使用二叉數實現
-----------| HashTable（瞭解）
*/
class Book{
String name;
double price;
public Book(String name, double price) {
super();
this.name = name;
this.price = price;
}
@Override
public int hashCode() {
return this.name.hashCode();
}
@Override
public boolean equals(Object obj) {
Book b = (Book)obj;
return this.name.equals(b.name);
}
@Override
public String toString() {
return "[書名："+ this.name+" 價格："+this.price+"]";
}
}
public class Demo15 {
public static void main(String[] args) {
//不允許重複的書名存在。
HashSet<Book> books = new HashSet<Book>();
books.add(new Book("深入javaweb",34));
books.add(new Book("java神書",78));
//修改書名
Iterator<Book> it = books.iterator();
while(it.hasNext()){
Book b = it.next();
if(b.name.equals("java神書")){
b.name = "java程式設計思想";
}
}
//為什麼修改名字之後不能刪除了呢?
books.remove(new Book("java神書",78));
System.out.println("集合的元素："+ books);
}
}
package cn.itcast.review;
import java.util.Scanner;
import java.util.TreeMap;
/*
從鍵盤輸入一個字母組成字串，分別統計每個字母出現的次數(10分)
要求輸出的效果按照字母的順序輸出 a(7)b(5)...
*/
public class Demo16 {
public static void main(String[] args) {
System.out.println("請輸入一段字串：");
Scanner scanner = new Scanner(System.in);
String line = scanner.next();
char[] arr = line.toCharArray(); //先把字串轉換成字元陣列。
TreeMap<Character, Integer> map = new TreeMap<Character, Integer>();
for(char c : arr){
if(map.containsKey(c)){ //map集合已經包含了該字元
int count = map.get(c);
map.put(c, count+1);
}else{ //沒有包含
map.put(c, 1);
}
}
System.out.println(map);
}
}