1. 封装
1.1 private关键字【理解】
private是一个修饰符，可以用来修饰成员（成员变量，成员方法）
-
被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
-
提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
-
提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰
-
-
示例代码：
/* 学生类 */ class Student { //成员变量 String name; private int age; //提供get/set方法 public void setAge(int a) { if(a<0 || a>120) { System.out.println("你给的年龄有误"); } else { age = a; } } public int getAge() { return age; } //成员方法 public void show() { System.out.println(name + "," + age); } } /* 学生测试类 */ public class StudentDemo { public static void main(String[] args) { //创建对象 Student s = new Student(); //给成员变量赋值 s.name = "林青霞"; s.setAge(30); //调用show方法 s.show(); } }
1.2 private的使用【应用】
-
需求：定义标准的学生类，要求name和age使用private修饰，并提供set和get方法以及便于显示数据的show方法，测试类中创建对象并使用，最终控制台输出 林青霞，30
-
示例代码：
/* 学生类 */ class Student { //成员变量 private String name; private int age; //get/set方法 public void setName(String n) { name = n; } public String getName() { return name; } public void setAge(int a) { age = a; } public int getAge() { return age; } public void show() { System.out.println(name + "," + age); } } /* 学生测试类 */ public class StudentDemo { public static void main(String[] args) { //创建对象 Student s = new Student(); //使用set方法给成员变量赋值 s.setName("林青霞"); s.setAge(30); s.show(); //使用get方法获取成员变量的值 System.out.println(s.getName() + "---" + s.getAge()); System.out.println(s.getName() + "," + s.getAge()); } }
1.3 this关键字【应用】
-
this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）
-
方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
-
方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量
-
public class Student {
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;
}
public void show() {
System.out.println(name + "," + age);
}
}
1.4 this内存原理【理解】
-
this代表当前调用方法的引用，哪个对象调用的方法，this就代表哪一个对象
-
示例代码：
public class StudentDemo { public static void main(String[] args) { Student s1 = new Student(); s1.setName("林青霞"); Student s2 = new Student(); s2.setName("张曼玉"); } }
1.5 封装思想【理解】
-
封装概述 是面向对象三大特征之一（封装，继承，多态） 是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的
-
封装原则 将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问 成员变量private，提供对应的getXxx()/setXxx()方法
-
封装好处 通过方法来控制成员变量的操作，提高了代码的安全性 把代码用方法进行封装，提高了代码的复用性
1.6 构造方法
1.6.1 构造方法概述【理解】
构造方法是一种特殊的方法
-
作用：创建对象 Student stu = new Student();
-
格式：
public class 类名{
修饰符 类名( 参数 ) {
}
}
-
功能：主要是完成对象数据的初始化
-
示例代码：
class Student {
private String name;
private int age;
//构造方法
public Student() {
System.out.println("无参构造方法");
}
public void show() {
System.out.println(name + "," + age);
}
}
/*
测试类
*/
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s = new Student();
s.show();
}
}
1.6.2 构造方法的注意事项【理解】
-
构造方法的创建
如果没有定义构造方法，系统将给出一个默认的无参数构造方法 如果定义了构造方法，系统将不再提供默认的构造方法
-
构造方法的重载
如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法
-
推荐的使用方式
无论是否使用，都手工书写无参数构造方法
-
重要功能！
可以使用带参构造，为成员变量进行初始化
-
示例代码
/*
学生类
*/
class Student {
private String name;
private int age;
public Student() {}
public Student(String name) {
this.name = name;
}
public Student(int age) {
this.age = age;
}
public Student(String name,int age) {
this.name = name;
this.age = age;
}
public void show() {
System.out.println(name + "," + age);
}
}
/*
测试类
*/
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s1 = new Student();
s1.show();
//public Student(String name)
Student s2 = new Student("林青霞");
s2.show();
//public Student(int age)
Student s3 = new Student(30);
s3.show();
//public Student(String name,int age)
Student s4 = new Student("林青霞",30);
s4.show();
}
}
1.6.3 标准类制作【应用】
-
需求：定义标准学生类，要求分别使用空参和有参构造方法创建对象，空参创建的对象通过setXxx赋值，有参创建的对象直接赋值，并通过show方法展示数据。
-
示例代码：
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(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void show() {
System.out.println(name + "," + age);
}
}
/*
创建对象并为其成员变量赋值的两种方式
1:无参构造方法创建对象后使用setXxx()赋值
2:使用带参构造方法直接创建带有属性值的对象
*/
public class StudentDemo {
public static void main(String[] args) {
//无参构造方法创建对象后使用setXxx()赋值
Student s1 = new Student();
s1.setName("林青霞");
s1.setAge(30);
s1.show();
//使用带参构造方法直接创建带有属性值的对象
Student s2 = new Student("林青霞",30);
s2.show();
}
}
1.7.API
1.7.1API概述【理解】
-
什么是API
API (Application Programming Interface) ：应用程序编程接口
-
java中的API
指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。
1.7.2如何使用API帮助文档【应用】
-
打开帮助文档
-
找到索引选项卡中的输入框
-
在输入框中输入Random
-
看类在哪个包下
-
看类的描述
-
看构造方法
-
看成员方法
1.8.String类
1.8.1 String类概述【理解】
String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例。也就是说，Java 程序中所有的双引号字符串，都是 String 类的对象。String 类在 java.lang 包下，所以使用的时候不需要导包！
1.8.2 String类的特点【理解】
-
字符串不可变，它们的值在创建后不能被更改
-
虽然 String 的值是不可变的，但是它们可以被共享
-
字符串效果上相当于字符数组( char[] )，但是底层原理是字节数组( byte[] )
1.8.3 String类的构造方法【记忆】
-
常用的构造方法
方法名 说明 public String() 创建一个空白字符串对象，不含有任何内容 public String(char[] chs) 根据字符数组的内容，来创建字符串对象 public String(byte[] bys) 根据字节数组的内容，来创建字符串对象 String s = “abc”; 直接赋值的方式创建字符串对象，内容就是abc -
示例代码
public class StringDemo01 { public static void main(String[] args) { //public String()：创建一个空白字符串对象，不含有任何内容 String s1 = new String(); System.out.println("s1:" + s1); //public String(char[] chs)：根据字符数组的内容，来创建字符串对象 char[] chs = {'a', 'b', 'c'}; String s2 = new String(chs); System.out.println("s2:" + s2); //public String(byte[] bys)：根据字节数组的内容，来创建字符串对象 byte[] bys = {97, 98, 99}; String s3 = new String(bys); System.out.println("s3:" + s3); //String s = “abc”; 直接赋值的方式创建字符串对象，内容就是abc String s4 = "abc"; System.out.println("s4:" + s4); } }
1.8.4 创建字符串对象两种方式的区别【理解】
-
通过构造方法创建
通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值不同
-
直接赋值方式创建
以“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一个 String 对象，并在字符串池中维护
1.8.5 字符串的比较【理解】
==号的作用
-
比较基本数据类型：比较的是具体的值
-
比较引用数据类型：比较的是对象地址值
equals方法的作用
-
方法介绍
public boolean equals(String s) 比较两个字符串内容是否相同、区分大小写
-
示例代码
public class StringDemo02 { 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(s1 == s2); System.out.println(s1 == s3); System.out.println(s3 == s4); System.out.println("--------"); //比较字符串内容是否相同 System.out.println(s1.equals(s2)); System.out.println(s1.equals(s3)); System.out.println(s3.equals(s4)); } }
1.8.6用户登录案例【应用】
案例需求
已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录之后，给出相应的提示
代码实现
/*
思路：
1:已知用户名和密码，定义两个字符串表示即可
2:键盘录入要登录的用户名和密码，用 Scanner 实现
3:拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。字符串的内容比较，用equals() 方法实现
4:用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循环
*/
public class StringTest01 {
public static void main(String[] args) {
//已知用户名和密码，定义两个字符串表示即可
String username = "itheima";
String password = "czbk";
//用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循环
for(int i=0; i<3; i++) {
//键盘录入要登录的用户名和密码，用 Scanner 实现
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名：");
String name = sc.nextLine();
System.out.println("请输入密码：");
String pwd = sc.nextLine();
//拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。字符串的内容比较，用equals() 方法实现
if (name.equals(username) && pwd.equals(password)) {
System.out.println("登录成功");
break;
} else {
if(2-i == 0) {
System.out.println("你的账户被锁定，请与管理员联系");
} else {
//2,1,0
//i,0,1,2
System.out.println("登录失败，你还有" + (2 - i) + "次机会");
}
}
}
}
}
1.8.7遍历字符串案例【应用】
案例需求
键盘录入一个字符串，使用程序实现在控制台遍历该字符串
代码实现
/*
思路：
1:键盘录入一个字符串，用 Scanner 实现
2:遍历字符串，首先要能够获取到字符串中的每一个字符
public char charAt(int index)：返回指定索引处的char值，字符串的索引也是从0开始的
3:遍历字符串，其次要能够获取到字符串的长度
public int length()：返回此字符串的长度
数组的长度：数组名.length
字符串的长度：字符串对象.length()
4:遍历字符串的通用格式
*/
public class StringTest02 {
public static void main(String[] args) {
//键盘录入一个字符串，用 Scanner 实现
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String line = sc.nextLine();
for(int i=0; i<line.length(); i++) {
System.out.println(line.charAt(i));
}
}
}
1.8.8统计字符次数案例【应用】
案例需求
键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)
代码实现
/*
思路：
1:键盘录入一个字符串，用 Scanner 实现
2:要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
3:遍历字符串，得到每一个字符
4:判断该字符属于哪种类型，然后对应类型的统计变量+1
假如ch是一个字符，我要判断它属于大写字母，小写字母，还是数字，直接判断该字符是否在对应的范围即可
大写字母：ch>='A' && ch<='Z'
小写字母： ch>='a' && ch<='z'
数字： ch>='0' && ch<='9'
5:输出三种类型的字符个数
*/
public class StringTest03 {
public static void main(String[] args) {
//键盘录入一个字符串，用 Scanner 实现
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String line = sc.nextLine();
//要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
int bigCount = 0;
int smallCount = 0;
int numberCount = 0;
//遍历字符串，得到每一个字符
for(int i=0; i<line.length(); i++) {
char ch = line.charAt(i);
//判断该字符属于哪种类型，然后对应类型的统计变量+1
if(ch>='A' && ch<='Z') {
bigCount++;
} else if(ch>='a' && ch<='z') {
smallCount++;
} else if(ch>='0' && ch<='9') {
numberCount++;
}
}
//输出三种类型的字符个数
System.out.println("大写字母：" + bigCount + "个");
System.out.println("小写字母：" + smallCount + "个");
System.out.println("数字：" + numberCount + "个");
}
}
1.8.9字符串拼接案例【应用】
案例需求
定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，
并在控制台输出结果。例如，数组为 int[] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]
代码实现
/*
思路：
1:定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
2:定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回。
返回值类型 String，参数列表 int[] arr
3:在方法中遍历数组，按照要求进行拼接
4:调用方法，用一个变量接收结果
5:输出结果
*/
public class StringTest04 {
public static void main(String[] args) {
//定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
int[] arr = {1, 2, 3};
//调用方法，用一个变量接收结果
String s = arrayToString(arr);
//输出结果
System.out.println("s:" + s);
}
//定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回
/*
两个明确：
返回值类型：String
参数：int[] arr
*/
public static String arrayToString(int[] arr) {
//在方法中遍历数组，按照要求进行拼接
String s = "";
s += "[";
for(int i=0; i<arr.length; i++) {
if(i==arr.length-1) {
s += arr[i];
} else {
s += arr[i];
s += ", ";
}
}
s += "]";
return s;
}
}
1.8.10字符串反转案例【应用】
案例需求
定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果
例如，键盘录入 abc，输出结果 cba
代码实现
/*
思路：
1:键盘录入一个字符串，用 Scanner 实现
2:定义一个方法，实现字符串反转。返回值类型 String，参数 String s
3:在方法中把字符串倒着遍历，然后把每一个得到的字符拼接成一个字符串并返回
4:调用方法，用一个变量接收结果
5:输出结果
*/
public class StringTest05 {
public static void main(String[] args) {
//键盘录入一个字符串，用 Scanner 实现
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String line = sc.nextLine();
//调用方法，用一个变量接收结果
String s = reverse(line);
//输出结果
System.out.println("s:" + s);
}
//定义一个方法，实现字符串反转
/*
两个明确：
返回值类型：String
参数：String s
*/
public static String reverse(String s) {
//在方法中把字符串倒着遍历，然后把每一个得到的字符拼接成一个字符串并返回
String ss = "";
for(int i=s.length()-1; i>=0; i--) {
ss += s.charAt(i);
}
return ss;
}
}
1.8.11帮助文档查看String常用方法【记忆】
| 方法名 | 说明 |
|---|---|
| public boolean equals(Object anObject) | 比较字符串的内容，严格区分大小写(用户名和密码) |
| public char charAt(int index) | 返回指定索引处的 char 值 |
| public int length() | 返回此字符串的长度 |
1.9 StringBuilder类
1.9.1 StringBuilder类概述【理解】
StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是 StringBuilder 对象中的内容是可变的
1.9.2 StringBuilder类和String类的区别【理解】
-
String类：内容是不可变的
-
StringBuilder类：内容是可变的
1.9.3 StringBuilder类的构造方法【记忆】
-
常用的构造方法
方法名 说明 public StringBuilder() 创建一个空白可变字符串对象，不含有任何内容 public StringBuilder(String str) 根据字符串的内容，来创建可变字符串对象 -
示例代码
public class StringBuilderDemo01 {
public static void main(String[] args) {
//public StringBuilder()：创建一个空白可变字符串对象，不含有任何内容
StringBuilder sb = new StringBuilder();
System.out.println("sb:" + sb);
System.out.println("sb.length():" + sb.length());
//public StringBuilder(String str)：根据字符串的内容，来创建可变字符串对象
StringBuilder sb2 = new StringBuilder("hello");
System.out.println("sb2:" + sb2);
System.out.println("sb2.length():" + sb2.length());
}
}
1.9.4 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");
//
// System.out.println("sb:" + sb);
// System.out.println("sb2:" + sb2);
// System.out.println(sb == sb2);
// sb.append("hello");
// sb.append("world");
// sb.append("java");
// sb.append(100);
//链式编程
sb.append("hello").append("world").append("java").append(100);
System.out.println("sb:" + sb);
//public StringBuilder reverse()：返回相反的字符序列
sb.reverse();
System.out.println("sb:" + sb);
}
}
1.9.5 StringBuilder和String相互转换【应用】
-
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) {
/*
//StringBuilder 转换为 String
StringBuilder sb = new StringBuilder();
sb.append("hello");
//String s = sb; //这个是错误的做法
//public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String
String s = sb.toString();
System.out.println(s);
*/
//String 转换为 StringBuilder
String s = "hello";
//StringBuilder sb = s; //这个是错误的做法
//public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder
StringBuilder sb = new StringBuilder(s);
System.out.println(sb);
}
}
1.9.6 字符串拼接升级版案例【应用】
案例需求
定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，
并在控制台输出结果。例如，数组为int[] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]
代码实现
/*
思路：
1:定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
2:定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回。
返回值类型 String，参数列表 int[] arr
3:在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
4:调用方法，用一个变量接收结果
5:输出结果
*/
public class StringBuilderTest01 {
public static void main(String[] args) {
//定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
int[] arr = {1, 2, 3};
//调用方法，用一个变量接收结果
String s = arrayToString(arr);
//输出结果
System.out.println("s:" + s);
}
//定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回
/*
两个明确：
返回值类型：String
参数：int[] arr
*/
public static String arrayToString(int[] arr) {
//在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
StringBuilder sb = new StringBuilder();
sb.append("[");
for(int i=0; i<arr.length; i++) {
if(i == arr.length-1) {
sb.append(arr[i]);
} else {
sb.append(arr[i]).append(", ");
}
}
sb.append("]");
String s = sb.toString();
return s;
}
}
1.9.7字符串反转升级版案例【应用】
案例需求
定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果
例如，键盘录入abc，输出结果 cba
代码实现
/*
思路：
1:键盘录入一个字符串，用 Scanner 实现
2:定义一个方法，实现字符串反转。返回值类型 String，参数 String s
3:在方法中用StringBuilder实现字符串的反转，并把结果转成String返回
4:调用方法，用一个变量接收结果
5:输出结果
*/
public class StringBuilderTest02 {
public static void main(String[] args) {
//键盘录入一个字符串，用 Scanner 实现
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String line = sc.nextLine();
//调用方法，用一个变量接收结果
String s = myReverse(line);
//输出结果
System.out.println("s:" + s);
}
//定义一个方法，实现字符串反转。返回值类型 String，参数 String s
/*
两个明确：
返回值类型：String
参数：String s
*/
public static String myReverse(String s) {
//在方法中用StringBuilder实现字符串的反转，并把结果转成String返回
//String --- StringBuilder --- reverse() --- String
// StringBuilder sb = new StringBuilder(s);
// sb.reverse();
// String ss = sb.toString();
// return ss;
return new StringBuilder(s).reverse().toString();
}
}
1.9.8帮助文档查看StringBuilder常用方法【记忆】
| 方法名 | 说明 |
|---|---|
| public StringBuilder append (任意类型) | 添加数据，并返回对象本身 |
| public StringBuilder reverse() | 返回相反的字符序列 |
| public int length() | 返回长度，实际存储值 |
| public String toString() | 通过toString()就可以实现把StringBuilder转换为String |
2. 继承
2.1 继承的实现（掌握）
-
继承的概念
-
继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法
-
-
实现继承的格式
-
继承通过extends实现
-
格式：class 子类 extends 父类 { }
-
举例：class Dog extends Animal { }
-
-
-
继承带来的好处
-
继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员。
-
-
示例代码
public class Fu { public void show() { System.out.println("show方法被调用"); } } public class Zi extends Fu { public void method() { System.out.println("method方法被调用"); } } public class Demo { public static void main(String[] args) { //创建对象，调用方法 Fu f = new Fu(); f.show(); Zi z = new Zi(); z.method(); z.show(); } }
2.2 继承的好处和弊端（理解）
-
继承好处
-
提高了代码的复用性(多个类相同的成员可以放到同一个类中)
-
提高了代码的维护性(如果方法的代码需要修改，修改一处即可)
-
-
继承弊端
-
继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性
-
-
继承的应用场景：
-
使用继承，需要考虑类与类之间是否存在is..a的关系，不能盲目使用继承
-
is..a的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类
-
-
2.3 继承中的成员访问特点
2.3.1继承中变量的访问特点（掌握）
在子类方法中访问一个变量，采用的是就近原则。
-
子类局部范围找
-
子类成员范围找
-
父类成员范围找
-
如果都没有就报错(不考虑父亲的父亲…)
-
示例代码
class Fu { int num = 10; } class Zi { int num = 20; public void show(){ int num = 30; System.out.println(num); } } public class Demo1 { public static void main(String[] args) { Zi z = new Zi(); z.show(); // 输出show方法中的局部变量30 } }
2.3.2 super（掌握）
-
this&super关键字：
-
this：代表本类对象的引用
-
super：代表父类存储空间的标识(可以理解为父类对象引用)
-
-
this和super的使用分别
-
成员变量：
-
this.成员变量 - 访问本类成员变量
-
super.成员变量 - 访问父类成员变量
-
-
成员方法：
-
this.成员方法 - 访问本类成员方法
-
super.成员方法 - 访问父类成员方法
-
-
-
构造方法：
-
this(…) - 访问本类构造方法
-
super(…) - 访问父类构造方法
-
2.4 继承中构造方法的访问特点（理解）
注意：子类中所有的构造方法默认都会访问父类中无参的构造方法
子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化，原因在于，每一个子类构造方法的第一条语句默认都是：super()
问题：如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？
1. 通过使用super关键字去显示的调用父类的带参构造方法 2. 在父类中自己提供一个无参构造方法
推荐方案：
自己给出无参构造方法
2.5 继承中成员方法的访问特点（掌握）
通过子类对象访问一个方法
-
子类成员范围找
-
父类成员范围找
-
如果都没有就报错(不考虑父亲的父亲…)
2.6 super内存图（理解）
-
对象在堆内存中，会单独存在一块super区域，用来存放父类的数据
2.7 方法重写（掌握）
-
1、方法重写概念
-
子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）
-
-
2、方法重写的应用场景
-
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容
-
-
3、Override注解
-
用来检测当前的方法，是否是重写的方法，起到【校验】的作用
-
2.8 方法重写的注意事项（掌握）
-
方法重写的注意事项
-
私有方法不能被重写(父类私有成员子类是不能继承的)
-
子类方法访问权限不能更低(public > 默认 > 私有)
-
示例代码
public class Fu {
private void show() {
System.out.println("Fu中show()方法被调用");
}
void method() {
System.out.println("Fu中method()方法被调用");
}
}
public class Zi extends Fu {
/* 编译【出错】，子类不能重写父类私有的方法*/
@Override
private void show() {
System.out.println("Zi中show()方法被调用");
}
/* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */
@Override
private void method() {
System.out.println("Zi中method()方法被调用");
}
/* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */
@Override
public void method() {
System.out.println("Zi中method()方法被调用");
}
}
2.9. Java中继承的注意事项（掌握）
-
Java中继承的注意事项
-
Java中类只支持单继承，不支持多继承
-
错误范例：class A extends B, C { }
-
-
Java中类支持多层继承
-
-
多层继承示例代码：
public class Granddad { public void drink() { System.out.println("爷爷爱喝酒"); } } public class Father extends Granddad { public void smoke() { System.out.println("爸爸爱抽烟"); } } public class Mother { public void dance() { System.out.println("妈妈爱跳舞"); } } public class Son extends Father { // 此时，Son类中就同时拥有drink方法以及smoke方法 }
2.10 继承练习
2.10.1 老师和学生（应用）
-
需求：定义老师类和学生类，然后写代码测试；最后找到老师类和学生类当中的共性内容，抽取出一个父类，用继承的方式改写代码，并进行测试
-
步骤：
①定义老师类(姓名，年龄，教书())
②定义学生类(姓名，年龄，学习())
③定义测试类，写代码测试
④共性抽取父类，定义人类(姓名，年龄)
⑤定义老师类，继承人类，并给出自己特有方法：教书()
⑥定义学生类，继承人类，并给出自己特有方法：学习()
⑦定义测试类，写代码测试
-
示例代码：
class Person { private String name; private int age; public Person() { } public Person(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; } } class Teacher extends Person { public Teacher() {} public Teacher(String name,int age) { super(name,age); } public void teach() { System.out.println("用爱成就每一位学员"); } } class Student extends Person{ public Student() {} public Student(String name, int age) { super(name,age); } public void study(){ System.out.println("学生学习"); } } class PersonDemo { public static void main(String[] args){ //创建老师类对象并进行测试 Teacher t1 = new Teacher(); t1.setName("林青霞"); t1.setAge(30); System.out.println(t1.getName() + "," + t1.getAge()); t1.teach(); Teacher t2 = new Teacher("风清扬", 33); System.out.println(t2.getName() + "," + t2.getAge()); t2.teach(); // 创建学生类对象测试 Student s = new Student("张三"，23)； System.out.println(s.getName() + "," + s.getAge()); s.study(); } }
2.10.2 猫和狗（ 应用）
-
需求：请采用继承的思想实现猫和狗的案例，并在测试类中进行测试
-
分析：
①猫：
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：get/set方法，抓老鼠()
②狗：
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：get/set方法，看门()
③共性：
成员变量：姓名，年龄；构造方法：无参，带参；成员方法：get/set方法
-
步骤：
1、定义动物类(Animal)
【成员变量：姓名，年龄】【 构造方法：无参，带参】【成员方法：get/set方法】
2、定义猫类(Cat)，继承动物类
【构造方法：无参，带参】【成员方法：抓老鼠() 】
3、定义狗类(Dog)，继承动物类
【构造方法：无参，带参】【成员方法：看门() 】
4、定义测试类(AnimalDemo)，写代码测试
-
示例代码：
class Animal { private String name; private int age; public Animal() { } public Animal(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; } } class Cat extends Animal { public Cat() { } public Cat(String name, int age) { super(name, age); } public void catchMouse() { System.out.println("猫抓老鼠"); } } class Dog extends Animal { public Dog() { } public Dog(String name, int age) { super(name, age); } public void lookDoor() { System.out.println("狗看门"); } } /* 测试类 */ public class AnimalDemo { public static void main(String[] args) { //创建猫类对象并进行测试 Cat c1 = new Cat(); c1.setName("加菲猫"); c1.setAge(5); System.out.println(c1.getName() + "," + c1.getAge()); c1.catchMouse(); Cat c2 = new Cat("加菲猫", 5); System.out.println(c2.getName() + "," + c2.getAge()); c2.catchMouse(); } }
2.11 修饰符
2.11.1 package（了解）
-
1、包的概念
-
包就是文件夹，用来管理类文件的
-
-
2、包的定义格式
-
package 包名; (多级包用.分开)
-
例如：package com.heima.demo;
-
-
3、带包编译&带包运行
-
带包编译：javac –d . 类名.java
-
例如：javac -d . com.heima.demo.HelloWorld.java
-
-
带包运行：java 包名+类名
-
例如：java com.heima.demo.HelloWorld
-
-
2.11.2 import（理解）
-
导包的意义
使用不同包下的类时，使用的时候要写类的全路径，写起来太麻烦了
为了简化带包的操作，Java就提供了导包的功能
-
导包的格式
格式：import 包名;
范例：import java.util.Scanner;
-
示例代码（没有使用导包，创建的Scanner对象）
package com.heima;
public class Demo {
public static void main(String[] args) {
// 1. 没有导包，创建Scnaner对象
java.util.Scanner sc = new java.util.Scanner(System.in);
}
}
-
示例代码（使用导包后，创建的Scanner对象）
package com.heima;
import java.util.Scanner;
public class Demo {
public static void main(String[] args) {
// 1. 没有导包，创建Scnaner对象
Scanner sc = new Scanner(System.in);
}
}
2.11.3 权限修饰符（理解）
2.11.4 final（应用）
-
fianl关键字的作用
-
final代表最终的意思，可以修饰成员方法，成员变量，类
-
-
final修饰类、方法、变量的效果
-
fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）
-
final修饰方法：该方法不能被重写
-
final修饰变量：表明该变量是一个常量，不能再次赋值
-
2.11.5 final修饰局部变量（理解）
-
fianl修饰基本数据类型变量
-
final 修饰指的是基本类型的数据值不能发生改变
-
-
final修饰引用数据类型变量
-
final 修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的
-
举例：
public static void main(String[] args){ final Student s = new Student(23); s = new Student(24); // 错误 s.setAge(24); // 正确 }
-
2.11.6 static（应用）
-
static的概念
-
static关键字是静态的意思，可以修饰【成员方法】，【成员变量】
-
-
static修饰的特点
-
被类的所有对象共享，这也是我们判断是否使用静态关键字的条件
-
可以通过类名调用当然，也可以通过对象名调用【推荐使用类名调用】
-
-
示例代码：
class Student {
public String name; //姓名
public int age; //年龄
public static String university; //学校 共享数据！所以设计为静态！
public void show() {
System.out.println(name + "," + age + "," + university);
}
}
public class StaticDemo {
public static void main(String[] args) {
// 为对象的共享数据赋值
Student.university = "传智大学";
Student s1 = new Student();
s1.name = "林青霞";
s1.age = 30;
s1.show();
Student s2 = new Student();
s2.name = "风清扬";
s2.age = 33;
s2.show();
}
}
2.11.7 static访问特点（掌握）
-
static的访问特点
-
非静态的成员方法
-
能访问静态的成员变量
-
能访问非静态的成员变量
-
能访问静态的成员方法
-
能访问非静态的成员方法
-
-
静态的成员方法
-
能访问静态的成员变量
-
能访问静态的成员方法
-
-
总结成一句话就是：
-
静态成员方法只能访问静态成员
-
-
3.多态
3.1多态的概述（记忆）
-
什么是多态
同一个对象，在不同时刻表现出来的不同形态
-
多态的前提
-
要有继承或实现关系
-
要有方法的重写
-
要有父类引用指向子类对象
-
3.2多态中的成员访问特点（记忆）
-
成员访问特点
-
成员变量
编译看父类，运行看父类
-
成员方法
编译看父类，运行看子类
-
-
代码演示
-
动物类
public class Animal { public int age = 40; public void eat() { System.out.println("动物吃东西"); } } -
猫类
public class Cat extends Animal { public int age = 20; public int weight = 10; @Override public void eat() { System.out.println("猫吃鱼"); } public void playGame() { System.out.println("猫捉迷藏"); } } -
测试类
public class AnimalDemo { public static void main(String[] args) { //有父类引用指向子类对象 Animal a = new Cat(); System.out.println(a.age); // System.out.println(a.weight); a.eat(); // a.playGame(); } }
-
3.3多态的好处和弊端（记忆）
-
好处
提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作
-
弊端
不能使用子类的特有成员
3.4多态中的转型（应用）
-
向上转型
父类引用指向子类对象就是向上转型
-
向下转型
格式：子类型 对象名 = (子类型)父类引用;
-
代码演示
-
动物类
public class Animal { public void eat() { System.out.println("动物吃东西"); } }-
猫类
public class Cat extends Animal { @Override public void eat() { System.out.println("猫吃鱼"); } public void playGame() { System.out.println("猫捉迷藏"); } }-
测试类
public class AnimalDemo { public static void main(String[] args) { //多态 //向上转型 Animal a = new Cat(); a.eat(); // a.playGame(); //向下转型 Cat c = (Cat)a; c.eat(); c.playGame(); } } -
3.5多态的案例（应用）
-
案例需求
请采用多态的思想实现猫和狗的案例，并在测试类中进行测试
-
代码实现
-
动物类
public class Animal { private String name; private int age; public Animal() { } public Animal(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; } public void eat() { System.out.println("动物吃东西"); } }-
猫类
public class Cat extends Animal { public Cat() { } public Cat(String name, int age) { super(name, age); } @Override public void eat() { System.out.println("猫吃鱼"); } }-
狗类
public class Dog extends Animal { public Dog() { } public Dog(String name, int age) { super(name, age); } @Override public void eat() { System.out.println("狗吃骨头"); } }-
测试类
public class AnimalDemo { public static void main(String[] args) { //创建猫类对象进行测试 Animal a = new Cat(); a.setName("加菲"); a.setAge(5); System.out.println(a.getName() + "," + a.getAge()); a.eat(); a = new Cat("加菲", 5); System.out.println(a.getName() + "," + a.getAge()); a.eat(); } } -
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
