从零开始学JAVA-笔记汇总(三)
自学资源来自B站：2020-java-入门到大神-慢慢来，别急
前篇文章：从零开始学JAVA-笔记汇总(二)
后篇文章：从零开始学JAVA-笔记汇总(四)
同期文章：从零开始学JAVA-作业习题(三)
目录
- 一、面向对象基础
- 1.1 类和对象
- 1.1.1 什么是对象/类
- 1.1.2 对象的属性/行为
- 1.1.3 类和对象的关系
- 1.1.4 类的定义
- 1.1.5 对象的使用
- 1.2 对象内存图
- 1.3 成员变量和局部变量
- 1.3.1 什么是成员变量和局部变量
- 1.3.2 成员变量和局部变量的区别
- 1.4 封装
- 1.4.1 private关键字
- 1.4.2 this关键字
- 1.4.3 封装
- 1.5 构造方法
- 1.5.1 构造方法概述
- 1.5.2 构造方法注意事项
- 1.5.3 标准类的制作
- 1.6 字符串
- 1.6.1 API
- 1.6.2 String
- 1.6.2.1 String构造方法
- 1.6.2.2 对象的特点
- 1.6.2.3 字符串的比较
- 1.6.3 StringBuilder
- 1.6.3.1 StringBuilder的构造方法
- 1.6.3.2 StringBuilder的添加和反转方法
- 1.6.3.4 StringBuilder和String相互转换
- 1.7 集合基础
- 1.7.1 ArrayList构造方法和添加方法
|Day15-20200528|
新章节，继续笔记~
一、面向对象基础
1.1 类和对象
1.1.1 什么是对象/类
对象：万物皆对象,客观存在的事物。
类：具有共同属性和共同行为的事物的抽象，他不存在于客观世界中。
1.1.2 对象的属性/行为
对象的属性
对象的行为
1.1.3 类和对象的关系
1.1.4 类的定义
类的定义步骤
- 代码示范
package com.lilin_07;
/*
类的定义
类的定义步骤：
定义类
编写类的成员变量
编写类的成员方法
手机类：
类名：
手机（Phone）
成员变量：
品牌（brand）
价格（price）
成员方法：
打电话（call）
发短信（sendMessage）
*/
public class Phone {
//成员变量
String brand;
int price;
//成员方法
public void call(){
System.out.println("打电话");
}
public void sendMessage(){
System.out.println("发短信");
}
}
1.1.5 对象的使用
- 首先创建对象，之后才能够使用对象
- 代码示范
package com.lilin_07;
/*
创建对象
格式：类名 对象名 = new 类名();
范例：Phome p = new Phone();
使用对象
1：使用成员变量
格式：对象名.变量名
范例：p.brand
2：使用成员方法
格式：对象名.方法名();
范例：p.call();
*/
public class PhoneDemo {
public static void main(String[] args) {
//创建对象
Phone p = new Phone();//new出来的东西是在堆内存中的，堆内存中的成员是有默认值的
//使用成员变量
System.out.println(p.brand);//String类型的默认值为null
System.out.println(p.price);//int类型的默认值为0
//为成员变量赋值
p.brand="小米";
p.price=1223;
System.out.println(p.brand);
System.out.println(p.price);
//使用成员方法
p.call();
p.sendMessage();
}
}
| Day16-20200529 |
休息
| Day17-20200530 |
休息
| Day18-20200531 |
休息
| Day19-20200601 |
1.2 对象内存图
- 栈内存：类的方法在栈内存中（局部变量），调用完方法会做出栈动作
- 堆内存：new出来的对象的内存空间以及其对象属性都在堆内存中
- 方法是可以被多个对象共用，但是每个成员变量的值是不同的。
1.3 成员变量和局部变量
1.3.1 什么是成员变量和局部变量
- 成员变量：类中方法外的变量
- 局部变量：方法重的变量
1.3.2 成员变量和局部变量的区别
1.4 封装
1.4.1 private关键字
- 代码示范
Student(private关键字)
package com.lilin_08;
public class Student {
String name;
//int age; //这种方式不安全，因此要使用private来修饰，此时只能在本类中使用
private int age;//大概用private方法修饰成员变量后，需要提供对应的方法来让其他类访问。
//提供get()/set()方法来让其他类访问成员变量
//set()方法是用来为age赋值的，无需返回值，因此使用viod来修饰方法。
public void setAge(int a){
//age=a;
// 为了使该方法更加健壮，需要对age进行限定
if(a<0||a>200){
System.out.println("年龄非法");
}else{
age = a;
}
}
//get()方法是用来获取age值的，需要有返回值，因此使用int来修饰方法。
public int getAge(){
return age;
}
public void show(){
System.out.println(name+","+age);
}
}
StudentDemo(private关键字)
package com.lilin_08;
public class StudentDemo {
public static void main(String[] args) {
Student st=new Student();
st.name="哈哈";
//st.age=11;//这里如果设置为负数，程序也能正常执行，但是显然逻辑上是错误的
//因此：这种直接访问类中成员变量的方式是不安全的，不健壮的，因此需要使用private关键字来修饰成员变量。
//当student类中的age使用private修饰后，这里的直接使用st.age来访问成员变量。需要用到get()set()方法来访问成员变量。
st.setAge(30);
System.out.println(st.getAge());
st.show();
}
}
1.4.2 this关键字
- 代码示范
Student(this关键字)
package com.lilin_08;
import sun.net.idn.Punycode;
public class Student {
private String name;
private int age;
//---------------set get START-------------
/* public void setName(String n){
name=n;
}
最好见名知意，因此public void setName(String n)
最好改为public void setName(String name)
*/
public void setName(String name){
//name=name;
/*此时，调用show()方法，StudentDemo方法中返回的结果为【null,10】，为什么呢？
因为当方法形参与成员变量不同名时，方法中的name指的是成员变量
而当方法形参与成员变量同名时，方法中的name指的就是方法的局部变量，如果想表示成员变量则需要在name前面加this关键字，用以区分跟形参的区别
name=null
所以StudentDemo方法中返回的结果是【null,10】*/
this.name=name;//这里this的意思是，成员变量.name，因此StudentDemo方法中show()方法返回的结果为【李霖,10】
}
public String getName(){
return name;
}
/* public void setAge(int a){
age=a;
}*/
//同理，这里也使用this关键字
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
//---------------set get END-------------
public void show(){
System.out.println(name+","+age);
}
}
StudentDemo(this关键字)
package com.lilin_08;
public class StudentDemo {
public static void main(String[] args) {
Student st=new Student();
st.setName("李霖");
st.setAge(10);
st.show();
}
}
1.4.3 封装
- 封装概述：
- 封装原则：
- 封装的好处：
1.5 构造方法
1.5.1 构造方法概述
- 构造方法是一种特殊的方法
- 作用：创建对象
- 功能：主要完成对象数据的初始化
- 代码示范
Student(构造方法)
package com.lilin_08;
import sun.java2d.pipe.SpanIterator;
public class Student {
private String name;
private int age;
//构造方法(无参)
public Student(){
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;
}
//---------------set get END-------------
public void show(){
System.out.println(name+","+age);
}
}
StudentDemo(构造方法)
package com.lilin_08;
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s = new Student();
s.show();//返回值为【null,0】
}
}
1.5.2 构造方法注意事项
-
构造方法的创建
-
构造方法的重载
-
推荐的使用方式
1.5.3 标准类的制作
- 代码示范
Student(标准类的制作)
package com.lilin_08;
public class Student {
private String name;
private int age;
//构造方法(无参)
public Student(){
System.out.println("无参构造方法");
}
//构造方法（带参数）
public Student(String name,int age){
System.out.println("带参构造方法");
this.name=name;
this.age=age;
}
//---------------set get START-------------
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;
}
//---------------set get END-------------
public void show(){
System.out.println(name+","+age);
}
}
StudentDemo(标准类的制作)
package com.lilin_08;
public class StudentDemo {
public static void main(String[] args) {
Student s1=new Student();
//无参构造方法创建对象后使用setXxx()赋值
s1.setName("哈哈");
s1.setAge(10);
s1.show();
//使用带参数构造方法直接创建带有属性值的对象
Student s2= new Student("李霖",10);
s2.show();
}
}
| Day20-20200602 |
1.6 字符串
1.6.1 API
API(Application Programming Interface)：应用程序编程接口
Java8 帮助文档-API中文版在线：Java8帮助文档
Java11 帮助文档-API中文版在线：Java11帮助文档
使用步骤：
- 在文档页面找到【索引】选项
- 在【索引】输入框中输入Random（public class Random）
- 看类在哪个包下（Random在java.util包下）
- 查看类的描述信息
- 查看构造方法
- 查看成员方法（继第五步【查看构造方法】往下浏览，即为成员方法部分）
1.6.2 String
-
String概述
-
字符串的特点
1.6.2.1 String构造方法
- 常用的String构造方法
- 代码示范
推荐使用直接赋值的方法得到字符串
package com.lilin_09;
import java.sql.SQLOutput;
/*
String构造方法：
public String(); ：创建一个空白字符串对象，不含有任何内容
public String(char[] chs); ：根据字符数组的内容，来创建字符串对象
public String(byte[] bys); ：根据字节数组的内容，来创建字符串对象
String s = "abc"; ：直接赋值的方式创建字符串对象，内容就是abc
最后还是推荐使用直接赋值（String s = "abc";）的方法得到字符串对象。
*/
public class StringDemo {
public static void main(String[] args) {
//public String(); ：创建一个空白字符串对象，不含有任何内容
String s1 = new String();
System.out.println("s1："+s1);
/*
public String(char[] chs); ：根据字符数组的内容，来创建字符串对象
如何调用 public String(char[] chs)这个方法呢？
思路：
把public String(char[] chs)看作普通的一个方法，如
public Student(String name,int age);
使用构造方法时：
String： String str = new String(ch); //推荐提前定义数组ch
Student： Student std = new Student(name,age) //推荐提前定义变量name.age
*/
char[] ch = {'a','b','c'};
String s2 = new String(ch);
System.out.println("s2："+s2);
//public String(byte[] bys); ：根据字节数组的内容，来创建字符串对象
byte[] by = {97,98,99};//这里97 98 99 被转换成String类型，对应的ASCII码分别是abc
String s3 = new String(by);
System.out.println("s3："+s3);
//String s = "abc"; ：直接赋值的方式创建字符串对象，内容就是abc
String s4 = "abc";
System.out.println("s4："+s4);
}
}
1.6.2.2 对象的特点
- 通过new创建的字符串对象：
- 通过直接赋值的方法创建的字符串对象：
1.6.2.3 字符串的比较
- 代码示范：
package com.lilin_09;
public class StringEquals {
public static void main(String[] args) {
//构造方法的方式得到对象
char[] chs= {'a','b','c'};
String s1 = new String(chs);
String s2 = new String(chs);
//直接赋值的方式得到对象
String s3 = "abc";
String s4 = "abc";
//比较字符串对象地址是否相同
System.out.println("比较字符串对象地址是否相同");
System.out.println(s1 == s2);
System.out.println(s1 == s3);
System.out.println(s3 == s4);
System.out.println("------------");
//比较字符串内容是否相同
System.out.println("比较字符串对象地址是否相同");
System.out.println(s1.equals(s2));
System.out.println(s1.equals(s3));
System.out.println(s3.equals(s4));
}
}
| Day21-20200603 |
今日全是习题，无笔记~
| Day22-20200604 |
1.6.3 StringBuilder
-
使用【String s=s+"";】对字符串进行拼接
图中
1：将hello写入堆内存中的常量池
2：s+="world"相当于 s=s+“world”，因此将world加入常量池，
3：s=s+"world"拼接后的helloworld也加入常量池,
结果：最终sout输出的s只用到了常量池中的内存空间为003的常量helloworld，其余了001、002内存空间中的hello、world被浪费掉了。
-
StringBuilder是一个可变的字符串类，我们可以把它看作是一个容器
这里的可变指的是StringBuilder对象中的内容是可变的
它在做拼接的时候，是不会创建新的对象的 -
String和StringBuilder的区别
- String：内容不可变
- StringBuilder：内容可变
1.6.3.1 StringBuilder的构造方法
- 代码示范
package com.lilin_11;
/*
StringBuilder构造方法：
public StringBuilder();创建一个空白的可变字符串对象，不含有任何内容
public StringBuilder(String str);根据字符串内容，来创建可变字符串对象
*/
public class StringBuilderTest {
public static void main(String[] args) {
//public StringBuilder();创建一个空白的可变字符串对象，不含有任何内容
StringBuilder sb = new StringBuilder();
System.out.println("sb:"+sb);
System.out.println("sb:"+sb.length());
//public StringBuilder(String str);根据字符串内容，来创建可变字符串对象
StringBuilder sb1 =new StringBuilder("asd");
System.out.println("sb1:"+sb1);
System.out.println("sb1:"+sb1.length());
}
}
| Day23-20200605 |
公司搬家
| Day24-20200606 |
公司搬家
| Day25-20200607 |
公司搬家
| Day26-20200608 |
1.6.3.2 StringBuilder的添加和反转方法
- 代码示范
package com;
/*
StringBuilder的添加和反转方法
public StringBuilder append(任意类型)：添加数据，并返回对象本身
public StringBuilder reverse()：返回相反的字符序列
*/
public class StringBuilderDemo01 {
public static void main(String[] args) {
//创建对象
StringBuilder sb = new StringBuilder();
//public StringBuilder append(任意类型)：添加数据，并返回对象本身
/*
StringBuilder sb2 = sb.append("hello");
//均返回 hello
System.out.println(sb);
System.out.println(sb2);
//返回true，由此可见sb与sb2指向的是同意内存空间。因此不需要讲sb.append的值再传给sb2
System.out.println(sb == sb2);
*/
/*
由于public StringBuilder append(任意类型);返回的是对象本身，因此可以调用方法，使用链式编程可以更简洁
sb.append("hello");//可以是任何数据类型
sb.append("world");
sb.append(100);
*/
//链式编程
sb.append("hello").append("world").append(100);
/*
可以这么想：
想要调用append(100)这个方法，需要由对象sb.append("hello").append("world")来调用、
此时append("world")这个方法，需要由对象sb.append("hello")来调用、
此时append("hello")这个方法，需要由对象 sb 来调用。
然后由于sb是一个对象，sb调用方法append("hello")之后、
sb.append("hello")返回得是对象本身，该对象调用方法append("world")之后、
sb.append("hello").append("world")返回得是对象本身，该对象调用方法append(100)之后、
sb.append("hello").append("world").append(100)返回得事对象本身，也就是helloworld100
从而完成链式编程
*/
System.out.println(sb);//返回：helloworld100
System.out.println("------反转之后的sb值为------");
//public StringBuilder reverse()：返回相反的字符序列
sb.reverse();
System.out.println(sb);//返回：001dlrowolleh
}
}
1.6.3.4 StringBuilder和String相互转换
- 为什么要学习他们的相互转换？
- 因为在StringBuilder中有两个非常好用的方法：append、reverse，而String是无法直接使用这两个方法的，因此需要将String转换为StringBuilder，最后再将StringBuilder转回String。
-
StringBuilder转换为String
public String toStringString()：通过toString()就可以实现把StringBuilder转换为String -
String转换为StringBuilder
public StringBuilder(String s)：通过构造方法就可以实现把String转换为StringBuilder
- 代码示范
package com.lilin_12;
/*
StringBuilder 转换为String
public String toString()：通过toString()就可以实现吧StringBuilder转换为String
String转换为StringBuilder
public StringBuilder(String s)：通过构造方法就可以实现把String转换为StringBuilder
*/
public class StringBuilderDemo02 {
public static void main(String[] args) {
//public String toString()：通过toString()就可以实现吧StringBuilder转换为String
StringBuilder sb = new StringBuilder();
sb.append("hello");
String s = sb.toString();
System.out.println(s);
//public StringBuilder(String s)：通过构造方法就可以实现把String转换为StringBuilder
String s1 = "haha";
StringBuilder sb2 = new StringBuilder(s1);
System.out.println(sb2);
}
}
1.7 集合基础
集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以发送改变。
集合类有很多，目前先学习：ArrayList
其中是一种特殊的数据类型：泛型。这个位置应写集合中存储的数组的元素的数据类型
| Day27-20200609 |
1.7.1 ArrayList构造方法和添加方法
- 代码示范
| Day28-20200610 |
我从事数据库相关行业，突然发现我的学习周期有点偏长。
决定从培训视频中，提取DBA需要了解的技术进行学习。
新博客地址：DBA需要了解的Java相关技术笔记
书签：视频P135
前篇文章：从零开始学JAVA-笔记汇总(二)
后篇文章：从零开始学JAVA-笔记汇总(四)
同期文章：从零开始学JAVA-作业习题(三)
自学资源来自B站：2020-java-入门到大神-慢慢来，别急