目录
1.基础语法
数据类型
标识符
规则：
*由数字、字母、下划线和美元符组成；
*不能以数字开头；
*不能是关键字；
*要区分大小写
Scanner键盘录入
数值拆分
字符串
注意：联想贪吃蛇
自增自减运算符
类型转换
小的给大的----->直接给
进制转换
原码反码补码
强制转换
赋值运算符
关系运算符
逻辑运算符
三元运算符
运算符优先级
if——分支语句 流程控制语句
快速整理代码：ctrl+alt+l
for循环
打印100以内偶数和
方法一：
方法二：方法调用
快捷键 ------>.var 然后敲回车键
自动起了个变量名sum，若不满意直接更改
for循环打印水仙花数
方法调用 
for循环注意事项
while循环
do-while循环
三种循环区别
switch语句
!!!优化操作 
Random随机数 猜数字小游戏
猜数字游戏
数组
数组静态初始化
数组定义格式
数组元素访问
数组遍历操作
//数组快捷键： 数组名arr.fori
数组遍历操作练习
package charpter06;
public class TestMath {
public static void main(String[] args) {
int[] arr = {100,50,20,90,80};
int max = getMax(arr);//把数组arr扔括号里，快捷键。var
System.out.println("最大值为："+max);
int min = getMin(arr);
System.out.println("最小值为："+min);
int sum = getSum(arr);
System.out.println("总成绩为："+sum);
double avg = getAvg(arr);
System.out.println("平均分为："+avg);
int count = getCount(arr);
System.out.println("低于平均值元素的个数为："+count);
}
/*
需求：已知班级学生成绩 int[] arr = {100,50,20,90,80}
1.找出数组最大值，并打印在控制台
2.找出数组最小值，并打印在控制台
3.求总成绩
4.求平均值
5.统计低于平均值元素的个数
*/
/** 1.找出数组最大值，并打印在控制台*/
public static int getMax(int[] arr) {//形参
//1.第一名选手上台（假设第一个元素就是最大值）
int max=arr[0];
//2.遍历数组，获取每一个元素
for(int i =1;i<arr.length;i++){
//3.逐个比较
if(arr[i]>max){
//4.记录更大的元素
max=arr[i];
}
}
return max;//返回值
}
/**2.找出数组最小值，并打印在控制台*/
public static int getMin(int[] arr) {//形参
int min=arr[0];//快捷键：shift+f6一件更改变量名为min
for(int i =1;i<arr.length;i++){
if(arr[i]<min){
min=arr[i];
}
}
return min;//返回值
}
/**3.求总成绩*/
public static int getSum(int[] arr) {
int sum=0;
for (int i = 0; i < arr.length; i++) {
sum+=arr[i];
}
return sum;
}
/**4.求平均值*/
public static double getAvg(int[] arr) {
int sum = getSum(arr);
double avg=(sum*1.0)/ arr.length;
return avg;
}
/**5.统计低于平均值元素的个数*/
public static int getCount(int[] arr) {
int count=0;
double avg = getAvg(arr);
for (int i = 0; i < arr.length; i++) {
if(arr[i]<avg) count++;
}
return count;
}
}数组动态初始化
初始化时只指定数组长度，由系统为数组分配初始值
- 格式：数据类型[ ] 数组名 = new 数据类型[ 数组长度 ]
- 范例：int[ ] arr = new int[ 3 ]
unicode字符
package charpter06;
public class TestMath {
public static void main(String[] args) {
arr1Test();
arr2Test();
arr3Test();
arr4Test();
arr5Test();
}
/*
默认值的分类：
整数：0
小数：0.0
布尔：false
————————————————————————
字符：'\u0000' ———>Unicode字符 杠u +16进制---->常见是空白字符
字符串（引用数据类型）：null
引用数据类型：数组，类，接口
String：类
*/
public static void arr1Test() {
int[] arr=new int[3];
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
System.out.println("------------------");
}
public static void arr2Test() {
double[] arr=new double[3];
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
System.out.println("------------------");
}
public static void arr3Test() {
boolean[] arr=new boolean[3];
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
System.out.println("------------------");
}
public static void arr4Test() {
char[] arr=new char[3];
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
System.out.println("------------------");
}
public static void arr5Test() {
String[] arr = new String[3];
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
System.out.println("------------------");
}
}数组静态初始化Vs数组动态初始化
- 动态初始化:手动指定数组长度，由系统给出默认初始化值。
数据类型[] 变量名 = new 数据类型[数组长度] eg. int[ ] array = new int[10];- 静态初始化:手动指定数组元素，系统会根据元素个数，计算出数组的长度。
数据类型[] 变量名 = {...}; eg. int[ ] arr = {1,2,3}; 数据类型[] 变量名 = new 数据类型[] {...}; eg. int[ ] arr = new arr[ ] {1,2,3};两种初始化的使用选择 :
1.静态初始化： 如果要操作的数据，需求中已经明确给出了，直接静态初始化
需求: 已知班 级学生成绩为 100 100 90 20 100 ，找出最高分
int[] arr = {100,100,90,20,100}
2.动态初始化：只明确元素个数，不明确具体数值
需求1: 键盘录入5个学生成绩，找出最高分
需求2：产生10个1——100之间的随机数，找出最小值
int[] arr = {？？？？？}；
int[] arr=new int[5]；
/*动态初始化*/
package charpter06;
import java.util.Scanner;
public class TestMath {
public static void main(String[] args) {
Scanner sc= new Scanner(System.in);
System.out.println("请输入5个学生成绩：");
int[] arr=new int[5];
for (int i = 0; i < arr.length; i++) {
System.out.println("请输入第"+(i+1)+"个：");
arr[i]= sc.nextInt();//键盘录入一个，往里存一个
}
int max = getMax(arr);
System.out.println("最大值为："+max);
}
public static int getMax(int[] arr) {//形参
//1.第一名选手上台（假设第一个元素就是最大值）
int max=arr[0];
//2.遍历数组，获取每一个元素
for(int i =1;i<arr.length;i++){
//3.逐个比较
if(arr[i]>max){
//4.记录更大的元素
max=arr[i];
}
}
return max;//返回值
}
}抽取方法的快捷键：ctrl+alt+M
package charpter06;
import java.util.Random;
import java.util.Scanner;
public class TestMath {
public static void main(String[] args) {
Random r=new Random();
int[] randomNums=new int[10];
for (int i = 0; i < randomNums.length; i++) {
randomNums[i]=r.nextInt(100)+1;
System.out.println(randomNums[i]);
}
int min=getMin(randomNums);
System.out.println("最小值为："+min);
}
public static int getMin(int[] arr) {//形参
int min=arr[0];//快捷键：shift+f6一件更改变量名为min
for(int i =1;i<arr.length;i++){
if(arr[i]<min){
min=arr[i];
}
}
return min;//返回值
}
}数组内存图
方法参数传递问题：
1.基本数据类型：传递的是数据值
2.引用数据类型：传递的是地址值
问题: Java到底是值传递，还是址传递?
回答: 值传递，地址值也是值
方法变量里有形参（change），形参对于内存就是变量而已
运行完后200弹栈消失
如果要返回200，则要找一个新的变量
二维数组
二维数组静态初始化
二维数组遍历
遍历二维数组并求和
二维数组动态初始化
2.方法
方法介绍
方法调用
方法调用内存图解——栈——>子弹上膛先入后出
带参数方法的定义和调用
方法调用个格式
方法常见问题
方法重载
方法名可以相同，保证参数不同就行。
错误示范：
3.案例
逢7跳过
package charpter06;
public class TestMath {
public static void main(String[] args) {
knockSeven();
}
public static void knockSeven() {
//1.通过循环获得1-100之间每个数字
for(int i=1;i<=100;i++) {
// 2.数值拆分，拆分出个位和十位
int ge = i % 10;
int shi = i / 10 % 10;
// 3.规则if判断
if (ge == 7 || shi == 7 || i % 7 == 0){
// 4.打印出满足规则的数据
System.out.println("过");
}else {
System.out.println(i);
}
}
}
}
数组元素求和
package charpter06;
public class TestMath {
public static void main(String[] args) {
int[] arr={68,27,95,88,171,996,51,210};
int evenNumberSum = getEvenNumberSum(arr);
System.out.println(evenNumberSum);
}
public static int getEvenNumberSum(int[] arr) {
//1.定义求和变量
int sum=0;
//2.遍历数组，获取内部的每一个元素
for (int i = 0; i < arr.length; i++) {
//arr[i]:数组中的每一个元素
// 3.数值拆分，拆分出个位和十位
int ge = arr[i] % 10;
int shi = arr[i]/ 10 % 10;
// 4.规则if判断
if (ge != 7 && shi != 7 && arr[i] % 2 == 0){
sum+=arr[i];
}
}
return sum;
}
}
判断两个数组元素是否相同
数组为引用类型，比较地址值，有各自内存地址
package charpter06;
public class TestMath {
public static void main(String[] args) {
int[] arr1={11,22,33};
int[] arr2={11,22,33,};
boolean result = checkArrayContent(arr1, arr2);
System.out.println(result);
}//定义一个方法接收两个数组
public static boolean checkArrayContent(int[] arr1,int[] arr2){
//1.比较数组长度
if(arr1.length!=arr2.length) return false;
//数组长度相同，意味着索引也相同
//2.比较数组中元素内容
for (int i = 0; i < arr1.length; i++) {
//arr1[i]:第一个数组中的每一个元素
//arr2[i]:第二个数组中的每一个元素
if(arr1[i]!=arr2[i]) return false;
//如果写==会出现第一个元素相同，后面元素不相同就return true，所以写！=
}
return true;
}
}
查找元素在数组中的索引
不考虑出现重复元素
package charpter06;
import java.util.Scanner;
/*查找元素在数组中第一次出现的索引*/
public class TestMath {
public static void main(String[] args) {
int[] arr={19,28,90,67,56,23};
Scanner sc=new Scanner(System.in);
System.out.println("请输入要查找的元素：");
int num=sc.nextInt();
int index = getIndex(num, arr);
System.out.println(index);
}
//int num 记录要查找的元素
public static int getIndex(int num, int[] arr) {
//1.假设要查找的元素，在数组不存在
int index = -1;
//2.遍历数组，获取内部的每一个元素
for (int i = 0; i < arr.length; i++) {
//3.比较
if (arr[i] == num) {//找到了，让index变量记录正确的索引
index = i;
break;//提升循环效果
}
}
return index;
}
}考虑出现重复元素
注意索引越界 result[i]=i;
package charpter06;
import java.util.Scanner;
/*考虑重复元素问题*/
public class TestMath {
public static void main(String[] args) {
int[] arr={19,28,90,67,78,19,19};
int[] result = getIndex(19, arr);
if(result.length==0){
System.out.println("您要查找的元素在数组中不存在");
}else {
for (int i = 0; i < result.length; i++) {
System.out.println(result[i]);
}
}
}
//int num 记录要查找的元素
/*
问题：当一个方法运行结束后，有多个结果需要返回，怎么处理？
回答：可以将多个结果，存入一个数组，将数组返回
*/
public static int[] getIndex(int num, int[] arr) {
//1.统计要查找的元素，在数组中出现的个数
int count=0;
for (int i = 0; i < arr.length; i++) {
if(arr[i]==num) count++;
}
//2.根据统计出来的个数，创建数组容器
int[] result=new int[count];
int index=0;//快捷键：shift+f6
//3.查找元素在数组中的索引，将找到的索引，存入新数组容器
for (int i = 0; i < arr.length; i++) {
if(arr[i]==num) {
/*
result[i]=i;
有可能会引发索引越界
*/
/*
result[0]=0;
result[1]=5;
result[2]=6;
*/
result[index]=i;
index++;
}
}
//4.将装满了索引的数组，返回
return result;
}
} 数据交换
联想第三方变量
不允许使用第三方变量
package charpter06;
import java.util.Scanner;
public class TestMath {
/*
int a=10;
int b=20;
// 定义第三方变量
int c=a;
a=b;
b=c;
System.out.println("a="+a);
System.out.println("b="+b);
*/
/*
^ 异或：
特点：
1.相同为false，不同为true
2.一个数字，被另一个数字异或两次，该数本身不变（10^5^10）
异或操作数值的运算过程：
1.将需要运算的数据，转换为二进制数据
10： 0000 1010
2： 0000 0010
2.将二进制数据的0当作false 1当作为true ，运算
0000 1010
^ 0000 0010
-------------------
0000 1000
3.将运算后的二进制数据，转换为十进制
*/
public static void main(String[] args) {
int a=10;
int b=20;
a=a^b; //a=10^20
b=a^b; //b=10^20^20 一个数字(10)，被另一个数字异或两次，该数本身不变---->b=10
a=a^b; //a=10^20^10 一个数字(20)，被另一个数字异或两次，该数本身不变---->a=20
System.out.println("a="+a);//20
System.out.println("b="+b);//10
}
}package charpter06;
public class TestMath {
public static void main(String[] args) {
int[] arr={11,22,33,44,55};
//数组中的第一个元素，和最后一个元素进行交换
//1.确定好，谁跟谁交换 arr[0] arr[arr,length-1]
//2.定义第三方变量，倒手
int temp=arr[0];
arr[0]=arr[4];
arr[4]=temp;
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
//55 22 33 44 11数组元素反转
package charpter06;
public class TestMath {
public static void main(String[] args) {
int[] arr={11,22,33,44,55};
//数组中的第一个元素，和最后一个元素进行交换
/*
1.确定好，谁跟谁交换
第一个和倒数第一个：arr[0] arr[arr.length-1-0]
第二个和倒数第二个：arr[1] arr[arr.length-1-1]
第三个和倒数第三个：arr[2] arr[arr.length-1-2]
……
arr[i] arr[arr.length-1-i]
*/
//2.定义第三方变量，套入公式
for (int i = 0; i < arr.length/2; i++) {
int temp=arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i]=temp;
}
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
} 
package charpter06;
public class TestMath {
public static void main(String[] args) {
int[] arr={11,22,33,44,55};
//数组中的第一个元素，和最后一个元素进行交换
//1.确定好，谁跟谁交换 arr[0] arr[arr,length-1]
//2.定义第三方变量，倒手
int start =0;
int end=arr.length-1;
//初始化语句在外面
for(;start<end;start++,end--){
int temp= arr[start];
arr[start]= arr[end];
arr[end]=temp;
}
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}评委打分
快捷键：快速抽取方法 ctrl+alt+M
package charpter06;
import java.util.Scanner;
public class TestMath {
public static void main(String[] args) {
int[] arr = initData();
int sum = getSum(arr);
int max = getMax(arr);
int min = getMin(arr);
//5.求平均分（总和-最大值-最小值）/4
double avg=((sum-min-max)*1.0)/ arr.length-2;
System.out.println("选手的最后得分："+avg);
}
private static int getMin(int[] arr) {
//4.求最小值
int min= arr[0];
for (int i = 0; i < arr.length; i++) {
if(arr[i]<min) min= arr[i];
}
return min;
}
private static int getMax(int[] arr) {
//3.求最大值
int max= arr[0];
for (int i = 0; i < arr.length; i++) {
if(arr[i]>max) max= arr[i];
}
return max;
}
private static int getSum(int[] arr) {
//2.求和
int sum=0;
for (int i = 0; i < arr.length; i++) {
sum+= arr[i];
}
return sum;
}
/**
* 此方法用于键盘录入6个评委分数
* @return
*/
private static int[] initData() {
int[] arr=new int[6];//动态
//1.键盘录入6个评委的打分
Scanner sc=new Scanner(System.in);
System.out.println("请输入6个评委的打分：" );
for (int i = 0; i < arr.length; i++) {
System.out.println("请输入第"+(i+1)+"个评委的打分");
int score = sc.nextInt();
//判断成绩是否正确0~100
if(score>=0&&score<=100){
arr[i]=score;
}else {
System.out.println("您输入的分数有误，请检查是否是0~100之间的");
i--;//继续输入
}
}
return arr;
}
} 随机产生验证码
字符串拼接
package charpter06;
import java.util.Random;
import java.util.Scanner;
public class TestMath {
public static void main(String[] args) {
char[] chs = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
'j', 'k','l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
};
Random r=new Random();
String checkCode="";
for (int i=1;i<=5;i++){
int index= r.nextInt(chs.length);//根据数组长度产生一个随机数
//把随机数当作一个索引
checkCode+=chs[index];
}
System.out.println("产生的验证码为："+checkCode);
}
}package charpter06;
import java.util.Random;
import java.util.Scanner;
public class TestMath {
public static void main(String[] args) {
char[] chs = getContens();
String checkCode = getCheckCode(chs);
System.out.println("产生的验证码为："+checkCode);
}
private static String getCheckCode(char[] chs) {
Random r =new Random();
String checkCode="";
for (int i=1;i<=5;i++){
int randomIndex= r.nextInt(chs.length);//根据数组长度产生一个随机数
//把随机数当作一个索引
checkCode+= chs[randomIndex];
}
return checkCode;
}
private static char[] getContens() {
char[] chs = new char[26+26+10];
//把字符存到数组当中
//变量
int index=0;
for (char c='a';c<='z';c++){
chs[index] = c;
index++;
}
for (char c='A';c<='Z';c++){
chs[index] = c;
index++;
}
for (char c='0';c<='9';c++){
chs[index] = c;
index++;
}
return chs;
}
}3.面向对象
类和对象
package graph6;
public class StudentTest {
public static void main(String[] args) {
Student stu1=new Student();
stu1.name="张三";
stu1.age=19;
System.out.println(stu1);
System.out.println(stu1.age);
System.out.println(stu1.name);
stu1.study();
stu1.eat();
System.out.println("----------------");
Student stu2=new Student();
stu2.name="李四";
stu2.age=66;
System.out.println(stu2);
System.out.println(stu2.age);
System.out.println(stu2.name);
stu2.study();
stu2.eat();
}练习：类的定义与对象的创建和使用
package graph;
public class PhoneTest {
public static void main(String[] args) {//主方法
//创建对象
Phone p1=new Phone();
p1.brand="小米";
p1.color="白色";
p1.price=4999;
System.out.println(p1.brand+"----"+p1.color+"-----"+p1.price);
Phone p2=new Phone();
p2.brand="华为";
p2.color="黑色";
p2.price=6999;
System.out.println(p2.brand+"----"+p2.color+"-----"+p2.price);
p1.call("张三");
p1.sendMessage();
p2.call("李四");
p2.sendMessage();
}
}
package graph;
public class Book {
String name;
String id;
double price;
public void show(){
System.out.println("编号为："+id+"书名为："+name+"价格为："+price);
}
}
package graph;
public class BookTest {
public static void main(String[] args) {
Book b1=new Book();
b1.price=88.88;
b1.id="001";
b1.name="三国";
b1.show();
System.out.println("-------------");
Book b2=new Book();
b2.name="水浒";
b2.price=99.78;
b2.id="002";
b2.show();
System.out.println("-------------");
Book b3=new Book();
b3.price=1000;
b3.id="003";
b3.name="红楼梦";
b3.show();
}
}
对象内存图
成员变量与局部变量
注意！！！！！ 方法弹栈消失
this关键字
java就近原则
构造方法
封装
权限修饰符
标准javabean
package graph6;
public class Student {
//1.成员变量私有化
private String name;
private int age;
//2.空参，带参够着方法
public Student(){}
public Student(String name,int age){
this.age=age;
this.name=name;
}
//3.对于私有的成员变量，提供对应的setXxx和getXxx方法
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
}快捷键！！！！
右键——>生成——>构造函数——>无选择（出现空参）----[重复上一轮出现有参]
ctrl+a全选 确定
ctrl+a全选 确定
#########################一键生成############################
综合案例
快捷键：CTRL+alt+t
package graph6;
public class Movie {
private int id;
private String title;
private String time;
private double score;
private String area;
private String type;
private String director;
private String starring;
public Movie() {
}
public Movie(int id, String title, String time, double score, String area, String type, String director, String starring) {
this.id = id;
this.title = title;
this.time = time;
this.score = score;
this.area = area;
this.type = type;
this.director = director;
this.starring = starring;
}
/**
* 获取
* @return id
*/
public int getId() {
return id;
}
/**
* 设置
* @param id
*/
public void setId(int id) {
this.id = id;
}
/**
* 获取
* @return title
*/
public String getTitle() {
return title;
}
/**
* 设置
* @param title
*/
public void setTitle(String title) {
this.title = title;
}
/**
* 获取
* @return time
*/
public String getTime() {
return time;
}
/**
* 设置
* @param time
*/
public void setTime(String time) {
this.time = time;
}
/**
* 获取
* @return score
*/
public double getScore() {
return score;
}
/**
* 设置
* @param score
*/
public void setScore(double score) {
this.score = score;
}
/**
* 获取
* @return area
*/
public String getArea() {
return area;
}
/**
* 设置
* @param area
*/
public void setArea(String area) {
this.area = area;
}
/**
* 获取
* @return type
*/
public String getType() {
return type;
}
/**
* 设置
* @param type
*/
public void setType(String type) {
this.type = type;
}
/**
* 获取
* @return director
*/
public String getDirector() {
return director;
}
/**
* 设置
* @param director
*/
public void setDirector(String director) {
this.director = director;
}
/**
* 获取
* @return starring
*/
public String getStarring() {
return starring;
}
/**
* 设置
* @param starring
*/
public void setStarring(String starring) {
this.starring = starring;
}
}
package test;
import graph6.Movie;
import java.util.Scanner;
public class MovieService {
private Movie[] movies;//成员变量
private Scanner sc=new Scanner(System.in);
public MovieService(Movie[] movies) {
this.movies=movies;//成员变量赋值
}
/**
*启动电影信息管理系统
*/
public void start() {
lo://加标
while (true) {
System.out.println("----------电影信息管理系统-------------");
System.out.println("请输入您的选择");
System.out.println("1.查询全部电影信息");
System.out.println("2.根据id查询电影信息");
System.out.println("3.退出");
int choice=sc.nextInt();
//判断，匹配数字
switch (choice){
case 1:
queryMovieInfos();
break;
case 2:
queryMovieInfoById();
break;
case 3:
System.out.println("感谢您的使用再见！");
break lo;
default:
System.out.println("您的输入有误，请检查");
break;
}
}
}
/**
* 此方法根据电影编号，查询电影详情信息
*/
private void queryMovieInfoById() {
//1.键盘录入用户输入的编号
System.out.println("请输入您要查找的电影编号：");
int id=sc.nextInt();
//2.遍历数组，从数组中查询信息
for (int i = 0; i < movies.length; i++) {
Movie movie = movies[i];
if(movie.getId()==id){
//3.将找到的电影信息，打印在控制台
System.out.println(movie.getId()+"----"+movie.getTitle()+"-----"+movie.getArea()+"-----"+movie.getScore()+"-----"+movie.getTime());
return;
}
}
System.out.println("您输入的编号不存在，请检查！");
}
/**
* 展示系统中的全部电影信息
*/
private void queryMovieInfos() {
for (int i = 0; i < movies.length; i++) {
Movie movie = movies[i];
// System.out.println(movie); 打印对象名，会看到内存地址
//2.通过电影对象，调用内部getXxx方法，获取信息并打印
System.out.println(movie.getTitle()+"--------"+movie.getScore());
}
}
}
package test;
import graph6.Movie;
public class Test {
public static void main(String[] args) {
Movie movie1=new Movie(1 , "东八区的先生们", "222", 2.1, "中国大陆", "剧情 喜剧","夏睿", "张翰 王晓晨");
Movie movie2 =new Movie( 2, "上海经杂","2019", 2.9, "中国大陆", "爱情 战争 科幻", "滕华涛", "舒淇");
Movie movie3 = new Movie( 3,"纯洁心灵·逐梦演艺圈","2015",2.5, "中国大陆","剧情 喜剧", "毕志飞","朱一文 李彦漫");
Movie[] movies={movie1,movie2,movie3};
//该如何将一个类中的数据，传递给另一个类
MovieService movieService=new MovieService(movies);
movieService.start();
}
}
API帮助文档的使用
String类
(38条消息) java String类（超详细！）_一个快乐的野指针~的博客-CSDN博客
(38条消息) Java基础之String类型详解_阿星_Alex的博客-CSDN博客
(38条消息) Java中的常量优化机制_什么叫常量优化_aledsan的博客-CSDN博客
字符串比较内容
/*
String类中用于比较的方法:
public boolean equals(Object anObject)将此 字符串 与指定的对象比较
public boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写
*/
package graph6;
public class StringDemo {
public static void main(String[] args) {
String s1="abc";
String s2=new String("abc");
System.out.println(s1==s2); //false;
System.out.println(s1.equals(s2)); //true;
System.out.println("------------------------------");
String ss1="abc";
String ss2="ABC";
System.out.println(ss1.equals(ss2)); //false
System.out.println(ss1.equalsIgnoreCase(ss2)); //true
}
}
package graph6;
import java.util.Scanner;
public class StringDemo {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
//1.定义两个字符串类型变量，模拟已经存在的用户名和密码
String username="admin";
String password="123456";
for (int i=1;i<=3;i++){
//2.键盘录入用户输入的用户名，密码
System.out.println("请输入用户名：");
String inputUsername=sc.nextLine();//字符串记得nextline
System.out.println("请输入密码：");
String inputPassword=sc.nextLine();
//3.比较
if (inputUsername.equals(username)&&inputPassword.equals(password)){
System.out.println("登录成功");
break;
}else {
if(i==3){
System.out.println("明天再来");
}
System.out.println("登录失败,您还剩余"+(3-i)+"次机会");
}
}
}
}
字符串遍历
toCharArray比较快，方法调用到数组进入循环，CharAt需要多次进栈弹栈
package graph6;
import java.util.Scanner;
public class StringDemo {
public static void main(String[] args) {
//1.键盘录入一个字符串
Scanner sc=new Scanner(System.in);
System.out.println("请输入：");
String content=sc.nextLine();
//2.定义三份计数器变量，用于统计操作
int smallContent=0;
int bingContent=0;
int numCount=0;
//3.遍历字符串，获取每一个字符
char[] chars = content.toCharArray();
for (int i = 0; i < chars.length; i++) {
char c = chars[i];
//4.在遍历的过程中，加入if判断，看字符属于哪一种类别
//5.对应的计数器变量自增
if(c>='a'&&c<='z'){
smallContent++;
} else if (c>='A'&&c<='Z') {
bingContent++;
} else if (c>='0'&&c<='9') {
numCount++;
}
}
//6.在遍历结束后，将统计好的计数器变量，打印在控制台
System.out.println("小写字母字符："+smallContent+"大写字母字符:"+bingContent+"数字字符:"+numCount);
}
}
String类的截取
String替换
String切割
建议: 先正常指定切割规则，后来发现没有得到自己要的效果，就可以尝试在规则前面，加入 \\
StringBuilder类
package graph6;
import java.util.Scanner;
public class StringBuilderDemo {
public static void main(String[] args) {
//获取1970年1月1日0时0分0秒到现在所经历的毫秒值（1秒=1000毫秒）
long time = System.currentTimeMillis();
System.out.println(time);
}
}
//1682140737759
//数值不停变化，因为时间不停变化
package graph6;
public class StringBuilderDemo {
public static void main(String[] args) {
/*
StringBuilder提高字符串的操作效率
*/
long start = System.currentTimeMillis();
StringBuilder sb=new StringBuilder();
for (int i=1;i<=100000;i++){
sb.append(i);
}
System.out.println(sb);
long end = System.currentTimeMillis();
System.out.println(end-start);
}
}
//25
StringBuilder常用成员方法
(43条消息) Java中StringBuilder的常用方法_stringbuilder的方法_①蓑烟雨的博客-CSDN博客
public StringBuilder append(任意类型)
public StringBuilder reverse()
public int length()
public String toString()
回文串反转
需求:
键盘接受一个字符串，程序判断出该字符串是否是对称字符串(回文字符串)，并在控制 台打印是或不是 对称字符串: 123321、111
非对称字符串: 123123
思路:对拿到的字符串进行反转，反转后的内容，跟原数据相同，判定为回文字符串
package graph6;
import java.util.Scanner;
public class StringBuilderDemo {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个对称字符串：");
String content= sc.nextLine();
//将String转换成StringBuilder，为了调用内部反转的方法
StringBuilder sb =new StringBuilder(content);
sb.reverse();
System.out.println(sb);
}
}
String ---> StringBuilder
String s ="abc":
StringBuilder sb = new StringBuilder(s);
StringBuilder ---> String
String s = sb.toString();
判断是否是回文串
package graph6;
import java.util.Scanner;
import java.util.Set;
public class StringBuilderDemo {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个对称字符串：");
String content= sc.nextLine();
//将String转换成StringBuilder，为了调用内部反转的方法
StringBuilder sb =new StringBuilder(content);
sb.reverse();
//判断反转后的内容，和原数据是否相同
// content:String类型
// sb:StringBuilder类型
if(content.equals(sb.toString())){
System.out.println("是对称字符");
}else {
System.out.println("不是对称字符");
}
}
}
需求:
定义一个方法，把int数组中的数据按照指定的格式拼接成一个字符串返回调用该方法，并在控制台输出结果。
例如:数组为int[] arr = {1,2,3};
执行方法后的输出结果为: [1，2，3]
package graph6;
import java.util.Scanner;
import java.util.Set;
public class StringBuilderDemo {
public static void main(String[] args) {
int[] arr={1,2,3};
arrayToString(arr);
}
public static void arrayToString(int[] arr){
//1.创建StringBuilder，尊宝进行拼接
StringBuilder sb=new StringBuilder("[");
//2.遍历数组，获取内部元素
for (int i = 0; i < arr.length-1; i++) {
//3.拼接
sb.append(arr[i]).append(", ");
}
//特殊处理最后一个元素
sb.append(arr[arr.length-1]).append("]");
System.out.println(sb);
}
}
5. 集合
集合和数组的使用选择
数组:存储的元素个数固定不变集合:存储的元素个数经常发生改变
ArrayList集合的使用:
细节:创建String，StringBuilder，ArrayList类的对象，打印对象名，都没有看到地址值，而是元素内容。
构造方法 :
public ArrayList() : 创建一个空的集合容器集合容器的创建细节 :
ArrayList list = new ArrayList();
现象: 可以添加任意类型数据
弊端: 数据不够严谨
ArrayList<String> list = new ArrayList<>();<>: 泛型
目前: 使用泛型，可以对集合中存储的数据，进行类型限制细节:泛型中，不允许编写基本数据类型
问题: 那我要是想集合中，存储 整数，小数，字符... 这些数据，怎么办呢?
解决:使用基本数据类型，所对应的包装类
ArrayList 集合常用成员方法
集合遍历
package graph6;
import java.util.ArrayList;
public class ArrayListTest1 {
public static void main(String[] args) {
ArrayList<String> list=new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五");
//遍历集合
///集合获取长度用size
for (int i=0;i< list.size();i++){
String s = list.get(i);//拿到集合中的每一个元素
System.out.println(s);
}
}
}
键盘录入学生信息到集合
package graph6;
import java.util.ArrayList;
import java.util.Scanner;
public class ArrayListTest1 {
public static void main(String[] args) {
//准备集合容器，用于存储学生对象
ArrayList<Student> list=new ArrayList<>();
//调用三次搞定三个学生对象
for (int i=1;i<=3;i++){
System.out.println("请输入第"+i+"个学生信息：");
addStudent(list);
}
//5.遍历集合，打印学生信息
for (int i = 0; i < list.size(); i++) {
Student stu=list.get(i);
System.out.println(stu.getName()+"----"stu.getName());
}
}
private static void addStudent(ArrayList<Student> list) {
//每个功能单独抽取出方法 方便管理
//2.键盘录入学生信息
Scanner sc=new Scanner(System.in);
System.out.println("请输入学生姓名：");
String name= sc.next();
System.out.println("请输入学生年龄：");
int age= sc.nextInt();
//3.将键盘录入的学生信息，封装为学生对象
Student stu=new Student(name,age);
//4.将封装好的学生对象，存入集合
list.add(stu);
}
}集合删除元素
package graph6;
import java.util.ArrayList;
import java.util.Scanner;
public class ArrayListTest1 {
public static void main(String[] args) {
//准备集合容器，用于存储学生对象
ArrayList<String> list = new ArrayList<>();
list.add("test");
list.add("张三");
list.add("李四");
list.add("test");
list.add("test");
for (int i = 0; i < list.size(); i++) {
String s = list.get(i);
if ("test".equals(s)) {
list.remove(i);
//正序遍历不要忘记删除
i--;
}
}
System.out.println(list);
System.out.println("----------------------");
for (int i = list.size() - 1; i >= 0; i--) {
String s = list.get(i);
if ("test".equals(s)) {
list.remove(i);
}
}
System.out.println(list);
}
}6.学生信息管理系统
1.学信信息类的创建
package com.itheima.domain;
public class Student {
private String id;
private String name;
private int age;
private String birthday;
public Student() {
}
public Student(String id, String name, int age, String birthday) {
this.id = id;
this.name = name;
this.age = age;
this.birthday = birthday;
}
/**
* 获取
* @return id
*/
public String getId() {
return id;
}
/**
* 设置
* @param id
*/
public void setId(String id) {
this.id = id;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
/**
* 获取
* @return birthday
*/
public String getBirthday() {
return birthday;
}
/**
* 设置
* @param birthday
*/
public void setBirthday(String birthday) {
this.birthday = birthday;
}
}
2.功能实现——增删查改
package com.itheima.test;
import com.itheima.domain.Student;
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Scanner;
public class Test{
public static void main(String[] args) {
//增删查改都是围绕着这个进行操作
ArrayList<Student>list=new ArrayList<>();
Scanner sc = new Scanner(System.in);
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("请输入您的选择：");
int choice=sc.nextInt();
switch (choice){
case 1:
addStudentInfos(list);
break;
case 2:
deleteStudentById(list);
break;
case 3:
updateStudentInfos(list);
break;
case 4:
queryStudentInfos(list);
break;
case 5:
System.out.println("感谢您的输入，再见！");
System.exit(0); //终止正在运行的jvm虚拟机
break;
default:
System.out.println("您的输入有误，请检查");
break;
}
}
}
/**
* 此方法用于键盘录入学生信息，封装学生对象，存入集合
* @param list
*/
private static void addStudentInfos(ArrayList<Student> list) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入学生学号：");
String id="";
while (true){
id = sc.next();
int index=getIndex(id,list);
if (index==-1){
//学号在集合中不存在，可以使用
break;
}else {
System.out.println("您输入的学号已被占用，请重新输入！");
}
}
System.out.println("请输入学生姓名：");
String name=sc.next();
System.out.println("请输入学生年龄：");
int age=sc.nextInt();
System.out.println("请输入学生生日：");
String birthday=sc.next();
Student stu = new Student(id,name,age,birthday);
list.add(stu);
System.out.println("添加成功！");
}
/**
* 根据学号修改集合中的学生信息
* @param list
*/
private static void updateStudentInfos(ArrayList<Student> list) {
//1.键盘录入要修改的学生学号
Scanner sc=new Scanner(System.in);
System.out.println("请输入您要修改的学号：");
String updateID= sc.next();
//2. 调用getIndex查找学号在集合中的索引位置
int index = getIndex(updateID, list);
//3.判断方法的返回值是否是-1
if(index==-1){
//4.-1给出错误提示
System.out.println("查无此人，修改失败！");
}else {
//5.不是-1，说明学号存在，录入新的学生信息，完成修改
System.out.println("请输入新的学生姓名：");
String name=sc.next();
System.out.println("请输入新的学生年龄：");
int age=sc.nextInt();
System.out.println("请输入新的学生生日：");
String birthday=sc.next();
//拿到新的学生信息，封装为学生对象，
Student stu=new Student(updateID,name,age,birthday);
//调用集合set方法
list.set(index,stu);
System.out.println("修改成功！");
}
}
/**
* 根据学号删除集合中的学生
*/
public static void deleteStudentById(ArrayList<Student> list){
//1.键盘录入要删除的学生学号
Scanner sc=new Scanner(System.in);
System.out.println("请输入您要删除的学号：");
String id= sc.next();
//2.调用getIndex查找学号在集合中的索引位置
int index = getIndex(id, list);
//3.判断方法的返回值是否是-1
if(index==-1){
//4.-1给出错误提示
System.out.println("查无此人，删除失败！");
}else {
//5.不是-1，说明学号存在，根据索引删除
list.remove(index);
System.out.println("删除成功" );
}
}
/**
* 此方法用于查看学生
*/
private static void queryStudentInfos(ArrayList<Student> list) {
if(list.size()==0){
System.out.println("查无信息，请添加后重试");
}else {
System.out.println("学号\t姓名\t生日\t\t\t年龄\t");//制表符
for (int i = 0; i < list.size(); i++) {
Student stu = list.get(i);//遍历获取数据 .var
System.out.println(stu.getId()+"\t"+stu.getName()+"\t"+stu.getBirthday()+"\t"+stu.getAge());
}
}
}
/**
此方法根据学号，去集合中查找到对应的索引
*/
private static int getIndex(String id, ArrayList<Student> list) {
//1.遍历集合，获取每一个元素
for (int i = 0; i < list.size(); i++) {
Student stu = list.get(i);
// stu.getId():从集合中取出的学生学号
// id：要查找的学号
//2.比对
if (stu.getId().equals(id)) {
return i;
}
}
return -1;
}
}7. 面向对象高级
static关键字
(41条消息) static的概念及其应用_static 定义_宏夏c的博客-CSDN博客
static 关键字 :
修饰符，可以修饰成员变量（类变量、静态变量），成员方法（类方法、静态方法）
特点:
- 被类(Student)的所有对象(stu1 stu2)所共享
- 多了一种调用方式，可以通过类名进行调用(推荐使用类名调用Student.）
- 随着类的加载而加载，优先于对象存在
直接拿类名调用
1.什么时候用static成员变量？
如果你的数据需要被这个类的所有对象共享
继承
全部私有调用get set
继承中成员变量和成员方法的访问特点
关键字super
方法重写
权限修饰符
继承中的成员访问特点——构造方法
package com.itheima.constructor;
public class Test1 {
public static void main(String[] args) {
Zi z1 = new Zi();//子类的空参构造方法
Zi z2 = new Zi(10);//子类的带参构造方法
}
}
class Fu {
public Fu(){
System.out.println("父类的空参构造方法");
}
public Fu(int num){
System.out.println("父类的带参构造方法。。。");
}
}
class Zi extends Fu{
public Zi(){
System.out.println("子类的空参构造方法");
}
public Zi(int num){
System.out.println("子类的带参构造方法。。。");
}
}
/*
父类的空参构造方法
子类的空参构造方法
父类的空参构造方法
子类的带参构造方法。。。
*/
继承关系的内存图解
(50条消息) java 继承关系的内存图解 （通俗易懂)_java继承内存图_Cyan_RA9的博客-CSDN博客
案例
package com.itheima.constructor;
public class Employee {
private String name;
private int age;
private int salary;
public Employee() {
}
public Employee(String name, int age, int salary) {
this.name = name;
this.age = age;
this.salary = salary;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
/**
* 获取
* @return salary
*/
public int getSalary() {
return salary;
}
/**
* 设置
* @param salary
*/
public void setSalary(int salary) {
this.salary = salary;
}
public void work(){
System.out.println("员工工作");
}
}
package com.itheima.constructor;
public class Coder extends Employee{
public Coder() {
}
public Coder(String name, int age, int salary) {
super(name, age, salary);
}
public void work(){
System.out.println("姓名为"+super.getName()+"，年龄为"+super.getAge()+"工资为"+super.getSalary()+"的程序员正在编写代码");
}
}
package com.itheima.constructor;
public class Manager extends Employee{
private int bonus;
public Manager() {
}
public Manager(String name, int age, int salary,int bonus) {
super(name, age, salary);
this.bonus = bonus;
}
public int getBonus() {
return bonus;
}
public void setBonus(int bonus) {
this.bonus = bonus;
}
public void work(){
System.out.println("姓名为"+super.getName()+"，年龄为"+super.getAge()+"工资为"+super.getSalary()+",奖金为"+bonus+"的项目经理正在分配任务");
}
}
package com.itheima.constructor;
public class Test {
public static void main(String[] args) {
Manager manager = new Manager("张三",24,18000,5000);
manager.work();
Coder coder = new Coder("李四",23,15000);
coder.work();
}
}
this和super
- this表示当前对象引用,调用本类(包括继承)的属性、方法、本类构造方法
- super表示父类对象引用,调用父类的属性、方法、构造方法
this或super使用在构造方法中时，都要求在首行。
当子类构造中使用了this （）或this(实参)
即不可再同时书写super （）或super (实参)
会由this（） 指向的构造方法完成super ( ）的调用
final关键字
修饰方法:表明该方法是最终方法，不能被重写
修饰类:则该类会成为最终类，即该类不能被继承（俗称“断子绝孙类”），但是该类可以有父类
以下会报错！！！
修饰变量:表明该变量是常量，不能再次被赋值
变量：
基本数据类型:数据值不可改变
引用数据类型: 地址值不可改变，但是内容可以改变
！！引用数据类型是地址，就算地址不变了，地址里的数据是可以变的
新地址会报错！
修饰成员变量，不允许修改默认值
在构造方法里赋值也可以
在普通成员变量里赋值不可以
final修饰变量的命名规范 :
如果变量名是一个单词， 所有字母大写 MAX
如果变量名是多个单词，所有字母大写，中间使用下划线分割 MAX_VALUE
包
抽象类
图解抽象
如何使用抽象类和抽象方法:
1.不能直接创建new抽象类对象
2.必须用一个子类来继承抽象父类。子类必须覆盖重写抽象父类当中所有的抽象方法。 3.覆盖重写(实现):子类去掉抽象方法的abstract关键字，然后补上方法体大括号。
4.创建子类对象进行使用。
public abstract class AbstractClassAnimal {
public static void main(String[] args) {
// 创建子类的对象
Cat cat = new Cat();
// 调用 run() 方法
cat.eat();
}
}
/**
* 这是一个抽象类（包含有一个抽象方法的类），抽象类动物
*/
abstract class Animal {
/**
* 这是一个抽象方法（只有方法声明，没有方法体），抽象方法吃，代表吃，但具体吃什么（）大括号的内容不确定
*/
public abstract void eat();
}
class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼~~~");
}
}抽象类的注意事项
接口
public interface 接口名称 {
// 抽象方法
// 默认方法
// 静态方法
// 私有方法
}
接口的抽象方法定义
接口的抽象方法使用
1、定义一个接口类，在接口类里面定义抽象方法
抽象方法的格式：
public abstract 返回值类型 方法名称(参数列表)；接口当中的抽象方法，修饰符必须是两个固定的关键字，即public abstract；这两个关键字不能更换成别的，但是能够省略。因为是默认的。
2、由于接口不能直接使用，接口的实现类必须覆盖重写 (实现) 接口中所有的抽象方法。因此要新建一个类来实现调用，去掉abstract关键字，加上方法体大括号。
实现接口类的格式：
public class 实现类的名称 implements 接口名称{
方法体：
}
ALT+回车键
3、创建实现类的对象，进行使用 。
// 错误写法!不能直接new接口对象使用。要用”实现类“来“实现”该接口
MyInterfaceAbstract inter = new MyInterfaceAbstract();
以下是创建实现类的对像使用
运行结果：
接口的默认方法定义
public default 返回值类型 方法名称(参数列表){
方法体
}
备注:接口当中的默认方法，可以解决接口升级的问题。
接口的默认方法使用
/**
* 这是一个含有默认方法的接口
*/
public interface InterfaceNameDefaultMethod {
/**
* 这是一个默认方法
*/
public default void method() {
System.out.println("这里就是一个默认方法体！");
}
}
接口的静态方法定义
从Java 8开始，接口当中允许定义静态方法。格式:
public static 返回值类型方法名称(参数列表){
方法体}
提示:就是将abstract或者default换成static即可，带上方法体。
接口的静态方法使用
接口的私有方法定义
1.普通私有方法，解决多个默认方法之间重复代码问题
格式:
private 返回值类型 方法名称(参数列表) {
方法体
}
2.静态私有方法，解决多个静态方法之间重复代码问题
格式:
private static 返回值类型 方法名称(参数列表) {
方法体
}
/**
* 这是一个含有私有方法和私有静态方法的接口，JDK9以及以上版本才支持
*/
public interface InterfaceNamePrivateMethod {
/**
* 这里一个私有方法，JDK9以及以上版本才支持
*/
private void method() {
System.out.println("这里一个私有方法！");
}
/**
* 这里一个私有静态方法，JDK9以及以上版本才支持
*/
private static void method() {
System.out.println("这里一个私有静态方法！");
}
}接口的私有方法使用
package com.itheima.constructor;
/*
问题描述:
我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题。但是这个共有方法不应该让实现类使用，应该是私有化的。
解决方案:
从Java 9开始，接口当中允许定义私有方法。
1.普通私有方法，解决多个默认方法之间重复代码问题
格式:
private 返回值类型 方法名称(参数列表) {
方法体
}
2.静态私有方法，解决多个静态方法之间重复代码问题
格式:
private static 返回值类型 方法名称(参数列表) {
方法体
}
*/
public interface MyInterfacePrivateA {
public default void methodStatic1(){
System.out.println("默认方法1");
System.out.println("AAA");
System.out.println("BBB");
System.out.println("CCC");
}
public default void methodStatic2(){
System.out.println("默认方法2");
//不用上面一样写，直接调用
methodCommon();
}
private void methodCommon(){
System.out.println("AAA");
System.out.println("BBB");
System.out.println("CCC");
}
}
package com.itheima.constructor;
public interface MyInterfacePrivateB {
public static void methodStatic1(){
System.out.println("静态方法1");
methodStaticCommon();
}
public static void methodStatic2(){
System.out.println("静态方法2");
methodStaticCommon();
}
private static void methodStaticCommon(){
System.out.println("AAA");
System.out.println("BBB");
System.out.println("CCC");
}
}
package com.itheima.constructor;
public class MyInterfacePrivateImpl implements MyInterfacePrivateA{
public void methodAnother(){
//直接访问到了接口中的默认方法，这样是错误的！
// methodCommon();
}
}
package com.itheima.constructor;
public class MyInterfacePrivateTest {
public static void main(String[] args) {
MyInterfacePrivateB.methodStatic1();
MyInterfacePrivateB.methodStatic2();
//错误写法
//MyInterfacePrivateB.methodStaticCommon();
}
}
接口的常量定义和使用
接口当中也可以定义“成员变量”，但是必须使用 public static final 三个关键字进行修饰。 从效果上看，这其实就是接口的【常量】。 格式： public static final 数据类型 常量名称 = 数据值； 注: 一旦使用final关键字进行修饰，说明不可改变。 注意事项: 1.接口当中的常量，可以省略public static final ，注意：不写也照样表达这个意思。 2.接口当中的常量，必须进行赋值：不能不赋值。 3.接口中常量的名称，使用完全大写的字母，用下划线进行分隔。(推荐这种命名规则）
接口的内容总结
1.成员变量其实就是常量，
格式：
【public】【 static】【 final】 数据类型 常量名称 = 数据值；
注意：
常量必须进行赋值，而且一旦赋值不能改变。【】里的内容可以省略。
常量名称完全大写，用下划线进行分隔。
2.接口中最重要的就是抽象方法，
格式：
【public】【 abstract】 返回值类型 方法名称（参数列表）；
注意：
实现类必须覆盖重写接口所有的抽象方法，除非实现类是抽象类。
3.从Java 8 开始，接口里允许定义默认方法，
格式：
【public】 default 返回值类型 方法名称（参数列表）{
方法体
}
注意：
默认方法也可以被覆盖重写。
4.从Java 8 开始，接口里允许定义静态方法，
格式：
public static 返回值类型 方法名称（参数列表）{
方法体
}
注意：
应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法。
5. 从Java 9 开始，接口里允许定义私有方法，
格式：
普通私有方法：
private 返回值类型 方法名称（参数列表）{
方法体
}
静态私有方法：
private static 返回值类型 方法名称（参数列表）{
方法体
}
注意：
private的方法只有接口自己本来才能使用，不能被实现类或者其它类使用
继承父类并实现多个接口
注意：
1.接口是没有静态代码块或者构造方法的。
2.一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。
格式：
publlic class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB{
//覆盖重写所有抽象方法
}
3.如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
我妈让我吃饭，我爸让我吃饭，母亲的方法我听了，父亲的方法我也听了
A方法覆盖了，B方法覆盖了，我只要覆盖重写一次即可，因为两人对我的要求是一样的
4.如果实现类没有覆盖重写所有的接口当中的抽象方法，那么实现类就必须是一个抽象类。
5.如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。
父亲让你写语文作业，母亲让你写数学作业，不可能双手同时写 语文数学作业，需要选择一个
进行覆盖重写
6.一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。
java中继承优先于接口实现的。
接口之间的多继承
1.类与类之间是单继承的。直接父类只有一个。
2.类与接口之间是多实现的。一个类可以实现多个接口。
3.接口与接口之间是多继承的。
注意：
1.多个父接口当中的抽象方法如果重复，没关系。
package cn.itcast.day09.java.多继承;
public interface MyInterfaceA {
public abstract void methodA();
public abstract void methodCom();
}package cn.itcast.day09.java.多继承;
public interface MyInterfaceB {
public abstract void methodB();
public abstract void methodCom();
}package cn.itcast.day09.java.多继承;
public interface MyInterface extends MyInterfaceA,MyInterfaceB {
public abstract void method();
} 
2..多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写。
【而且带着default关键字】
package cn.itcast.day09.java.多继承;
public interface MyInterfaceA {
public default void method(){
System.out.println("AAA");
}
}package cn.itcast.day09.java.多继承;
public interface MyInterfaceB {
public default void method(){
System.out.println("BBB");
}
}package cn.itcast.day09.java.多继承;
public interface MyInterface extends MyInterfaceA,MyInterfaceB {
@Override
default void method() {
System.out.println("CCC");
}
}多态
代码当中体现多态性，其实就是一句话：父类引用指向子类对象。
右侧子类对象被当作父类来看，猫被当作动物来看
格式：
父类名称 对象名 = new 子类名称()；//左父右子；
或者：
接口名称 对象名 = new实现类名称()；
多态中成员变量的使用特点
访问成员变量的两种方式：
1.直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找。
2.间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找。
多态中成员方法的使用特点
看new的是谁，就优先用谁，没有则向上找。
简记：编译看左边，运行看右边。
多态的好处：
对象的向上转型
对象的向下转型
instanceof关键字进行类型判断
如何才知道一个父类引用的对象，本来是什么子类？
格式：
对象 instanceof 类名称
这将会得到一个Boolean值结果，也就是判断前面的对象能不能当作后面的实例
package com.itheima.Demo;
public class Demo02Instanceof {
public static void main(String[] args) {
Animal animal=new Cat();//本来是一只猫
animal.eat();//猫吃鱼
//如果希望调用子类特有方法，需要向下转型
//判断父类引用animal本来是不是Dog
if(animal instanceof Dog){
((Dog) animal).watchHouse();
}
//判断animal本来是不是Cat
if(animal instanceof Cat){
Cat cat = (Cat)animal;
cat.catchMouse();
}
givePet(new Dog());
givePet(new Cat());
}
public static void givePet(Animal animal){
if(animal instanceof Dog){
((Dog) animal).watchHouse();
}
//判断animal本来是不是Cat
if(animal instanceof Cat){
Cat cat = (Cat)animal;
cat.catchMouse();
}
}
}
笔记本USB接口案例
笔记本电脑（laptop）通常具备使用USB设备的功能。
在生产时，笔记本都预留了可以插入USB设备的USB接口，
但具体是什么USB设备，笔记本厂商并不关心，只要符合USB规格的设备都可以。
定义USB接口，具备最基本的开启功能和关闭功能。鼠标和键盘要想能在电脑上使用，
那么鼠标和键盘也必须遵守USB规范，实现USB接口，否则鼠标和键盘的生产出来也无法使用。
分析： 进行描述笔记本类，实现笔记本使用USB鼠标、USB键盘
①USB接口，包含打开设备功能、关闭设备功能。
②笔记本类，包含开机功能、关机功能、使用USB设备功能。
③鼠标类，要实现USB接口，并具备点击的方法。
④键盘类，要实现USB接口，具备敲击的方法。
package com.itheima.Demo;
public class DemoMain {
public static void main(String[] args) {
//创建一个笔记本
Computer computer = new Computer();
computer.powerOn();
//准备一个鼠标，供电脑使用
// Mouse mouse = new Mouse();
//首先进行向上转型
USB usbMouse = new Mouse();//左父右子，左边接口，右边实现类//多态写法
//参数是USB类型，我正好传递进去的就是USB鼠标
computer.usbDevice(usbMouse);
//创建一个usb键盘
Keyboard keyboard = new Keyboard();//没有使用多态写法
//方法参数是usb类型，传递进去的是实现类对象
computer.usbDevice(keyboard);//正确写法！
computer.powerOff();
System.out.println("================================");
method(10.0);//正确写法，double--->double
method(20);//正确写法，int--->double
int a=30;
method(a);//正确写法，int--->double
}
public static void method(double num){
System.out.println(num);
}
}
内部类
1.内部类的概念：
如果一个事物的内部包含另一个事物，那么这就是一个类 内部包含另一个类。例如：身体和心脏的关系。又如：汽车和发动机的关系。房子和房间的关系等。
2.内部类的分类：
Ⅰ.成员内部类
Ⅱ.局部内部类（包含匿名内部类）
Ⅰ.成员内部类
成员内部类的定义格式：
修饰符 class 外部类名称 {
修饰符 class 内部类名称 {
//...
}
//...
}
注意：内用外，随意访问；外用内，需要借助内部类对象。
package com.itheima.Demo;
public class Body {//外部类
public class heart{//成员内部类
//内部类的方法
public void beat(){
System.out.println("心脏跳动!!");
System.out.println("我叫:"+name);//正确写法！
}
}
//外部类的成员变量
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//外部类的方法
public void methodBody(){
System.out.println("外部类的方法");
}
}
①间接方式使用成员内部类：
在外部类的方法当中使用内部类，然后mian中只调用外部类的方法。
package com.itheima.Demo;
import java.util.HashMap;
public class Body {//外部类
public class Heart{//成员内部类
//内部类的方法
public void beat(){
System.out.println("心脏跳动!!");
System.out.println("我叫:"+name);//正确写法！
}
}
//外部类的成员变量
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//外部类的方法
public void methodBody(){
System.out.println("外部类的方法");
Heart heart=new Heart();
heart.beat();
}
}
package com.itheima.Demo;
public class Demo01InnerClass {
public static void main(String[] args) {
//外部类的对象
Body body=new Body();
//通过外部类的对象，调用外部类的方法，里面在简洁使用内部类Heart
body.methodBody();
}
}
②直接方式使用成员内部类：
格式：
【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();】
package com.itheima.Demo;
public class Demo01InnerClass {
public static void main(String[] args) {
//外部类的对象
Body body=new Body();
//通过外部类的对象，调用外部类的方法，里面在简洁使用内部类Heart
body.methodBody();
System.out.println("===================");
//按照公式写
Body.Heart heart=new Body().new Heart();
heart.beat();
}
}
Ⅱ.局部内部类（包含匿名内部类）
定义格式：
修饰符 class 外部类名称{
修饰符 返回值类型 外部类方法名称（参数列表）{
class 局部内部类名称{
//...
}
}
}
①内部类的定义和使用
如果一个类是定义在一个方法内部的，那么这个类就是一个局部内部类。
“局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。
package com.itheima.Demo;
public class Outer {
public void methodOuter(){
class Inner{ //局部内部类
int num=10;
public void methodInner(){
System.out.println(num); //10
}
}
Inner inner=new Inner();
inner.methodInner();
}
}
②局部内部类的final问题
局部内部类，如果希望访问所在的方法的局部变量，那么这个局部变量必须是【有效final的】
备注：从java 8以后开始，只要局部变量事实不变，那么final关键字可以省略。
原因：
1.new出来的对象在推内存当中。
2.局部变量事跟着方法走的，在栈内存当中。
3.方法运行结束后，立刻出栈，局部变量就会立刻消失。
4.但是呢我出来的对象会在堆当中持续存在，知道垃圾回收消失。
③.内部类的同名变量访问
如果出现重名现象，那么格式是：外部类名称.this.外部类变量名
package com.itheima.Demo;
public class Outer {
int num=10;//外部类的成员变量
public class Inner /*extends Object*/{//不是继承关系，心脏不是一个身体
int num=20;//内部类的成员变量
public void methodInner(){
int num=30;//内部类方法的局部变量
System.out.println(num);//局部变量，就近原则 30
System.out.println(this.num);内部类的成员变量 20
System.out.println(Outer.this.num);//外部类的成员变量 10
}
}
}
Lambda
(61条消息) Java中的Lambda表达式的使用（详解）_lambda表达式使用条件_肥兄的博客-CSDN博客
766
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
