第一章.可变参数
java
1.需求:定义一个方法,实现若干个整数相加
参数:类型确定了,但是个数不确定1介绍和基本使用
java
1.格式:
数据类型...变量名
2.本质:数组
3.注意:
参数位置只能有一个可变参数,而且只能放到最后
java
public class Demo01Var {
public static void main(String[] args) {
add(1, 2, 3, 4, 5);//new int[]{1,2,3,4,5}
}
public static void add(int data,int... arr) {//int[] arr
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
System.out.println(sum);
}
}2.练习
2.1.字符串拼接
需求一：返回n个字符串拼接结果，如果没有传入字符串，那么返回空字符串""
java
public class Demo02Var {
public static void main(String[] args) {
String result = concat("张三", "李四", "王五", "赵六", "田七", "朱八");
System.out.println(result);
}
public static String concat(String...s){
//定义一个空字符串
String str = "";
for (int i = 0; i < s.length; i++) {
str+=s[i];
}
return str;
}
}2.2.字符串拼接分隔符
java
n个字符串进行拼接，每一个字符串之间使用某字符进行分隔，如果没有传入字符串，那么返回空字符串""
concat("-","张三","李四","王五") -> 返回的是 -> 张三-李四-王五
java
public class Demo03Var {
public static void main(String[] args) {
String result = concat("-", "张三", "李四", "王五", "赵六");
System.out.println(result);
}
public static String concat(String sep,String...s){
//定义一个空字符串
String str = "";
for (int i = 0; i < s.length; i++) {
if (i == s.length-1){
str+=s[i];
}else{
str+=s[i]+sep;
}
}
return str;
}
}第二章.递归
java
1.概述:方法内部自己调用自己
2.表现形式:
a.方法自己调用自己-> 最常见
b.方法之间互相调用
3.注意:
a.递归需要有出口,否则会出现"栈内存溢出"
b.即使有出口,也不要递归太多次
java
public class Demo01DiGui {
public static void main(String[] args) {
method();
}
public static void method(){
method();
}
}1.用递归输出3到1
java
public class Demo02DiGui {
public static void main(String[] args) {
method(3);
}
public static void method(int n){
if (n==1){
System.out.println(n);
return;//结束方法
}
System.out.println(n);
n--;
method(n);
}
}2.求n!
java
1.需求:求3的阶乘
3*2*1
2.分析:
a.定义一个方法,代表阶乘,参数代表多少的阶乘 -> method(n)
b.找规律:
method(3) -> 3*method(2)
method(2) -> 2*method(1)
method(n) -> n*method(n-1)
java
public class Demo03DiGui {
public static void main(String[] args) {
int result = method(3);
System.out.println(result);
}
private static int method(int n) {
if (n==1){
return 1;
}
return n*method(n-1);
}
}
示例三：计算斐波那契数列（Fibonacci）的第n个值
java
不死神兔
故事得从西元1202年说起，话说有一位意大利青年，名叫斐波那契。
在他的一部著作中提出了一个有趣的问题：假设一对刚出生的小兔一个月后就能长成大兔，再过一个月就能生下一对小兔，并且此后每个月都生一对小兔，一年内没有发生死亡
问：一对刚出生的兔子，一年内繁殖成多少对兔子? 144规律：一个数等于前两个数之和，比如: 1 1 2 3 5 8 13 21 34 55...
java
分析:
1.定义一个方法,代表生兔子的对数,参数为月份
2.找规律
method(1) 1
method(2) 1
method(3) 2 method(1)+method(2)
method(4) 3 method(2)+method(3)
method(5) 5 method(3)+method(4)
method(n) = method(n-1)+method(n-2)
java
public class Demo04DiGui {
public static void main(String[] args) {
int result = method(12);
System.out.println(result);
}
private static int method(int n) {
if (n==1||n==2){
return 1;
}
return method(n-1)+method(n-2);
}
}第三章.类和对象
java
java核心编程思想:面向对象
面向对象:自己的事情找对象去帮我们做 -> 编程简单
面向过程:C语言的编程思想 -> 讲究的是自己的事情自己做1.面向对象的介绍
java
1.什么是面向对象思想:java的核心编程思想
2.为啥使用面向对象思想:为了少写代码,很多功能别人写好了,我们只需要直接调用即可,至于人家怎么实现的,我们不需要关心
3.什么时候使用面向对象思想:
调用别的类中的成员,就要使用面向对象思想编程
4.怎么使用面向对象思想编程:
a.new对象,new完去点 -> 比如 new Scanner new Random
b.特殊:不用new对象,直接类名点 -> 适用于被点的成员上带static关键字 -> 比如Arrays System类
java
public class Demo01Object {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
/*
next()方法就是Scanner这个对象实现好的功能
我们直接new完调用,就可以实现键盘录入字符串
至于人家怎么实现的,跟我没有关系
只需要new,new完点
*/
String data = sc.next();
System.out.println(data);
System.out.println("====================");
int[] arr = {1,2,3,4,5};
/*
Arrays就是咱们找来的对象
toString方法就是这个对象中实现好的功能
我们直接调用,就可以实现数组的打印
至于人家怎么实现的,跟我没有关系
*/
System.out.println(Arrays.toString(arr));
}
}2.类和对象
2.1类(实体类)_class
java
1.概述:一类事物的抽象表示形式
2.类的分类:
a.测试类 -> 带main方法的类,用于跑代码的,测试代码
b.逻辑类 -> 写业务逻辑的
c.实体类 -> 用于描述世间万物的分类
java
1.实体类包含的成员:
属性(这个分类有啥) -> 成员变量
a.定义位置:类中方法外
b.作用范围:整个这个类都能使用
c.定义格式: 数据类型 变量名
d.成员变量有默认值
整数 0
小数 0.0
字符 '\u0000'
布尔 false
引用 null
行为(这个分类能干啥) -> 成员方法
将之前定义的方法中的static干掉
java
public class Person {
//属性
String name;//null
int age;//0
//行为
public void eat(){
System.out.println("人要吃饭");
}
public void drink(){
System.out.println("人要喝水");
}
public void la(){
System.out.println("人要拉屎");
}
public void sa(){
System.out.println("人要撒尿");
}
}描述动物类
javapublic class Animal { //属性 String brand; int age; //行为 public String run(){ return "动物在跑"; } public String eat(){ return "动物在吃"; } }描述手机类
javapublic class Phone { //属性 String brand; double price; String color; //行为 public void call(String name){ System.out.println("给"+name+"打电话"); } public String message(String name){ return "给"+name+"发短信"; } }
2.2.对象
java
1.概述:一类事物的具体体现
2.使用:
a.导包:import 包名.类名
如果两个类在同一个包下,使用对方的成员不需要导包
如果两个类不在同一个包下,使用对方的成员需要导包
特殊包:java.lang包 -> 使用lang包下的类不需要导包
b.创建对象:想使用哪个类中的成员,就new哪个类的对象
类名 对象名 = new 类名()
c.调用成员:想使用哪个类中的成员,就用哪个类的对象去点哪个成员
对象名.成员名
java
public class Phone {
//属性
String brand;
double price;
String color;
//行为
public void call(String name){
System.out.println("给"+name+"打电话");
}
public String message(String name){
return "给"+name+"发短信";
}
}
java
public class Demo02Object {
public static void main(String[] args) {
//创建对象 类名 对象名 = new 类名()
Phone phone1 = new Phone();
phone1.brand = "华为";
phone1.price = 8888;
phone1.color = "黑色";
System.out.println(phone1.brand);
System.out.println(phone1.price);
System.out.println(phone1.color);
phone1.call("金莲");
String result = phone1.message("大郎");
System.out.println(result);
}
}3.匿名对象的使用
javaint i = 10 a.等号左边的int:数据类型 b.i:变量名 c.等号右边的:真实的数据 Person p = new Person() a.等号左边的Person:数据类型,相当于int b.p:变量名 c.等号右边的new Person():真实的数据,是一个真实的对象
java
1.匿名对象的概述:new对象的时候没有等号左边的部分,相当于对象没有名字,只有new 类名()
a.Person p = new Person() 有名的对象
b.new Person() 匿名的对象
2.注意:
a.如果只让一个方法简单执行,就可以使用匿名对象
b.但是如果涉及到赋值了,千万不要使用,因为匿名对象都是一次性的
java
public class Person {
//属性
String name;//null
int age;//0
//行为
public void eat(){
System.out.println("人要吃饭");
}
public void drink(){
System.out.println("人要喝水");
}
public void la(){
System.out.println("人要拉屎");
}
public void sa(){
System.out.println("人要撒尿");
}
}
java
public class Demo03Object {
public static void main(String[] args) {
//有名的对象
Person p = new Person();
p.name = "张三";
System.out.println(p.name);
p.eat();
System.out.println("=================");
//匿名对象
new Person().eat();
new Person().name = "李四";
System.out.println(new Person().name);//null
}
}
4.一个对象的内存图
java
public class Phone {
String brand;
int price;
public void call(){
System.out.println("打电话");
}
}
java
public class{
public static void main(String[] args) {
Phone phone = new Phone();
System.out.println(phone);//地址值
System.out.println(phone.brand);// null
System.out.println(phone.price);// 0
phone.brand = "华为";
phone.price = 8888;
System.out.println(phone.brand);// 华为
System.out.println(phone.price);// 8888
phone.call();
}
}
5.两个对象的内存图
phone1和phone2是两个不同的对象,在堆内存中开辟了两个不同的空间,操作一个空间中的数据不会影响另外一个空间中的数据
6.两个对象指向同一片空间内存图
phone2不是new出来的,而是phone1直接给的,所以此时会将phone1的地址值给phone2,此时两个对象指向了同一片空间,所以修改一个对象的数据会影响到另外一个对象
第四章.成员变量和局部变量区别
java
1.定义位置不同
a.成员变量:类中方法外
b.局部变量:在方法内,或者参数位置
2.作用范围不同:
a.成员变量:作用于整个类
b.局部变量:只作用于自己所在的方法内部
3.初始化值不同:
a.成员变量:有默认值的
b.局部变量:没有默认值,必须赋值之后才能使用
4.内存位置不同:
a.成员变量:在堆中
b.局部变量:在栈中
5.生命周期不同:
a.成员变量:随着对象的创建而创建,随着对象的消失而消失
b.局部变量:随着方法的调用而创建,随着方法调用完毕而消失 第五章.封装
java
1.面向对象编程为了:少写代码
2.面向对象有三大特征:封装 继承 多态
3.面向对象思想和封装,继承,多态的关系:
面向对象思想编程是为了少写代码,而封装,继承,多态是少写代码的具体方式1.封装的介绍以及使用
java
1.封装的概述:
将细节隐藏起来(为了不让外界直接使用),对外提供一套公共的接口(让外界通过这个公共的接口间接使用封装起来的细节),这种思想就是封装
2.封装的表现形式:
a.表现形式1:将一段代码放到一个方法中,方法体就是隐藏的细节,方法名就是对外提供的接口,我们直接调用方法名,内部的方法体就执行了,至于这个方法底层怎么写的,我们不需要考虑,我们直接调用方法名就行了
b.表现形式2:代表性关键字:private(私有权限)
3.private关键字:
a.概述:代表的是私有权限
b.作用:被private修饰的成员(成员变量,成员方法),只能在本类中使用,别的类不能调用
c.被private修饰之后,需要提供公共的接口:
get/set方法
setxxx:为属性赋值
getxxx:获取属性值
java
public class Person {
//隐藏细节
private String name;
private int age;
/**
* 为name提供公共的接口
*/
public void setName(String xingMing){
name = xingMing;
}
public String getName(){
return name;
}
/**
* 为age提供公共的接口
*/
public void setAge(int nianLing){
age = nianLing;
}
public int getAge(){
return age;
}
}
java
public class Test01 {
public static void main(String[] args) {
Person person = new Person();
//person.name = "张三";
//person.age = 18;
//System.out.println(person.name+"..."+person.age);
person.setName("张三");
person.setAge(18);
System.out.println(person.getName()+"..."+person.getAge());
}
}
一个类中如果有私有属性,get/set方法基本就是配套提供的
2.this的介绍
java
1.注意:
如果成员变量和局部变量重名,遵循"就近原则"访问,先访问局部变量
2.this:
a.概述:代表的是当前对象(哪个对象调用的this所在的方法,this就代表哪个对象)
b.作用:区分重名的成员变量和局部变量 -> this.后面的一定是成员的
java
public class Person {
String name;
public void speak(String name){
System.out.println(this+"...");
System.out.println(this.name+"您好,我是"+name);
}
}
java
public class Test01 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person+"......");
person.name = "沉香";
person.speak("刘彦昌");
System.out.println("================");
Person person2 = new Person();
System.out.println(person2+"......");
person2.name = "哪吒";
person2.speak("李靖");
}
}
java
public class Person {
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
}
java
public class Test01 {
public static void main(String[] args) {
Person p1 = new Person();
p1.setName("张三");
p1.setAge(18);
System.out.println(p1.getName()+"..."+p1.getAge());
System.out.println("=============================");
Person p2 = new Person();
p2.setName("李四");
p2.setAge(19);
System.out.println(p2.getName()+"..."+p2.getAge());
}
}
问题:属性没有被私有化的时候能不能提供get/set方法呢
其实是可以的,但是没有意义
3.构造方法_构造器
java
1.特点:
a.方法名和类名一致
b.构造方法没有返回值,连void都没有
c.我们一new就相当于调用了构造方法3.1空参构造
java
1.格式:
pubilc 类名(){
}
2.作用:
new对象,初始化对象中的属性值
3.特点:
每个类中有会默认有一个无参构造,即使不写,jvm会自动提供一个
java
public class Person {
private String name;
private int age;
/**
* 无参构造
*/
public Person(){
System.out.println("我是无参构造");
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
}
java
public class Test01 {
public static void main(String[] args) {
Person p1 = new Person();
}
}3.2有参构造
java
1.格式:
public 类名(形参){
为属性赋值
}
2.作用:
new对象的同时为属性赋值
3.特点:
如果写了有参构造,jvm将不再提供无参构造,所以建议都写上
JAVA
public class Person {
private String name;
private int age;
/**
* 无参构造
*/
public Person(){
}
/**
* 有参构造
*/
public Person(String name,int age){
this.name = name;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
}
JAVA
public class Test01 {
public static void main(String[] args) {
Person p1 = new Person();
System.out.println("===================");
//利用有参构造创建对象
Person p2 = new Person("张三", 18);
System.out.println(p2.getName()+"..."+p2.getAge());
}
}
4.标准JavaBean
JavaBean 是 Java语言编写类的一种标准规范。符合JavaBean` 的类，要求：
（1）类必须是具体的(非抽象 abstract)和公共的，public class 类名
（2）并且具有无参数的构造方法
（3）成员变量私有化，并提供用来操作成员变量的set 和get 方法。
com.atguigu.controller -> 存放和页面打交道的类
com.atguigu.service -> 存放业务类
com.atguigu.dao -> 存放和数据库打交道的类
com.atguigu.pojo/entity -> 存放的都是javabean类
com.atguigu.utils -> 存放的都是工具类
编写符合JavaBean 规范的类，以学生类为例，标准代码如下：
java
public class Student {
private int id;
private String name;
public Student() {
}
public Student(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}