1-1 介绍类与对象
类(class)和对象(object)是两种以计算机为载体的计算机语言的合称。对象是对客观事物的抽象,类是对对象的抽象。类是一种抽象的数据类型。
1.类与对象的定义
类是现实世界或思维世界中的实体在计算机中的反映,它将数据以及这些数据上的操作封装在一起。
对象是具有类类型的变量。类和对象是面向对象编程技术中的最基本的概念。
2.类与对象的关系
类是对象的抽象,而对象是类的具体实例。类是抽象的,不占用内存,而对象是具体的,占用存储空间。类是用于创建对象的蓝图,它是一个定义包括在特定类型的对象中的方法和变量的软件模板。
3.类与对象的关系
类是对象的抽象,而对象是类的具体实例。类是抽象的,不占用内存,而对象是具体的,占用存储空间。类是用于创建对象的蓝图,它是一个定义包括在特定类型的对象中的方法和变量的软件模板。
4.Java创建类的语法
pubilc class 类名{
//类的内容
}
1.类名要有直白意义,最好是英文。
2.首字母大写
3.不要数字开头,不要有特殊字符。
1-2 创建类与对象
1.创建类
在使用Java语言创建对象之前,首先要创建对象所属的类。Java语言使用关键字声明一个类。
声明一个类的完整语法是:
public class 类名{
//成员变量定义
//成员方法定义
}
其中“public”关键字是一种访问修饰级别,代表该类无论放在哪里都可以公开访问。
类是创建对象的模板,对象的属性在类中被定义为成员变量,对象的方法则被定义为成员方法。
行为定义:
方法为 public int length()
修饰符:
返回值的类型(void 表示无返回值)方法名(参数类型 参数名){
语句部分
}
2.创建对象
类型创建完毕后,就该创建该类型的对象了。Java语言中,使用关键字“new”创建一个类型的对象。
“引用”中保存的对象地址可以通过以下几种方式获取
1.new关键字返回
2.通过其他引用变量赋值得到
3.通过方法返回得到
对象创建完毕后,可以使用“.”操作符访问对象的成员,包括设置或取得成员变量的值。
public class Dog {
public static void main(String[] args) {
Dog duoduo =new Dog();
Dog lucky = new Dog();
}
1-3 成员变量
由static修饰的变量称为静态变量,其实质上就是一个全局变量。如果某个内容是被所有对象所共享,那么该内容就应该用静态修饰;没有被静态修饰的内容,其实是属于对象的特殊描述。
不同的对象的实例变量将被分配不同的内存空间, 如果类中的成员变量有类变量,那么所有对象的这个类变量都分配给相同的一处内存,改变其中一个对象的这个类变量会影响其他对象的这个类变量,也就是说对象共享类变量。
成员变量和类变量的区别:
1、两个变量的生命周期不同
成员变量随着对象的创建而存在,随着对象的回收而释放。
静态变量随着类的加载而存在,随着类的消失而消失。
2、调用方式不同
成员变量只能被对象调用。
静态变量可以被对象调用,还可以被类名调用。
3、别名不同
成员变量也称为实例变量。
静态变量也称为类变量。
4、数据存储位置不同
成员变量存储在堆内存的对象中,所以也叫对象的特有数据。
静态变量数据存储在方法区(共享数据区)的静态区,所以也叫对象的共享数据。
static 关键字,是一个修饰符,用于修饰成员(成员变量和成员函数)。
特点:
1、想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。
2、被静态修饰的成员,可以直接被类名所调用。也就是说,静态的成员多了一种调用方式。类名:静态方式。
3、静态随着类的加载而加载。而且优先于对象存在。
public class Dog {
String name; int age;
float weight;
public static void main(String[] args){
Dog duoduo=new Dog();
duoduo.name="多多";
duoduo.age = 6;
duoduo.weight =13.5f;
Dog lucky=new Dog();
lucky.name = "Lucky";
lucky.age =3;
lucky.weight =10.2f;
System.out.println(duoduo.name + "今天" + duoduo.age +"岁了");
System.out.println(lucky.name + "体重" + duoduo.weight +"千克");
}
}
1-4 方法的作用
Method类
Method类是最终类,不能继承。
是用于完成特定功能的整段代码。
public class MethodSample01{
public String isOddNumber(int num){
System.out.println("原始数据为:"+num);
if(num%2==0){
return "偶数";
}else{
return "奇数";
}
}
public static void main(String[] args) {
/* int a=10;
if(a%2==0){
System.out.println(a+"是偶数 ");
}else {
System.out.println(a+"是奇数");
}
int b=5;
if(b%2==0){
System.out.println(b+"是偶数");
}else{
System.out.println(b+"是奇数");
}*/
//在mian使用方法,先创建对象才能使用
int a=10;
MethodSample01 methodSample01=new MethodSample01();
String r1=methodSample01.isOddNumber(a);
System.out.println(a+"是"+r1);
int b=5;
String r2=methodSample01.isOddNumber(b);
System.out.println(b+"是"+r2);
}
}
第2章 面向对象特性之封装
2-1 包-Package
Java 中使用 package 语句定义包,package 语句应该放在源文件的第一行,在每个源文件中只能有一个包定义语句,并且 package 语句适用于所有类型(类、接口、枚举和注释)的文件。定义包语法格式如下:
package 包名;
Java 包的命名规则如下:
1.包名全部由小写字母(多个单词也全部小写)。
2.如果包名包含多个层次,每个层次用“.”分割。
3.包名一般由倒置的域名开头,比如 com.baidu,不要有 www。
4.自定义包不能 java 开头。
注意:如果在源文件中没有定义包,那么类、接口、枚举和注释类型文件将会被放进一个无名的包中,也称为默认包。在实际企业开发中,通常不会把类定义在默认包下。
package com.micheal.test
public class Test {
}
java解释器会将package中的.解释为目录分隔符/,也就是说该文件的目录结构为:...com/micheal/test/Test.java
那么package中的类的访问权限是怎么样的呢?在同一package中的类是可以互相访问的,比如:
//Test1.java
package test;
class Test1 {}
//Test2.java
package test;
public class Test2 {
public static void main(String[] args) {
Test1 t;
}
}
由于Test2与Test1在同一个package—test中,所以Test2能够直接调用Test1生成Test1的引用变量t;在命令行进行编译时,直接编译Test2.java即可:javac Test2.java(若没有进入Test1和Test2的目录,需在Test2前加上绝对路径)
若类在不同的package中,那么在一个类中要调用另一个package中的类(必须是public类,非public类不支持不同包间访问),需要在类名前明确加上package名称;不过,java中存在一个让java程序员偷懒的特性,叫做import关键字。使用import就可以在一个package中导入另一个package中的类,不过import和C语言和C++中的#include是不同的,import并不会在当前java文件中嵌入另一个package中的类的代码,只是告诉java文件,不属于该包的类能够到哪里去寻找而已:
package p1;
//import p2.Test2
public class Test1 {
public static void main(String[] args) {
p2.Test2 t;//Test2 t if we import p2.Test2 before;
}
}
2-2 访问修饰量
修饰类,变量,方法时:
public公共,任何地方都能使用;
private私有,只能在类中使用;
不加修饰词=default,包内其他类可以用;
protected继承,只能继承的子类可以使用;
访问修饰符:public protected default private
Java中,可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。
public:对所有类可见。使用对象:类、接口、变量、方法
protected:对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)
default (即默认,什么也不写): 在同一包内可见,不使用任何修饰符。使用对象:类、接口、变量、方法。
private: 在同一类内可见。使用对象:变量、方法。 注意:不能修饰类(外部类)
外部如何访问内部的私有成员变量 适用本类中的共有方访问本类中的私有成员变量。
public class PackageSample01 {
//public代表其他任何类都能访问成员变量
public String name;
//private代表只能在当前类中使用
private void sayHello(){
System.out.println("Hello World");
}
//不写修饰符代表是默认修饰符,只能被包中其他类访问
void sayGoodbye(){
System.out.println("Good bye!");
}
public static void main(String[] args) {
PackageSample01 packageSample01 = new PackageSample01();
packageSample01.sayHello();
}
}
2-3 面向对象特性之封装
封装(Encapsulation)面向对象三大特性之一。 封装的概念是将类的某些信息隐藏在类的内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问。 封装的好处是只能通过规定的方法访问数据,隐藏类的实例细节,方便修改和实现。
封装的概念是将类的某些信息隐藏在类的内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问。
封装的好处是只能通过规定的方法访问数据,隐藏类的实例细节,方便修改和实现。当我们使用一个类时只关注这个类能解决什么问题,并不关注这个类是如何实现的。
封装:
1.封装即隐藏功能的实现细节;
2.良好的封装代码更容易阅读和维护;
3.利用对象与方法是实现封装的直接途径。
2-4 对成员变量进行续写封装
对成员变量进行读写封装,是为了不允许用户修改某一些成员变量
对只允许读,不允许写的变量,只生成get方法,不生成set方法
public class MobileNumber {
private String owner;
private String areaCode;
private String mobileNumber;
//getter方法,用于读取成员变量的内容
//getter书写格式,public 成员变量类型 get 成员变量名(),PS:首字母大写
public String getOwner() {
//this关键字代表当前对象的...
return this.owner;
}
public String getAreaCode() {
//this关键字代表当前对象的...
return this.areaCode;
}
//setter方法,setter方法用于设置成员变量的内容
//setter书写格式:public void set成员变量名(新的数据参数)
public void setOwner(String owner) {
this.owner = owner;
}
public void setAreaCode(String areaCode) {
this.areaCode = areaCode;
}
}
public class MobileNumberTestor {
public static void main(String[] args) {
MobileNumber mobileNumber=new MobileNumber();
mobileNumber.setOwner("老奇");
String owner= mobileNumber.getOwner();
System.out.println(owner);
String areaCode=mobileNumber.getAreaCode();
System.out.println(areaCode);
}
}
第3章 面向对象特性之继承和多态
3-1 面向对象之继承
继承(英语:inheritance)是面向对象软件技术当中的一个概念。如果一个类别A“继承自”另一个类别B,就把这个A称为“B的子类别”,而把B称为“A的父类别”也可以称“B是A的超类”。继承可以使得子类别具有父类别的各种属性和方法,而不需要再次编写相同的代码。在令子类别继承父类别的同时,可以重新定义某些属性,并重写某些方法,即覆盖父类别的原有属性和方法,使其获得与父类别不同的功能。另外,为子类别追加新的属性和方法也是常见的做法。 一般静态的面向对象编程语言,继承属于静态的,意即在子类别的行为在编译期就已经决定,无法在执行期扩充。
优点 1.功能复用:将已有的属性和行为继承过来,实现功能的复用,节省了大量工作。
2.便于扩展功能:在已有功能的基础上,更容易建立、扩展新功能。
3.结构清晰,简化认识:同属于一个继承体系的相关类,他们之间结构层次清晰,简化了人们对代码结构的认识。
4.易维护性:不同类之间的继承关系,让事物之间保持一致性,大大降低了维护成本。
缺点
打破了封装性:父类向子类暴露了实现细节,打破了父类对象的封装性。
高耦合性:类与类之间紧密结合在一起,相互依赖性高。
public class Mark1 {
protected String title;
protected String color;
protected String movie;
public void description(){
System.out.println("型号:"+title);
System.out.println("颜色:"+color);
System.out.println("首次出现电影:"+movie);
}
private void fire(){
System.out.println("利用手臂燃料泵射出火焰");
}
public static void main(String[] args) {
Mark1 mark1=new Mark1();
mark1.color="银灰色";
mark1.movie="钢铁侠1";
mark1.title="马克1型";
mark1.description();
mark1.fire();
}
}
public class Hulk extends Mark1{
public static void main (String[] args) {
Hulk hulk = new Hulk();
hulk.title ="反浩克装甲";
hulk.color = "红色";
hulk.movie = "复仇者联盟3";
hulk.description();
}
}
3-2 面向对象特性之多态
public class Mark85 extends Mark1{
private void createShield() {
System.out.println("利用纳米技术生成防御护盾");
}
public static void main(String[] args) {
Mark85 mark85 = new Mark85();
mark85.title ="马克85型";
mark85.color ="红色";
mark85.movie ="复仇者联盟4";
mark85.description();
mark85.createShield();
}
}
多态的存在要有3个必要条件
(多态是指方法的多态,属性没有多态)要有继承;
要有方法重写;
父类引用指向子类对象。
多态的前提
1)要有继承或实现关系
2)要有方法的重写
3)要有父类引用指向子类对象
引用变量的两种类型:
编译时类型(模糊一点,一般是一个父类)由声明时的类型决定。
运行时类型(运行时,具体是哪个子类就是哪个子类)由实际对应的对象类型决定。
优点:提高程序的扩展性。定义方法时候,使用父类型作为参数,在使用的时候,使用具体的子类型参与操作
缺点:不能使用子类的特有成员
多态:同一个行为具有多个不同的表现形式或形态的能力,根据输入的内容不同,去产生不同的接口实现
实现多态的关键是接口
接口:是一个抽象的类型,只提供方法的定义
实现类:是一个借口的具体实现,要实现每一个接口方法的功能
一个接口可以拥有多个实现类
interface Language {
public void voice();
}
public class Chinese implements Language{
@Override
public void voice() {
System.out.println("你好,有什么可以帮到你的?");
}
}
public class English implements Language{
@Override
public void voice() {
System.out.println("Hi,may I help you?");
}
}
public class French implements Language{
@Override
public void voice() {
System.out.println("Comment puis-je me rendre a l'h pital");
}
}
public class CustomerService {
public static void main(String[] args) {
Language language = new English();
language.voice();
Language languagel = new Chinese();
languagel.voice();
Language language2 = new French();
language2.voice();
}
}
3-3 ArrayList列表类的使用
ArrayList类是List接口的实现,允许我们创建可调整大小的数组。
1.向列表添加数据
对象名.add();
对象名.add(索引位置,数据)// 像当前数组尾部添加数据
2、泛型:<>
List <数据类型> 对象名 = new ArrayList<数据类型>();
3、得到指定位置数据
对象名.get(索引位置);
4、获得列表的数值总数
对象名.size();
5、移除数据
对象名.remove(索引位置);
6、移除最后一项数据
对象名.remove(对象名.size()-1);
7、遍历列表所有数据
For( 数据类型 变量名 :列表名){
//循环体
}
import java.util.ArrayList;
import java.util.List;
public class ArrayListSample {
public static void main(String[] args) {
//泛型<类型>,用于规范列表中的数据
List<String> bookList=new ArrayList<String>();//创建ArrayList对象
bookList.add("红楼梦");//向列表末端追加数据
bookList.add("西游记");
bookList.add("水浒传");
bookList.add("三国志");
bookList.add("index:0,element“镜花缘");
System.out.println(bookList);
String bookName=bookList.get(2);//得到指定索引位置(从0开始)
System.out.println(bookName);
int size=bookList.size();//得到列表总数
System.out.println(size);
bookList.remove(2);
bookList.remove(bookList.size()-1);
System.out.println(bookList);
for (String book:bookList){
System.out.println("《"+book+"》");
}
}
}