1、面向对象
概念:略
1.1、学习面向对象的三条主线
1、Java类及类的成员:属性,方法,构造器,代码块,内部类
2、面向对象的三大特征:封装,继承,多态
3、其它关键字:this、super、static、final、abstract、interface、package、import 等
1.2、面向对象的2个要素
类和对象
2、类和对象
- 类:对一类事物的描述,是抽象的、概念上的定义
- 对象:是实际存在的该类事物的每个个体,因而也称为实例(instance)。
1、类
面向对象程序设计的重点是类的设计;
设计类,其实就是设计类的成员。
1.1、类的语法格式
2、对象
2.1、对象的创建和使用
创建对象语法: 类名 对象名 = new 类名();
使用“对象名.对象成员”的方式访问对象成员(包括属性和方法)
3、面向思想的落地实现
- 创建类 = 类的实例化 = 实例化类
二.类和对象的使用(面向对象思想落地的实现) - 1.创建类,设计类的成员
- Field = 属性 = 成员变量 = 域、字段
- Method = (成员)方法 = 函数
- 2.创建类的对象
- 3.通过“对象.属性”或“对象.方法”调用对象的结构
4、特性
1、如果创建类一个类的多个对象,则每个对象都独立的拥有一套类的属性。(非 static 的)
意味着:如果我们修改一个对象的属性 a,则不影响另外一个对象属性 a 的值。
2、类的访问机制:
在一个类中的访问机制:类中的方法可以直接访问类中的成员变量。(例外:static方法访问非static,编译不通过。)
在不同类中的访问机制:先创建要访问类的对象,再用对象访问类中
定义的成员。
例子
//测试类
public class PersonTest {
public static void main(String[] args) {
//2.创建 Person 类的对象
//创建对象语法:类名对象名= new 类名();
Person p1 = new Person();
//Scanner scan = new Scanner(System.in);
//调用类的结构:属性、方法
//调用属性:“对象.属性”
p1.name = "Tom";
p1.age = 25;
p1.isMale = true;
System.out.println(p1.name);
//调用方法:“对象.方法”
p1.eat();
p1.sleep();
p1.talk("chinese");
//**********************
Person p2 = new Person();
System.out.println(p2.name); //null
System.out.println(p2.isMale);
//**********************
//将 p1 变量保存的对象地址值赋给 p3,导致 p1 和 p3 指向了堆空间中的一个对象实体。
Person p3 = p1;
System.out.println(p3.name);
p3.age = 10;
System.out.println(p1.age); //10
}
}
/*
* 类的语法格式:
* 修饰符 class 类名{
* 属性声明;
* 方法声明;
* }
* 说明:修饰符 public:类可以被任意访问类的正文要用{ }括起来
*/
//1.创建类,设计类的成员
class Person{
//属性:对应类中的成员变量
String name;
int age;
boolean isMale;
//方法:对应类中的成员方法
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
public void talk(String language){
System.out.println("人可以说话,使用的是:" + language);
}
}
5、匿名对象
我们也可以不定义对象的句柄,而直接调用这个对象的方法。这
样的对象叫做匿名对象。
如:new Person().shout();
使用情况
如果对一个对象只需要进行一次方法调用,那么就可以使用匿名对象。
我们经常将匿名对象作为实参传递给一个方法调用。
3、类的成员之一:属性
1、语法格式
修饰符 数据类型 属性名 = 初始化值 ;
说明1: 修饰符
- 常用的权限修饰符有:private、缺省、protected、public
- 其他修饰符:static、final (暂不考虑)
说明2:数据类型
任何基本数据类型(如int、Boolean) 或 任何引用数据类型。
说明3:属性名
属于标识符,符合命名规则和规范即可。
2、成员变量和局部变量
在方法体外,类体内声明的变量称为成员变量。
在方法体内部声明的变量称为局部变量。
注意:局部变量除形参外,都需要显示赋值后才能使用。
3、区别
4、成员变量默认初始值
5、例子及练习
public class UserTest {
public static void main(String[] args) {
User u1 = new User();
System.out.println(u1.name);
System.out.println(u1.age);
System.out.println(u1.isMale);
u1.talk("俄语");
}
}
class User{
//属性(或成员变量)
String name; //不加权限修饰符,即为缺省
public int age; //加了public,即可被任意访问
boolean isMale;
public void talk(String language){//language:形参,也是局部变量,在该方法调用时赋值
System.out.println("我们使用" + language + "进行交流。");
}
public void eat(){
String food = "石头饼"; //石头饼:局部变量
System.out.println("北方人喜欢吃:" + food);
}
}
public class School {
public static void main(String[] args) {
Student stu = new Student();
stu.name = "小明";
stu.age = 16;
Teacher tea = new Teacher();
tea.name = "王老师";
tea.age = 27;
tea.say(stu.name,stu.age);
stu.say(tea.name, tea.age);
}
}
class Student{
String name;
int age;
String major;
String interests;
void say(String name, int age){
System.out.println("这个学生是:"+name+"年龄是:"+age); }
}
class Teacher{
String name;
int age;
String teachAge;
String course;
void say(String name, int age){
System.out.println("这个老师是:"+name+"年龄是:"+age);
}
}
4、类的成员之二:方法
1、方法的声明格式
权限修饰符:默认方法的权限修饰符先都使用public
Java规定的4种权限修饰符:private、public、缺省、protected
返回值类型: 有返回值 vs 没有返回值
如果方法有返回值,则必须在方法声明时,指定返回值的类型。同时,方法中,需要使用return关键字来返回指定类型的变量或常量:“return 数据”。
如果方法没有返回值,则方法声明时,使用void来表示。通常,没有返回值的方法中,就不需要使用return.但是,如果使用的话,只能“return;”表示结束此方法的意思。
2、例子
1、return关键字的使用:
使用范围:使用在方法体中
注意点:return关键字后不可声明执行语句。
2、方法的使用中,可以调用当前类的属性或方法。
特殊的:方法A中又调用了方法A:递归方法。
方法中不能定义其他方法。
public class CustomerTest {
public static void main(String[] args) {
Customer cust1 = new Customer();
cust1.eat();
//测试形参是否需要设置的问题
// int[] arr = new int[]{3,4,5,2,5};
// cust1.sort();
cust1.sleep(8);
}
}
//客户类
class Customer{
//属性
String name;
int age;
boolean isMale;
//方法
public void eat(){
System.out.println("客户吃饭");
return;
//return后不可以声明表达式
// System.out.println("hello");
}
public void sleep(int hour){
System.out.println("休息了" + hour + "个小时");
eat();
// sleep(10);
}
public String getName(){
if(age > 18){
return name;
}else{
return "Tom";
}
}
public String getNation(String nation){
String info = "我的国籍是:" + nation;
return info;
}
//体会形参是否需要设置的问题
// public void sort(int[] arr){
//
// }
// public void sort(){
// int[] arr = new int[]{3,4,5,2,5,63,2,5};
// //。。。。
// }
public void info(){
//错误的
// public void swim(){
//
// }
}
}
5、再谈方法
1、方法的重载
概念:在同一个类中,允许存在一个以上的同名方法,只要它们的参数个数或者参数类型不同即可。
重载的特点:
与返回值类型无关,只看参数列表,且参数列表必须不同。(参数个数或参数类型)。调用时,根据方法参数列表的不同来区别。
2、可变个数的形参
JavaSE 5.0 中提供了Varargs(variable number of arguments)机制,允许直接定义能和多个实参相匹配的形参。从而,可以用一种更简单的方式,来传递个数可变的实参。
说明
1、声明格式:方法名(参数的类型名 …参数名)
2、当调用可变个数形参的方法时,传入的参数的个数可以是:0个,1个,2个…
3、可变个数形参的方法与本类中方法名相同,形参不同的方法之间构成重载。可变个数形参的方法与本类中方法名相同,形参类型也相同的数组之间不构成重载。即二者不可共存。
4、可变个数形参在方法中的形参中,必须声明在末尾。
5、可变个数形参在方法中的形参中,最多只能声明一个可变形参。
public class MethodArgs {
public static void main(String[] args) {
MethodArgs test = new MethodArgs();
test.show(12);
// test.show("hell0");
// test.show("hello","world");
// test.show();
test.show(new String[] { "AA", "BB", "CC" });
}
public void show(int i) {
}
// public void show(String s){
// System.out.println("show(String)");
// }
public void show(String... strs) {
System.out.println("show(String ...strs)");
for (int i = 0; i < strs.length; i++) {
System.out.println(strs[i]);
}
}
// 此方法与上一方法不可共存
// public void show(String[] strs){
//
// }
public void show(int i, String... strs) {
}
//The variable argument type String of the method show must be the last parameter
// public void show(String... strs,int i,) {
//
// }
}
3、方法参数的值传递机制
/*
* int[] arr = new int[10];
* System.out.println(arr);//地址值?
*
* char[] arr1 = new char[10];
* System.out.println(arr1);//地址值?
*/
public class ArrayPrint {
public static void main(String[] args) {
int[] arr = new int[]{1,2,3};
//传进去的是一个Object的对象
System.out.println(arr);//地址值
char[] arr1 = new char[]{'a','b','c'};
//传进去的是一个数组,里面遍历数据了
System.out.println(arr1);//abc
}
}
原因:
面向对象特征之一:封装与隐藏
问题的引入:
当我们创建一个类的对象以后,我们可以通过"对象.属性"的方式,对对象的属性进行赋值。这里,赋值操作要受到属性的数据类型和存储范围的制约。但除此之外,没有其他制约条件。但是,实际问题中,我们往往需要给属性赋值加入额外限制条件。这个条件就不能在属性声明时体现,我们只能通过方法进行条件的添加。比如说,setLegs同时,我们需要避免用户再使用“对象.属性”的方式对属性进行赋值。则需要将属性声明为私有的(private) --》此时,针对于属性就体现了封装性。
四种权限修饰符的理解与测试
Java 权限修饰符public、protected、default(缺省)、private 置于类的成员定义前,用来限定对象对该类成员的访问权限。
对于 class 的权限修饰只可以用 public 和 default(缺省)。
public 类可以在任意地方被访问。
default 类只可以被同一个包内部的类访问。
7、构造器
1、构造器的理解和使用
语法格式
构造器的特征
- 它具有与类相同的名称
- 它不声明返回值类型。(与声明为void不同)
- 不能被static、final、synchronized、abstract、native修饰,不能有
return语句返回值(只能使用权限修饰符)
特别说明:
- 1.如果没有显示的定义类的构造器的话,则系统默认提供一个空参的构造器,默认构造器的修饰符和所属类的修饰符一致。
- 2.一个类中定义的多个构造器,彼此构成重载。
- 3.一旦显示的定义了类的构造器之后,系统不再提供默认的空参构造器。
- 4.一个类中,至少会有一个构造器
- 5.父类的构造器不可被子类继承
构造器的作用: - 1.创建对象
- 2.初始化对象的属性
2、总结属性赋值的过程
- ① 默认初始化值
- ② 显式初始化
- ③ 构造器中赋值
- ④ 通过"对象.方法" 或 “对象.属性”的方式,赋值
3、JavaBean 的使用
- JavaBean 是一种 Java 语言写成的可重用组件。
- 所谓 javaBean,是指符合如下标准的 Java 类:
> 类是公共的
> 有一个无参的公共的构造器
> 有属性,且有对应的 get、set 方法
8、关键字:this 的使用
this代表的意义:
它在方法内部使用,即这个方法所属对象的引用;
它在构造器内部使用,表示该构造器正在初始化的对象。
总之,this 理解为:当前对象,或当前正在创建的对象。
this使用场景
- 用this来区分属性和局部变量
- 使用this,调用属性、方法
- 在类的方法中,我们可以使用"this.属性"或"this.方法"的方式,调用当前对象属性和方法。通常情况下,我们都选择省略“this.”。特殊情况下,如果方法的形参和类的属性同名,我们必须显式的使用"this.变量"的方式,表明此变量是属性,而非形参。
- 在类的构造器中,我们可以使用"this.属性"或"this.方法"的方式,调用正在创建的对象属性和方法。但是,通常情况下,我们都选择省略“this.”。特殊情况下,如果构造器的形参和类的属性同名,我们必须显式的使用"this.变量"的方式,表明此变量是属性,而非形参。
- 使用this调用本类的构造器
- ① 我们可以在类的构造器中,显式的使用"this(形参列表)"的方式,调用本类中重载的其他的构造器!
- ② 构造器中不能通过"this(形参列表)"的方式调用自己。
- ③ 如果一个类中声明了n个构造器,则最多有n -1个构造器中使用了"this(形参列表)"。
- ④ "this(形参列表)"必须声明在类的构造器的首行!
- ⑤ 在类的一个构造器中,最多只能声明一个"this(形参列表)"。
9、import和package关键字
略