面向对象基础
面向对象和面向过程的思想对比
- 面向过程编程(Procedure Oriented Programming)
是一种以过程为中心的编程思想,实现功能的每一步,都是自己实现的 - 面向对象编程(Object Oriented Programming)
是一种以对象为中心的编程思想,通过指挥对象实现具体的功能
类和对象
类是对象的描述
对象是 类的实体
类的定义
类的组成:属性和行为
- 属性:在代码中通过成员变量来体现(类中方法外的变量)
- 行为:在代码中通过成员方法来体现(和前面的方法相比去掉static关键字即可)
public class 类名{
//成员变量
变量1的数据类型 变量1;
…
//成员方法
方法1;
…
}
public calss Student{
String name;
int age;
public void study(){
System.out.println(“学习”);
}
}
对象的使用
- 创建对象
格式:类名 对象名 = new 类名();
Student s = new Student(); - 使用对象
- 使用成员变量
格式:对象名。变量名
s.name - 使用成员方法
格式:对象名.方法名()
s.study();
案例
定义一个手机类,然后定义一个手机测试类,在手机测试类中通过对象完成成员变量和成员方法的使用
public class phone{
String brand;
int price;
public void call(String name){
System.out.println("给"+name+"打电话");
}
public void sendMessage(){
System.out.println("群发短信");
}
}
public class TestPhone{
public static void main(String[] args){
Phone p = new Phone();
p.brand = "米";
p.price = 1999;
System.out.println(p.brand +"..."+p.price);
p.call("森");
p.sendMessage();
}
}
对象内存图
单个对象内存图
两个对象内存图
.class字节码文件不用再加载一次
两个引用指向同一对象内存图
垃圾回收
当堆内存中,对象或数组产生的地址,通过任何方式都不能被找到后,就会被判定为内存中的“垃圾”。
垃圾会被java垃圾回收器,空闲的时候自动进行清理
成员变量和局部变量
成员变量:类中方法外的变量
局部变量:方法中的变量
封装
private关键字
权限修饰符,可以用来修饰成员(变量、方法)
特点:只能在本类当中进行访问
public class Student{
String name;
private int age;
//设置值
pulic void setAge(int a){
if(a>=0 && a<=120){
age = a;
}else{
System.out.println("您的年龄不合理");
}
}
//获取值
pulic int getAge(){
return age;
}
public void show(){
System.out.println(name+"..."+age);
}
}
public class TestStudent{
public static void main(String[] args){
Student stu = new Student();
stu,name = "张三";
stu.setAge(-23);
stu.show();
}
}
this关键字
局部变量和成员变量如果重名,Java使用的是就近原则
public class Student{
private int age = 18;
pulic void method(){
int age = 19;
System.out.prinltn(age);
}
}
控制台:19
public class Student{
private int age = 18;
pulic void method(){
int age = 19;
System.out.prinltn(this.age);
}
}
控制台:18
public class Student{
private int age ;
pulic int getAge(){
return age ; //默认为 return this.age;
}
}
this关键字作用:可以调用本类的成员(变量、方法),解决局部变量和成员变量的重名问题
this:代表所在类的对象引用,方法被哪个对象调用,this就代表哪个对象
this内存原理
封装
- 面向对象三大特征(封装、继承、多态)
- 隐藏实现细节,仅对外暴露公共的访问方式
私有仅仅是封装的一种体现 - 封装常见的体现:
- 将代码抽取到方法中,这是对代码的一种封装
- 将属性抽取到类当中,这是对数据的一种封装
- 私有成员变量,提供setXxx和getXxx方法
- 封装的好处:
提高了代码的安全性
提高了代码的复用性
构造方法
构建、创造对象的时候,所调用的方法
格式:
- 方法名与类名相同,大小写也要一致
- 没有返回值类型,连void都没有
- 没有具体返回值(不能由return带回结果数据)
执行时机:
创建对象的时候调用,每创建一次对象,就会执行一次构造方法
不能手动调用构造方法
作用:
用于给对象的数据(属性)进行初始化
所有Student对象的age,都是18
class Student{
private int age;
public Student(){
age = 18;
}
}
class Student{
private int age;
public Student(int age){
this.age = age;
}
}
Student s1 = new Student(23);
Student s2 = new Student(24);
注意事项
构造方法的创建:
如果没有定义构造方法,系统将给出一个默认的无参数构造方法
如果定义了构造方法,系统将不再提供默认的构造方法
构造方法的重载:
如果自定义了带参构造方法,还要使用无参数构造方法,就必须再写一个无参数构造方法
无论是否使用,都手动书写无参数构造方法和带参数构造方法
/*
JavaBean类:封装数据
*/
public class Student{
private String name;
private int age;
//无参数构造
public Student(){}
//有参数构造
public Student(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(String age){
this.age = age;
}
public intgetAge(){
return age;
}
public void show(){
System.out.println(name+"..."+age);
}
}
public class TestStudent{
public static void main(String[] args){
//无参数构造方法创建对象,通过setXxx方法给成员变量进行赋值
Student stu1 = new Student();
stu1.setName("张三");
stu1.setAge(23);
stu1.show();
//通过带参数构造方法,直接给属性进行赋值
Student stu2 = new Student("李四", 24);
stu2.show();
}
}
字符串
API
应用程序编程接口(Application Programming Interface)
键盘输入一个字符串
import java.util.Scanner;
public class Demo1Scanner{
/*
next() : 遇到了空格,就不再录入数据了
结束标记:空格、tab键
nextLine() :可以将数据完整的接收过来
结束标记:回车换行符
nextInt和nextLine方法配合使用的时候,nextLine方法就没有键盘录入的机会了
字符串和整数一起录入,建议使用next方法
*/
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入:");
//ctrl + alt + v 快速生成方法的返回值
String s = sc.nextLine();
System.out.println(s);
}
}
String
String类在java.lang包下,所以使用时不用导包
String类代表字符串,java程序中所有字符串文字(如"abc")都被实现为此类的实例,也就是说,java程序中所有的双引号字符串,都是String类的对象
字符串不可变,他们的值在创建后不能被更改
重新赋值只是让这个字符串变量记录了一个新的对象
String常见构造方法
注意String这个类比较特殊,打印其对象名的时候。不会出现内存地址,而是该对象所记录的真实内容 ( 面向对象-继承,Object类)
创建字符串对象的区别对比
构造方法能创建对象,双引号也能创建字符串对象,有什么区别
注意 ==号作比较
- 基本数据类型:比较的是具体的值
int a = 10;
int b = 20;
System.out.println(a == b); //false - 引用数据类型:比较地址值
Student s1 = new Student(23);
Student s2 = s1;
System.out.println(s1 == s2); //true
以""方式给出的字符串,只要字符序列相同(顺序和大小写),无论在程序代码中出现几次,JVM都只会建立一个String对象,并在字符串常量池中维护
String s1 = “abc”;
String s2 = “abc”;
- 字符串常量池:当使用双引号创建字符串对象的时候,系统会检查该字符串是否在字符串常量池中存在
不存在:创建
存在:不会重新创建,而是直接复用
字符串常量池在JDK7版本开始从方法区挪到了堆内存
通过new创建的字符串对象,每一次new都会申请一个内存空间,虽然内容相同,但是地址值不同
char[] chs = {‘a’, ‘b’, ‘c’};
String s1 = new String(chs);
String s2 = new String(chs);
上面的代码中,JVM会首先创建一个字符数组,然后每一次new的时候都会有一个新的地址
双引号创建的字符串对象,在字符串常量池中存储,通过构造方法创建的字符串对象,在堆内存中存储
String字符串的特点
- java程序中所有的双引号字符串,都是String类的对象
- 字符串不可变,它们的值在创建后不能被更改
- 虽然String的值是不可变的,但是它们可以被共享(字符串常量池)
当字符串之间使用+号串联(拼接)的时候,系统底层会自动创建一个StringBuilder对象,然后再调用其append方法完成拼接,拼接后,再调用其toString方法转换为String类型
Java存在常量优化机制,在编译的时候,就会将"a" + “b” + “c"拼接为"abc”
字符串的比较
使用==做比较
- 基本数据类型:比较的是具体的值
- 引用数据类型:比较地址值
字符串是对象,比较内容是否相同,通过equals()方法实现
- public boolean equals(Object anObject):将此字符串与指定对象进行比较。由于我们比较的是字符串对象,所以参数直接传递一个字符串
equalsIgnoreCase() 忽略大小写比较
案例
- 用户登录
已知用户名和密码是,请用程序实现模拟用户登录,总共给三次机会,登录之后,给出相应的提示
import java.util.Scanner;
public calss Test1{
public static void main(String[] args){
String username = "admin";
String password = "123456";
Scanner sc = new Scanner(System.in);
for(int i =1;i<=3;i++){
System.out.println("请输入用户名:");
String scUsername = sc.nextLine();
System.out.println("请输入密码:");
String scPassword = sc.nextLine();
if(uesername.equals(scUsername)&&password.equals(scPassword)){
System.out.println("登录成功");
break;
}else{
if(i==3){
System.out.println("您的登录次数已达到今日上限,请明日再来");
}else{
System.out.println("登录失败,您还剩下"+(3-i)+"次机会");
}
}
}
}
}
- 遍历字符串
键盘录入一个字符串,使用程序实现在控制台遍历该字符串
import java.util.Scanner;
public calss Test1{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入:");
String s = sc.nextLine();
for(int i =0;i<s.length();i++){
System.out.println(s.charAt(i));//charAt 返回指定索引处的char值,字符串的索引也是从0开始的
}
}
}
import java.util.Scanner;
public calss Test1{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入:");
String s = sc.nextLine();
char[] chars = s.toCharArray();//将当前字符串拆分为字符数组
for(int i =0;i<chars.length;i++){
System.out.println(chars[i]);
}
}
}
- 统计字符次数
键盘录入一个字符串,统计该字符中大写字母字符,小写字母字符,数字符出现的次数(不考虑其他字符)
import java.util.Scanner;
public calss Test1{
public static void main(String[] args){
int da = 0;
int xiao = 0;
int shu = 0;
Scanner sc = new Scanner(System.in);
System.out.println("请输入:");
String s = sc.nextLine();
char[] chars = s.toCharArray();
for(int i =0;i<chars.length;i++){
if(chars[i]>='A'&&chars[i]<='Z'){
da++;
}else if(chars[i]>='a'&&chars[i]<='z'){
xiao++;
}else if(chars[i]>='0'&&chars[i]<='9'){
shu++;
}
System.out.println("大写字母符个数:"+da);
System.out.println("小写字母符个数:"+xiao);
System.out.println("数字符个数:"+shu);
}
}
}
- 手机号屏蔽
以字符串的形式从键盘接受一个手机号,将中间四位号码屏蔽
import java.util.Scanner;
public calss Test1{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入:");
String s = sc.nextLine();
String hou = s.substring(s.length() - 4);
String qian = s.substring(0, 3);//[0,3)
System.out.println(qian+"****"+hou);
}
}
}
- 敏感词替换
键盘录入一个字符串,如果字符串中包含(TMD),则使用***替换
import java.util.Scanner;
public calss Test1{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入:");
String s = sc.nextLine();
String ss = s.replace("TMD", "***");
System.out.println(ss);
}
}
}
- 切割字符串
以字符串形式从键盘录入学生信息,例如“张三,23”从该字符串中切割出有效数据,封装为Student学生对象
import java.util.Scanner;
public class Student{
private String name;
private int age;
//无参数构造
public Student(){}
//有参数构造
public Student(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(String age){
this.age = age;
}
public intgetAge(){
return age;
}
}
public calss Test1{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入学生信息:");
String s = sc.nextLine();
String[] arr = s.split(",");
Stufent stu = new Student(arr[0], arr[1]);
System.out.println(stu.getName()+"..."+stu.getAge());
}
}
}
小结
StringBuilder
StringBuilder是一个可变的字符串类,可以把它看成是一个容器
作用:提高字符串的工作效率
StringBuilder构造方法
StringBuilder常用方法
链式编程:如果一个方法返回的是对象类型,对象就可以继续向下调用方法
StringBuilder sb = new StringBuilder();
sb.append("red").append("blue").append("green");
StringBuilder提高效率原理图
StringBuilder和String的区别
- string:内容是不可变的
- StringBuilder:内容是可变的
案例
1.对称字符串
键盘接受一个字符串,程序判断出该字符串是否是对称字符串,并在控制台打印是或不是
对称字符串:123321、111
非对称字符串:123123
import java.util.Scanner
public class Test{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入对称字符串:");
String s = sc.nextLine();
StringBuilder sb = new StringBuilder(s);
sb.reverse();
if(s.equals(sb.toString())){
System.out.println("是");
}else{
System.out.println("不是");
}
}
}
2.拼接字符串
定义一个方法,把int数组中的数据按照指定的格式拼接成一个字符串返回,调用该方法,并在控制台输出结果。例如,数组为int[] arr = {1,2,3}; ,执行方法后输出结果为:[1,2,3]
public class Test{
public static void main(String[] args){
int[] arr = {1,2,3};
String s = arrayToString(arr);
System.out.println(s);
}
public static String arrayToString(int[] arr){
StringBuilder sb = new StringBuilder("[");
for(int i = 0; i < arr.length; i++){
if(i == arr.length - 1){
sb.append(arr[i]).append("]");
}else{
sb.append(arr[i]).append(", ");
}
}
return sb.toString();
}
}
集合基础
对象数组
将(张三,23)(李四,24)(王五,25)封装为3个学生对象并存入数组随后遍历数组,将学生信息输出在控制台
import domain.Student;
public class Test {
public static void main(String[] args) {
Student[] arr = new Student[3];
Student stu1 = new Student("张三", 23);
Student stu2 = new Student("李四", 24);
Student stu3 = new Student("王五", 25);
arr[0] = stu1;
arr[1] = stu2;
arr[2] = stu3;
for (int i = 0; i < arr.length; i++) {
Student temp = arr[i];
System.out.println(temp.getName() + "..." + temp.getAge());
}
}
}
package domain;
public class Student {
private String name;
private int age;
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;
}
}
集合和数组的特点对比
- 集合类的特点:提供一种存储空间可变的存储模型,存储的数据容量可以发生改变
- 集合和数组的区别:
- 共同点:都是存储数据的容器
- 不同点:数组的容量是固定的,集合的容量是可变的
如果存储的数据,长度经常发生改变,推荐使用集合
ArrayList集合
构造方法和添加方法
ArrayList <E>
- 可调整大小的数组实现
- <E> 是一种特殊的数据类型,泛型
在出现E的地方我们使用引用数据类型替换即可,如ArrayList< String>,ArrayList<Student>
ArrayList集合常用方法
案例
- 存储字符串并遍历
创建一个存储字符串的集合,存储3个字符串元素,使用程序实现在控制台遍历该集合
import java.util.ArrayList;
public class Test {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("zhangsan");
list.add("lisi");
list.add("wangwu");
for (int i = 0; i < list.size(); i++) {
String s = list.get(i);
System.out.println(s);
}
}
}
- 存储学生对象并遍历
创建一个存储学生对象的集合,存储3个学生对象,使用程序实现在控制台遍历该集合
import domain.Student;
import java.util.ArrayList;
public class Test {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<>();
Student stu1 = new Student("张三", 23);
Student stu2 = new Student("李四", 24);
Student stu3 = new Student("王五", 25);
list.add(stu1);
list.add(stu2);
list.add(stu3);
for (int i = 0; i < list.size(); i++) {
Student stu = list.get(i);
System.out.println(stu.getName() + "..." + stu.getAge());
}
}
}
package domain;
public class Student {
private String name;
private int age;
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;
}
}
学生信息从键盘录入
import domain.Student;
import java.util.ArrayList;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<>();
Student stu1 = getStudent();
Student stu2 = getStudent();
Student stu3 = getStudent();
list.add(stu1);
list.add(stu2);
list.add(stu3);
for (int i = 0; i < list.size(); i++) {
Student stu = list.get(i);
System.out.println(stu.getName() + "..." + stu.getAge());
}
}
private static Student getStudent() {
Scanner sc = new Scanner(System.in);
System.out.println("请输入学生姓名:");
String name = sc.next();
System.out.println("请输入学生年龄:");
int age = sc.nextInt();
Student stu = new Student(name, age);
return stu;
}
}
- 集合删除元素
创建一个存储String的集合,内部存储(test,张三,李四,test,test)字符串删除所有的test字符串,删除后,将集合剩余元素打印在控制台
根据元素进行删除,只能删除集合中的第一个元素
import java.util.ArrayList;
public class Test {
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++) {
//常量在前,避免空指针调用方法
if ("test".equals(list.get(i))) {
list.remove(i);
//删除后元素递进,需索引-1才能回置
i--;
}
}
System.out.println(list);
}
}
4. 集合元素筛选
定义一个方法,方法接收一个集合对象(泛型为Student),方法内部将年龄低于18的学生对象找出并存入新集合对象,方法返回新集合。
import domain.Student;
import java.util.ArrayList;
public class Test {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<>();
Student stu1 = new Student("张三", 10);
Student stu2 = new Student("李四", 10);
Student stu3 = new Student("王五", 20);
list.add(stu1);
list.add(stu2);
list.add(stu3);
ArrayList<Student> newList = getList(list);
for (int i = 0; i < newList.size(); i++) {
Student stu = newList.get(i);
System.out.println(stu.getName() + "..." + stu.getAge());
}
}
public static ArrayList<Student> getList(ArrayList<Student> list){
ArrayList<Student> newList = new ArrayList<>();
for (int i = 0; i < list.size(); i++) {
Student stu = list.get(i);
int age = stu.getAge();
if(age < 18) {
newList.add(stu);
}
}
return newList;
}
}