• 欢迎光临~

肖sir__Java API Java类和对象13

开发技术 开发技术 2022-09-30 次浏览
1.1 面向对象概述
什么是对象?
所谓对象就是真实世界中的事物,对象与事物一一对应,也就是说现实世界中每一个
事物都是一个对象。
比如:
物:张三的宠物狗旺财。张三是一个对象,旺财也是一个对象。
事:李四在多测师学Java开发。李四是对象,多测师是对象,Java开发也是对象
对象的特点:
对象具有属性和行为。
//比如张三的属性:有姓名,年龄,性别。行为:养宠物
对象具有变化的状态。
//比如张三的年龄,身高,体重都会随着时间而发生变化
对象具有唯一性。
//比如张三这个人在现实生活中就是唯一的
对象都是某个类别的实例。//比如张三是人类的实例
 
=================================
1.2 面向对象概述
Java中的对象:
Java是面向对象的编程语言,对象就是面向对象程序设计的核心。
在Java语言中,一切皆对象。Java中使用类抽象地把现实世界中某一类别的事物进行
定义描述。而Java中的对象就是类的一个实例。一个Java中的对象代表了某个具体的
事物。
例如,在真实世界的学校里,会有学生和老师。学生有学号、姓名、所在班级等属性。学生还有学习、提问、吃饭和走路等行为。学生只是学生这个类别抽象的描述,这个抽象的描述称为“类”。在学校里的是学生个体,即张同学、李同学等,这些具体的个体称为“对象”,“对象”也称为“实例”。
面向对象,简称 OO(Object Oriented)
面向对象编程,简称OOP(Object Oriented Programming)
 
=================================
2.1 类和对象
Java中的类:
类描述了一组有相同特性(属性)和相同行为(方法)的一组对象的集合。
类是构造面向对象程序的基本单位,是抽取了同类对象的共同属性和方法所形成的对象或实体的“模板”。而对象是现实世界中实体的描述,对象要创建才存在,有了对象才能对对象进行操作。类是对象的模板,对象是类的实例。
比如:
每个人都有身高、体重、年龄、血型等属性。人会劳动、会直立行走、会用自己的头脑去创造工具等方法。人之所以能区别于其他类型的动物,是因为每个人都具有“人类”这个群体的属性与方法。“人类”只是一个抽象的概念,它仅仅是一个概念,是不存在的实体!但是所有具备“人类”这个群体的属性与方法的对象都叫人!这个对象“人” 是实际存在的实体!每个人都是“人”这个群体的一个对象
=================================
2.2 类和对象
Java中类的定义语法:
[public][abstract|final]class<class_name>[extends<class_name>][implements
<interface_name>] {
// 定义成员变量(属性)
[public|protected|private][static][final]<type><variable_name>;
// 定义成员方法(行为)
[public|private|protected][static]<void|return_type><method_name>([para
mList]) {
// 方法体
} …
}
说明:中括号“[]”中的部分表示可以省略,竖线“|”表示“或关系”,例如 abstract|final,说明可
以使用 abstract 或 final 关键字,但是两个关键字不能同时出现。
=================================
2.3 类和对象
定义类中各关键字的描述如下:
public:访问控制修饰符。public修饰,则可以被其他类和程序访问。
abstract:如果类被 abstract 修饰,则该类为抽象类。
final:如果类被 final 修饰,则不允许被继承。
class:声明类的关键字。
class_name:类的名称。
extends:表示继承其他类。
implements:表示实现某些接口。
property_type:表示成员变量的类型。
property:表示成员变量名称。
function():表示成员方法名称。
 
=================================
2.4 类和对象
Java中类定义成员变量的语法如下:
[public|protected|private][static][final]<type><variable_name>;
各参数的含义如下:
public、protected、private:用于表示成员变量的访问权限。
static:表示该成员变量为类变量,也称为静态变量。
final:表示将该成员变量声明为常量,其值无法更改。
type:表示变量的类型。
variable_name:表示变量名称。
=================================
2.5 类和对象
Java中类定义成员方法的语法如下:
[public|private|protected][fainal][static]<void|return_type><method_name>([
paramList]) {
// 方法体
}
各参数的含义如下:
public、private、protected:表示成员方法的访问权限。
static:表示该成员方法为静态方法。
final:表示该成员方法不能被重写或重载。
abstract:表示该成员方法为抽象方法,并且所属类必须为抽象类。
method_name:方法名称。
paramList:入参数列表
 
=================================
2.6 类和对象
Java中类的定义实例:
定义一个人的类,人的属性有姓名,年龄。行为有说话等。
使用Java类来定义描述,如下:
public class Person {
private String name; // 姓名(属性)
private int age; // 年龄(属性)
// 定义说话的方法(行为)
public void tell() {
System.out.println(name+"今年"+age+"岁!");
}
}
 
=================================
2.7 类和对象
Java类中的构造方法:
构造方法是类的一种特殊方法,用来初始化类的一个新的对象,每个类都有构造方法。如果没有显式地为类定义构造方法,Java编译器将会为该类提供一个默认构造方法。在创建对象的时候,至少要调用一个构造方法。一个类可以有多个构造方法。
Java构造方法有以下特点:
1,方法名必须与类名相同
2,可以有 0 个、1 个或多个参数
3,没有任何返回值,包括 void
4,默认返回类型就是对象类型本身
5,只能与 new 运算符结合使用
说明:构造方法可以使用private修饰,如果类中只有一个构造方法,并且使用private修饰,则在外部无法使用该类创建该类的实例对象
 

=================================
 
2.8 类和对象
this关键字:
this可用于任何实例方法内指向当前对象,也可指向对其调用当前方法的对象。
比如:this.属性名;this.方法名;this(); // this调用构造方法
注意:this( ) 不能在普通方法中使用,只能写在构造方法中。在构造方法中使用时,
必须是第一条语句。
this.属性名的使用场景:
大部分时候,普通方法访问其他方法、成员变量时无须使用 this 前缀,但如果方法里有个局部变量和成员变量同名,但程序又需要在该方法里访问这个被覆盖的成员
变量,则必须使用 this 前缀。
比如:在构造方法中使用this关键字:
public Person(String name,int age){
this.name = name;
this.age = age;
}
 
=================================
2.9 类和对象
对象的创建:
对象是对类的实例化。对象具有状态和行为,变量用来表明对象的状态,方法表明
对象所具有的行为。
在Java中,使用关键字new来创建一个新的对象。使用new关键词时会自动调用类
中的构造方法创建对象。
创建对象需要以下三步:
声明:声明一个对象,包括对象名称和对象类型。
实例化:使用关键字new来创建一个对象。
初始化:使用new创建对象时,会调用构造方法初始化对象。
例如:
Person persion = new Person("张三",20);
=================================
2.1.0 类和对象
访问对象的变量和方法:
在Java中对象被创建后则可以使用该对象来访问对象中的变量和方法。
语法如下:
对象名. 成员变量
// 访问对象的属性
对象名.成员方法名() // 访问对象的方法
例如:
Person persion = new Person("张三",20);
persion.tell(); // 访问对象的方法
说明:如果一个对象要被使用,则对象必须被实例化,如果一个对象没有被实例化
而直接调用了对象中的属性或方法则会导致程序异常
3.1 访问控制修饰符
在Java中,可以使用访问控制修饰符来保护对类、变量、方法和构造方法的访问。
类的访问控制符只能是空或者public,方法和属性的访问控制符有 4 个,分别是 pub
lic、private、protected和default ,其中default即默认,什么也不写。
访问控制修饰符的权限如下:
肖sir__Java API Java类和对象13

 

 3.2 访问控制修饰符

默认访问修饰符(不使用任何关键字)
使用默认访问修饰符声明的变量和方法,对同一个包内的类是可见的。
接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限
为 public。
如下例所示,变量和方法的声明可以不使用任何修饰符:
String version = "1.5.1";
boolean processOrder() {
return true;
}
 
3.3 访问控制修饰符
私有访问修饰符-private
被声明为private的方法、变量和构造方法只能被所属类访问,并且类和接口不能声明
为private。声明为私有访问类型的变量只能通过类中公共的方法被外部类访问。
例如下面的类使用了私有访问修饰符:
public class Logger {
private String format;
public String getFormat() {
return this.format;
}
public void setFormat(String format) {
this.format = format;
}
}
 
3.4 访问控制修饰符
公有访问修饰符-public
被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。
如果几个相互访问的 public 类分布在不同的包中,则需要导入相应 public 类所在的
包。
由于类的继承性,类所有的公有方法和变量都能被其子类继承。
以下函数使用了公有访问控制:
public static void main(String[] arguments) {
// ...
}
说明:
Java 程序的 main() 方法必须设置成公有的,否则,Java 解释器将不能运行该类。
3.5 访问控制修饰符
受保护的访问修饰符-protected
protected两种场景说明:
子类与基类在同一包中:被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问;
子类与基类不在同一包中:那么在子类中可以访问其从基类继承而来的 protected 方法,而不能访问基类实例的protected方法。
protected 可以修饰构造方法,方法成员,不能修饰类(内部类除外)。
接口及接口的成员变量和成员方法不能声明为 protected。
子类能访问 protected 修饰符声明的方法和变量,这样就能保护不相关的类使用这些
方法和变量
 
3.6 访问控制修饰符
访问控制修饰符和继承:
父类中声明为 public 的方法在子类中也必须为 public。
父类中声明为 protected 的方法在子类中要么声明为 protected,要么声明为
public,不能声明为 private。
父类中声明为 private 的方法,不能够被继承。
4.1 非访问控制修饰符
Java中非访问修饰符:
static 修饰符,用来修饰类方法和类变量。
final 修饰符,用来修饰类、方法和变量,final 修饰的类不能够被继承,修饰的方法不能被继承类重新定义,修饰的变量为常量,是不可修改的。
abstract 修饰符,用来创建抽象类和抽象方法。
synchronized 和 volatile 修饰符,主要用于线程的编程
 
4.2 非访问控制修饰符
static 修饰符
静态变量:
static 关键字用来声明独立于对象的静态变量,无论一个类实例化多少对象,它的静
态变量只有一份拷贝。
静态变量也被称为类变量。局部变量不能被声明为 static 变量。
静态方法:
static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。
静态方法从参数列表得到数据,然后计算这些数据。
对类变量和方法的访问可以直接使用 classname.variablename 和 classname.meth
odname 的方式访问
 
4.3 非访问控制修饰符
final 修饰符
final 变量:
final 表示"最后的、最终的"含义,变量一旦赋值后,不能被重新赋值。
被 final 修饰的实例变量必须显式指定初始值。
final 修饰符通常和 static 修饰符一起使用来创建类常量
final 方法:
父类中的 final 方法可以被子类继承,但是不能被子类重写。
声明 final 方法的主要目的是防止该方法的内容被修改。
final 类:
final 类不能被继承,没有类能够继承 final 类的任何特性。
 
4.4 非访问控制修饰符
abstract 修饰符,可以修饰类和修饰方法,
使用abstract修饰的类---抽象类:
抽象类不能用来实例化对象,声明抽象类的唯一目的是为了将来对该类进行扩充。
一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法,那么该类一定
要声明为抽象类,否则将出现编译错误。
抽象类可以包含抽象方法和非抽象方法。
使用abstract修饰的方法---抽象方法(是一种没有任何实现的方法)
抽象方法不能被声明成 final 和 static。
任何继承抽象类的子类必须实现父类的所有抽象方法,除非该子类也是抽象类。
如果一个类包含若干个抽象方法,那么该类必须声明为抽象类。抽象类可以不包含抽
象方法。
抽象方法的声明以分号结尾,例如:public abstract sample();
 
其他修饰符
synchronized 修饰符:
synchronized 关键字声明的方法同一时间只能被一个线程访问。
transient 修饰符:
该修饰符包含在定义变量的语句中,用来预处理类和变量的数据类型
volatile 修饰符:
volatile 修饰的成员变量在每次被线程访问时,都强制从共享内存中重新读取该成员
变量的值。
而且,当成员变量发生变化时,会强制线程将变化值回写到共享内存。
这样在任何时刻,两个不同的线程总是看到某个成员变量的同一个值。
 
5.1 包的定义和导入包
包的定义package:
Java 引入了包(package)机制,提供了类的多层命名空间,用于解决类的命名冲突、
类文件管理等问题。
包的 3 个作用如下:
1,区分相同名称的类。
2,能够较好地管理大量的类。
3,控制访问范围。
Java 中使用 package 语句定义包,package 语句应该放在源文件的第一行,在每个
源文件中只能有一个包定义语句,并且 package 语句适用于所有类型(类、接口、
枚举和注释)的文件。定义包语法格式如下:
 
 
5.2 包的定义和导入包
包语法格式如下:
package 包名;
Java 包的命名规则如下:
包名全部由小写字母(多个单词也全部小写)。
如果包名包含多个层次,每个层次用“.”分割。
包名一般由倒置的域名开头,比如 com.baidu,不要有 www。
自定义包不能 java 开头。
例如:com.dcs;
 
5.3 包的定义和导入包
导入包:
Java 引入了 import 关键字,import 可以向Java文件中导入指定包层次下的某个类或全部类。import 语句位于 package 语句之后,类定义之前。一个 Java 源文件只能包含一个 package 语句,但可以包含多个 import 语句。
使用 import 导入单个类的语法格式如下:
import 包名.类名;
例如:
import com.dcs.Person;
 
5.4 包的定义和导入包
导入包:
Java导入某个包下面所有的类。
使用 import 导入某个包所有类的语法格式如下:
import 包名.*;
例如:
import com.dcs.*;
说明:”*“代表一个包下面的所有类。使用星号(
*)可能会增加编译时间,特别是
引入多个大包时,所以明确的导入你想要用到的类可以减少编译世界。
5.5 包的定义和导入包
导入包:
在一些时候使用第三方包时,两个包种有相同名称的类,这个时候就需要通过类全名
来指定具体的类了。
使用类全名指定类,比如:
com.dcs.Person person = new com.dcs.Person();
说明:Java 默认为所有源文件导入 java.lang 包下的所有类,因此前面在 Java 程序
中使用 String、System 类时都无须使用 import 语句来导入这些类。
课后练习题
课后练习:
1,定义一个学生的类,
学生的属性:姓名,年龄,性别,身高,体重
定义一个体育项目类
体育项目类包含,打篮球和举重2个方法
学校要求
身高超过170cm的学生要打篮球,
所有学生中体重最重的人要举重
再定义一个主类,主类中包含身高比较的方法,体重比较的方法。
创建三个学生来测试
 
2.9 类和对象
程序员灯塔
转载请注明原文链接:肖sir__Java API Java类和对象13
喜欢 (0)