一.使用Scanner
Scanner 就是一种引用类型,使用步骤如下:
1, 导包: import java,util.Scanner;
2, 创建:Scanner sc =new Scanner(System.in); (ps: 其中System.in 代表从键盘输入)
3, 使用:
a) 获取键盘输入的数字int : int num = sc.nextInt();
b) 获取键盘输入的字符 : String str = sc.next();
二.使用数组
数组是引用类型 使用步骤如下:
1,数组的定义:
a) 数据类型[] 数组名称;
c) 数组类型 数组名称[];
2,数组的初始化:
a) 数据类型[] 数组名称 = new 数据类型 [数组长度];
b) 数据类型[] 数组名称; 数组名称 = new 数据类型[数组长度];
3,数组的输出:
System.out.println(array[]);
三. 集合
1.什么叫做集合?
a)集合跟已经学过的数组比较类似,本身也是一种引用类型,本身也是一种引用类型,而且可以保存很多数据。
b)区别在于数组长度不可改变,集合的长度可以改变。
c)集合包含很多种,ArrayList ,HashSet ,LinkedList 等等,入门我们只学习ArrayList(是一种类)一种即可。
d)ArrayList(中括号代表泛型,统一的类型叫泛型)。
2.Java.util.ArrayList是一个类,使用起来就有三个步骤:
a)导包: import java.util.ArrayList
b)创建:ArrayList 常用构造方法:1.public Array List():默认无参数的构造方法。 ArrayList<泛型> list = new ArrayList<>();(泛型:也就是集合当中存放的全是统一的什么类型的数据。注意: 泛型只能是引用类型数据不能是基本类型,如果一定要存储基本数据,那么就要使用基本类型对应的"包装类",(全部都位于Java.lang 包下,有八种)
基本类型 对应的包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
)。
3.如何使用已经创建好的集合?
a)添加元素: public boolean add( E element) : 向集合当中添加一个元素,参数就是被添加的元素,而返回值是true值就代表成功。
b)获取元素:public E get(int index); 从集合当中获取一个元素,参数是元素索引。
c)获取长度:public int size(): 获取集合元素的个数,集合的长度,得到 int 数字。
package day2;
import java.util.ArrayList;
public class Demo {
public static void main(String[] args) {
ArrayList<String> list1 = new ArrayList<>();// 构造集合。//泛型只能写引用类型,不能是基本类型。
System.out.println(list1);//输出集合,此项并不是一个地址值 而是一对中括号。
list1.add("鹿晗");//添加。下同。
list1.add("赵丽颖");
list1.add("吴亦凡");
list1.add("张艺兴");
System.out.println(list1);//打印集合。
Boolean success = list1.add("关小童");//集合返回的是Boolean 类型 因此success得到的的是true值。
System.out.println(success);
System.out.println(list1.get(2));//跟数组类似,这项得到的是集合的第二号元素。
System.out.println(list1.size());//得到集合的长度
}
}
遍历集合当中的所有字符串对象:
for(int i =0; i < list1.size(); i ++ )
{
String result = list1.get(i);
System.out.println(result);
}
4.添加基本类型:
代码如下:
ArrayList<Integer> list2 = new ArrayList<>();
list2.add(100);
list2.add(250);
System.out.println(list2);
基本类型可以和对应的包装类进行自动装箱拆箱:
装箱 :基本类型 ——> 包装类。
拆箱 :包装类——> 基本类型。
5.集合存储自定义类型对象
同String类似。
四. 接口
1.接口的基本定义格式:
public interface 接口名称{
1.抽象方法
2.常量
3.默认方法
4.静态方法
5.私有方法
}
2.接口定义抽象方法:
public abstract 返回值类型 方法名称(参数类型 参数名称);
注意:a) 接口中的抽象方法,修饰符如果写必须写成:public abstract。
b)接口的抽象方法,修饰符可以省略不写,默认就是 public abstract。
c)抽象方法只有方法头, 不可能有方法大括号。
3.接口实现类的定义:
a)如果想要使用定义好的接口,必须有个接口的"实现类": 定义实现类的格式为:public class 实现类的名称 implements 接口名称{
//一定要覆盖重写所有的抽象方法。
}
b)什么是覆盖重写抽象方法?
将接口当中的抽象方法抄写过来,去掉Abstract关键字,写上大括号方法体。
4.如何使用接口与实现类?
创建: 接口名称 引用名 =new 实现类名称();
调用: 引用名 . 抽象方法名(参数);以下代码实现:
定义接口类:
package day2;
//接口类!!!
public interface Animal {
public abstract void eat();
public abstract void sleep();
public abstract void speak();
}
package day2;
//实现类!!!
public class Cat implements Animal{
public void eat() {
System.out.println("猫吃鱼!!!");
}
public void sleep() {
System.out.println("猫睡觉!!!");
}
public void speak() {
System.out.println("喵喵喵!!!");
}
public void catchMouse() //非接口抽象方法。
{
System.out.println("猫抓老鼠!!!");
}
}
package day2;
//实现类!!!
public class Dog implements Animal {
@Override
public void eat() {
System.out.println("狗吃骨头!!!");
}
public void sleep() {
System.out.println("狗睡觉!!!");
}
public void speak() {
System.out.println("汪汪汪!!!");
}
}
package day2;
//方法的调用!!!
public class Demo {
public static void main(String[] args) {
Animal cat = new Cat();//左边是接口类型,那么只能调用接口当中定义好的内容,不能调用右侧实现类当中特有的内容。(接口隔离)
Animal dog = new Dog();
//调用接口中定义好的方法
cat.eat();
dog.eat();
cat.catchMouse();//错误,非接口方法
}
}
5.面向接口编程
创建一个猫类。创建一个狗类。分别有吃饭睡觉等动作。运用接口,用一个方法输出。
见代码:
package day2;
//方法的调用!!!
public class Demo {
public static void main(String[] args) {
Animal cat = new Cat();//左边是接口类型,那么只能调用接口当中定义好的内容,不能调用右侧实现类当中特有的内容。(接口隔离)
Animal dog = new Dog();
//调用接口中定义好的方法
cat.eat();
dog.eat();
method(cat);//将猫对象传递给方法,间接使用其中的eat(), sleep()方法。
method(dog);
}
public static void method(Animal animal)//使用接口作为参数类型,这样就不区分到底是猫是狗。
{
animal.eat();
animal.sleep();
animal.catchMouse(); //错误!!!无法调用猫的专用方法
}
}
6.Lambda表达式
初步理解:先看问题:通过调用接口实现两个数相加。
面向对象代码如下:
package day1;
public interface Calculator {
int sum(int a,int b);
}
package day1;
public class Cal implements Calculator {
public int sum(int a, int b) {
return a + b;
}
}
package day1;
public class Main {
public static void main(String[] args) {
Calculator cal = new Cal();
method(cal);
}
public static void method(Calculator calculator)
{
int result = calculator.sum(100,200);
System.out.println("结果是:" + result);
}
}
但是使用Lambda表达式可以使结构更加简单:
package day2;
public interface Calculator {
int sum(int a , int b);
}
package day2;
public class Main {
public static void main(String[] args) {
method((x,y) -> x + y);
}
public static void method(Calculator calculator )
{
int result = calculator. sum(100,200);
System.out.println("结果是:" + result);
}
}
a)Lambda表达式: (x , y)->x + y;
b) method 方法需要一个Calculator接口类型的参数,Lambda表达式就充当了Calculator接口类型的参数。
c)对表达式的初步理解:Lambda前面的小括号其实就是接口抽象方法的小括号。箭头代表拿着小括号做什么事,是指向一个动作。箭头后 面的就代表拿了参数做什么事情。Lambda表达式的语义本身就代表了怎么做这件事,没有对象的概念在里面。(更加简单直观),但是接口抽象方法只能有一个。
d)函数式接口:有且仅有一个抽象方法的接口叫做函数式接口。如何才能万无一失检测一下当前接口是不是函数接口?:
用一固定格式写在、public interface 之前一行即可:
package day2;
@FunctionalInterface
public interface Calculator {
int sum(int a , int b);
}
7.获取Stream流的常用方式
a) Java 8 当中的流其实就是Stream接口对象。 JDK提供一个流接口:java.util.stream.Stream
b)如何获取流?
(1).根据集合获取流:集合名称.stream();
(2).根据数组获取流:Stream.of(数组名称);
package day3;
import java.util.ArrayList;
import java.util.stream.Stream;
public class GetStream {
public static void main(String[] args) {
//根据集合获取流;
ArrayList<String> list = new ArrayList<>();
list.add("迪丽热巴");
list.add("古丽拉扎");
list.add("马尔扎哈");
list.add("德玛西亚");
//根据集合获取流:
Stream<String> streamA = list.stream();
//根据数组获取流
String[] arrayStr = {"Hello","world","Java"};
Stream<String> streamB = Stream.of(arrayStr);
Integer[] arrayInteger = {1,2,3,4};
//获取整数流
Stream<Integer> streamC = Stream.of(arrayInteger);
}
}
既然获取了流,那我们就要输出流。如何输出流呢?这里通过map映射方法输出流。
获取流之后,可以使用映射方法:map(用于转换的Lambda表达式。映射:就是将一个对象转换成为另一个对象,把老对象映射到新对象上。)