选择排序：数组中的每个元素和其他元素进行比较换位置 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();
}
}