第二周笔记

最新推荐文章于 2021-02-23 21:59:22 发布

方长很方

最新推荐文章于 2021-02-23 21:59:22 发布

阅读量216

点赞数

本文链接：https://blog.csdn.net/AB__C/article/details/105374757

版权

1.类和对象

类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特殊和行为特征来描述该类事物。

对象：是一类事物的具体表现。对象是类的一个实例，必然具备该类事物的属性和行为。

类是对一类事物的描述，是抽象的。
对象是一类事务的实例，是具体的。
类是对象的模板，对象是类的实体。

1.1 类

例：定义一个类，用来模拟学生。

成员变量（属性）：
String name；
intage；

成员方法（行为）：
public void eat() {}
public void sleep() {}

public class Student {
	//成员变量
	String name;
	int age;
	//成员方法
	public void showName() {
		System.out.println("我叫" + name);
	}
	public void eat(){
		System.out.println("吃饭啦！！！");
	}
	public void sleep(){
		System.out.println("睡觉啦！！！");
	}
}

注意事项：

成员变量是直接定义在类当中的，在方法外面。
成员方法不要写static关键字。

通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用

1.2 对象

引用类型的一般使用步骤：

导包： 也就是指出需要使用的类，在什么位置。
import 包名称.类名称；
对于和当前类属于同一个包的情况，可以省略导包语句不写。
只有java.lang包下的内容不需要导包，其他的包都需要import语句。
创建格式：
类名称对象名 = new 类名称()；
例：Student stu = new Student()；
使用：
使用成员变量：对象名.成员变量名
使用成员方法：对象名.成员方法名(参数)
注意事项：如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。

//导包
import week2.Student; 
public class DemoStudent {
	public static void main(String[] args) {
		//创建
		Student stu = new Student();
		//使用
		System.out.println(stu.name); //null
		System.out.println(stu.age); //0
		//改变对象当中的成员变量数值内容
		stu.name = "镜"；
		stu.age = 18;
		System.out.println(stu.name); //镜
		System.out.println(stu.age); //18
		//使用对象的成员方法
		stu.eat; //吃饭啦！！！
		stu.sleep; //睡觉啦！！！
	}
}

1.3 匿名对象

创建对象的标准格式：类名称对象名 = new 类名称();

匿名对象就是只有右边的对象，没有左边的名字和赋值运算符。
new 类名称();

public class Anonymous {
	public static void main(String[] args) {
		new Student().name = "猪猪侠";
		new Student().showname();  //我叫null
		//使用匿名对象进行传参
		methodParam(new Scanner(System.in));
		//返回值为参数
		Scanner sc = methodReturn();
		int num = sc.nextInt();
		System.out.println("输入的是：" + num);
	}
	public static void methodParam(Scanner sc) {
		int num = sc.nextInt();
		System.out.println("输入的是：" + num);
	}
	public static Scanner methodReturn() {
		return new Scanner(System.in);
	}
}

匿名对象只能使用唯一的一次，下次再是使用就需要再创建一个新对象。

1.4 局部变量和成员变量

定义位置不一样
局部变量：在方法的内部
成员变量：在方法的外部，直接写在类当中
作用范围不一样
局部变量：只有方法当中才能用，出了方法就不能用
成员变量：整个类都可以使用
默认值不一样
局部变量：没有默认值，如要使用，需要赋值
成员变量：如果没有赋值，会有默认值，规则和数组一样
内存位置不一样
局部变量：位于栈内存
成员变量：位于堆内存
生命周期不一样
局部变量：随着方法进栈产生，出栈消失
成员变量：随着对象创建产生，对象被垃圾回收消失

1.5 面向对象三大特征之封装性

封装就是将一些细节信息隐藏起来，对于外界不可见

封装性在Java当中的体现：

方法就是一种封装
关键字private也是一种封装

1.6 private

一旦使用了private进行修饰，那么本类当中仍然可以随意访问，但是超出了本类范围之外就不能再直接访问了。
间接访问private成员变量，就是定义一对Getter/Setter方法。
必须叫setXxx，getXxx命名规则。对于boolean值，Getter方法一定要写成isXxx的形式，而setXxx规则不变。
对于Getter，不能有参数，返回值类型和成员变量对应。
对于Setter，不能有返回值，参数类型和成员变量对应。

//要求：age的值不能小于零
public class Person {
	String name;
	private int age;

	public void show() {
		System.out.println("你是" + name + ",年龄：" + age);
	}
	//用于向age传递数据
	public void setAge(int num) {
		if(num >= 0)
			age = num;
		else
			System.out.println("数据不合理");
	}
	//用于获取age的数据
	public int getAge() {
		return age;
	}
}

public class DemoPerson {
	public static void main(String[] args) {
		Person person = new Person();
		person.name = "pig";
		//person.age = 5;       //直接访问private内容，错误写法
		person.setAge(5); 		//间接访问，正确写法
		person.show();
	}
}

1.7 this

当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量。
如果需要访问本类当中的成员变量，需要使用格式：this.成员变量名
即通过谁调用的方法，谁就是this

public class Person {
	String name;
	//参数name是对方的名字，成员变量name是自己的名字
	public void sayHello(String name) {
		System.out.println(name + ",你好，我是" + this.name);
	}
}

public class DemoPerson {
	public static void main(String[] args) {
		Person person = new Person();
		person.name = "猪猪侠";
		person.sayHello("小菲菲");
	}
}

1.8 构造方法

构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。

注意事项：

构造方法的名称必须和所在类名称完全一样。
构造方法不要写返回值类型，void也不要写。
构造方法不能return一个具体的返回值
如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数，方法体，什么事情都不做。
一旦编写了构造方法，那么编译器将不会再赠送。
构造方法也是可以重载的。

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;
	}
	public void setName(String name){
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int setAge() {
		return age;
	}
}

public class DemoStudent {
	public static void main(String[] args) {
		Student stu1 = new Student();
		Student stu2 = new Student("猪猪侠"， 8);
		System.out.println("姓名：" + stu2.getName() + ",年龄：" + stu2.getAge());
	}
}

1.9 定义一个标准的类

一个标准的类通常拥有下面四个部分：

所有的变量名称都要使用 private 关键字修饰。
为每一个变量编写一对Getter / Setter方法。
编写一个无参数的构造方法。
编写一个全参数的构造方法。

这样标准的类也叫Java Bean

其中2 3 4 Alt + Insert可自动生成

public class Student {
	private String name;
	private int age;
	
	//Alt+Insert 自动生成下面
	public student() {
    }
    public student(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;
    }
}

2. API

API（Application Programming Interface，应用程序接口）。Java API是一本程序员的字典，是JDK中提供给我们使用的类的说明文档。这些类将底层的代码封装了起来，我们需要学习如何使用。

2.1 Scanner

功能： 可以实现键盘输入数据，到程序当中

public class DemoScanner {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		printf(a);
	}
}

2.2 Random

Random类用来生成随机数字。使用起来也是三个步骤：

导包
import java.util.Random;
创建
Random r = new Random();
使用
获得一个随机的int数字, int num = r.nextInt();
获取一个随机的有范围的数：int num = r.nextInt(3); 范围0~2

import java.util.Random;
public class Random {
	public static void main(String[] args) {
		Random r = new Random();
		int num = r.nextInt();
		System.out.println("随机数是" + num);
	}
}

3. ArrayList集合

3.1 ArrayList集合概述和基本使用

数组的长度不可以发生改变，但是ArrayList来说，有一个尖括号 < E > 代表泛型。

泛型： 也就是装在集合当中的所有元素，全部是统一的类型。

注意：

泛型只能是引用类型，不能是基本类型。
对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。
如果内容是空，得到的是空的中括号。

public class ArrayList {
	public static void main(String[] args){
		ArrayList<String> list = new ArrayList<>();
		System.out.println(list);  //[]
		//相机和当中添加数据需要用到add方法
		list.add("猪猪侠");
		System.out.println("list");  //猪猪侠
		list.add("小菲菲");
		System.out.println("list");  //猪猪侠,小菲菲
	}
}

3.2 ArrayList集合的常用方法和遍历

public boolean add(E e)； 向集合当中添加元素，参数的类型和泛型一样，返回值代表是否成功。

public E get(int index)； 向集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。

public E remove(int index); 从集合当中删除元素，参数是索引编号，返回值就是被删除的元素。

public int size(); 获取集合的尺寸长度，返回值是集合中包含的元素个数。

import java.util.ArrayList;
public class ArrayListMethod {
	public static voiid main(String[] args){
		ArrayList<String> list = new ArrayList<>();
		//向集合中添加元素
		boolean miao = list.add("猪猪侠");
		System.out.println(list); //猪猪侠
		System.out.println(miao);  //true
		//从集合中获取元素
		String name = list.get(0);
		System.out.println(name); //猪猪侠
		//从集合中删除元素
		String whoRemoved = list.remove(0);
		System.out.println(whoRemoved); //猪猪侠
		System.out.println(list); //[]
		//获取集合的尺寸长度
		int size = list.size();
		System.out.println(list);
	}
}

import java.util.ArrayList;
public class ArrayListEach {
	public static voiid main(String[] args){
		ArrayList<String> list = new ArrayList<>();
		list.add("猪猪侠");
		list.add("小菲菲");
		for(int i = 0; i < list.size(); i ++)
			System.out.println(list.get(i));
	}
}

3.3 ArrayList集合储存基本数据类型

泛型只能是引用类型，不能是基本类型。如果希望集合ArrayList当中存储基本类型数据，必须使用基本类型数据对应的“包装类”。

基本类型	包装类（都位于java.lang包下）
byte	Byte
short	Short
int	Integer(特殊)
long	Long
float	Float
double	Double
char	Character(特殊)
boolean	Boolean

import java.util.ArrayList;
public class ArrayListBastic {
	public static voiid main(String[] args){
		//ArrayList<int> list = new ArrayList<>(); //错误写法
		ArrayList<Integer> list = new ArrayList<>();
		list.add(100);
		list.add(200);
		System.out.println(list.get(1)); //200
	}
}

4. 字符串

Java程序中的所有字符串字面值都作为此类的实例实现。也就是说，程序当中所有的双引号字符串，都是String类的对象，就算没有new。

特点：

字符串的内容永不可变。
正是因为字符串的内容永不可变，所以字符串是可以共享使用的。
字符串效果上相当于char[ ]字符数组，但是底层原理是byte[ ]字节数组。

4.1 字符串的构造方法和直接创建

创建的3 + 1种方法

三种构造方法：

public String(); 创建一个空白字符串，不含有任何内容
public String(char[] array); 根据字符数组的内容，来创建对应的字符串
public String(byte[] array); 根据字符数组的内容，来创建对应的字符串

一种直接创建：

String str = “Hello”;

public class String {
	public static void main(String[] args) {
		//使用空参创建
		String str1 = new String();
		System.out.println(str1);   // 
		//根据字符数组创建
		char[] charArray = {'a', 'b', 'c'};
		String str2 = new String(charArray);
		System.out.println(str2);  //abc
		//根据字节数组创建
		byte[] byteArray = {97, 98, 99};
		String str3 = new String(charArray);
		System.out.println(str3);   //abc
		//直接创建
		String str = "Hello";
		System.out.println(str);    //Hello
	}
}

4.2 字符串的常量池

对于引用类型， == 进行的是地址值的比较。
程序当中直接写上的双引号字符串，都在字符串常量池(包含在堆中)，new的不在池中。

public class String {
	public static void main(String[] args) {
		String str1 = "abc";
		String str2 = "abc";
		char[] charArray = {'a', 'b', 'c'};
		String str3 = new String(charArray);

		System.out.println(str1 == str2);  //true,故str1，str2同地址
		System.out.println(str1 == str3);  //flase
		System.out.println(str2 == str3);  //flase
}

4.3 字符串的比较相关方法

public boolean equals(Object obj); 参数可以是任何对象，只有参数是一个字符串并且内容相同(严格区分大小写)才会给true，否则都会返回flase。

public boolean equalsIgnoreCase(String str); 忽略大小写进行内容比较

注意事项：

任何对象都能用Object进行接收。
equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。
如果比较双方一个常量一个变量，推荐把常量字符串写在前面。

public class StringEquals {
	public static void main(String[] args) {
		String str1 = "abc";
		String str2 = "abc";
		char[] charArray = {'a', 'b', 'c'};
		String str3 = new String(charArray);

		System.out.println(str1.equals(str2));  //true
		System.out.println(str2.equals(str3));  //true
		System.out.println(str3.equals("abc"));  //true
		System.out.println(abc.equals("str1"));  //true
		System.out.println(abc.equalsIgnoreCase("ABC")); //true
}

4.4 字符串的获取相关方法

String当中与获取相关的常用方法有：

public int length(); 获取字符串当中含有的字符个数，拿到字符串长度。
public String concat(String str); 将当前字符串和参数字符串拼接成为返回值新的字符串。
public char charAt(int index); 获取指定索引位置的单个字符。
public int indexOf(String str); 查询参数字符串在本字符串当中首次出现的索引位置，如果没有则返回-1。

public class StringGain {
	public static void main(String[] args) {
		//获取长度
		int length = "abcdefg".length();
		System.out.println(length); //7
		//拼接
		String str1 = "Hello";
		String str2 = "World";
		String str3 = str1.concat(str2);
		System.out.println(str3); //HelloWorld
		//获取指定索引位置的单个字符
		char ch = "Hello".charAt(1);
		System.out.println(ch); // e
		//查询首次出现的索引位置
		String str4 = "HelloHello";
		int index = str4.indexOf("llo");
		System.out.println(index); // 2
    }
}

4.5 字符串的截取方法

public String substring(int index); 截取从参数位置一直到字符串末尾，返回新字符串。
public String substring(int begin, int end); 截取从begin开始一直到end结束中间的字符串。（包含begin，不包含end）

public class StringCut {
	public static void main(String[] args) {
		String str1 = "HelloWorld";
		String str2 = str1.substring(5);
		System.out.println(str1); //HelloWorld
		System.out.println(str2); //World
		String str3 = str1.substring(4, 7);
		System.out.println(str3); //oWo
}

4.6 字符串的转换相关方法

public char[] toCharArray(); 将当前字符串拆分成为字符数组作为返回值
public byte[] getBytes(); 获得当前字符串底层的字节数组
public String replace(CharSequence oldString, CharSequence newString); 将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串

public class StringConvert {
	public static void main(String[] args) {
		//转换成为字符数组
		char[] ch = "Hello".toCharArray();
		System.out.println(ch[0]); // H 
		//转换成为字节数组
		byte[] by = "abc".getBytes();
		for(int i = 0; i < by.length; i ++）
			System.out.print(str1 + " "); //97 98 99
		//内容转换
		String str1 = "abca";
		String str2 = str1.replace("a", "*");
		System.out.println(str1); // abca
		System.out.println(str2); // *bc*
}

4.7 字符串的分割

public String[] split(String regex); 按照参数的规则，将字符串切成若干部分。

注意事项： split方法的参数是一个“正则表达式”，如果按照 “.” 进行切分，必须写成 “\\.”

public class StringSplit {
	public static void main(String[] args){
		String str1 = "aaa,bbb,ccc";
		String[] array1 = str1.split(",");
		for(int i = 0; i < array1.length; i ++){
			System.out.println(array1[i]);
			//aaa
			//bbb
			//ccc
		}
		String str2 = "aaa.bbb.ccc";
		//String[] array2 = str2.split("."); //错误
		String[] array2 = str2.split("\\.");
		for(int i = 0; i < array2.length; i ++){
			System.out.println(array2[i]);
			//aaa
			//bbb
			//ccc
		}
	}
}

方长很方

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第二周笔记

1.类和对象类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特殊和行为特征来描述该类事物。对象：是一类事物的具体表现。对象是类的一个实例，必然具备该类事物的属性和行为。类是对一类事物的描述，是抽象的。对象是一类事务的实例，是具体的。类是对象的模板，对象是类的实体。1.1 类例：定义一个类，用来模拟学生。成员变量（属性）：String name；in...
复制链接

扫一扫