Java OOP第一至四章节

Java OOP第一至四章节

第一章 对象和封装

1.1理解面向对象

1.1.1为什么要使用面向对象

​ 面向对象就是采用"现实模拟"的方法设计和开发程序,面向对象技术利用"面向对象的思想"去描述"面向对象的世界",是客户和软件设计开发人员之间、软件设计开发人员内部交流更加顺畅,同时有代码重用性高,可靠性高等优点,大大提高了软件尤其是大型软件的设计和开发效率。

1.1.2面向过程和面向对象的区别

​ 面向过程:面向过程的核心是函数,已功能为中心,实现函数级别的代码重用。也就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候一个一个依次调用就可以了。面向过程中没有继续和多态的特征。

​ 面向对象:面向对象的核心是封装了属性和方法(行为)的类,以数据为中心,实现类级别代码的重用。也就是把构成问题事务分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描叙某个事物在整个解决问题的步骤中的行为。

1.1.3面向对象设计的过程

​ 面向对象设计的过程就是抽象的过程,分为以下三步:

​ 第一步:发现类

​ 第二步:发现类的属性

​ 第三步:发现类的方法

1.2使用面向对象

1.2.1创建类和对象

//创建狗狗类
public class Dog {
    public String name;//姓名
    public int health;//健康值
    public int love;//亲密度
    public String strain;//品种
	//输出信息
    public void print() {
        System.out.println("宠物的自白:\n我的名字叫"+this.name
                +"健康值是:"+this.health+",和主人的亲密度是"+this.love
                +",我是一只"+this.strain);
    }
}

//创建测试类
public class Test {
	public static void main(String[] args) {
        //创建狗狗对象赋值
		Dog dog =new Dog();
		dog.name="酷酷";
		dog.strain="拉布拉多犬";
         dog.love=100;
         dog.health=100;
		dog.print();//输出狗狗对象
    }
}

​ (1)Java中创建对象、调用属性及方法的语法和C#中是相同的。

​ 通过构造方法来创建对象,如:

Dog dog = new Dog();创建狗狗对象

​ 通过对象名.属性名的方式调用属性,如:

dog.name="酷酷";//给属性赋值

​ 通过对象名.方法名的方式调用方法,如:

dog.print();//调用输出方法

​ (2)类和对象是面向对象的两个核心概念,类是对某一类事物的描述是抽象的,对象是实际存在的,具体的事物个体。

1.2.2构造方法及其重载

​ (1)构造方法

​ 构造方法是类的一种特殊的方法,它的主要作用是完成对新对象的初始化。构造方法有无参的构造方法和有参的构造方法。一个类可以定义多个不同的构造方法。

​ 构造方法的特点:

​ 1、方法名和类名相同

​ 2、没有返回值

​ 3、在创建一个类的新对象时,系统会自动的调用该类的构造方法完成对新对象的初始化。

​ (2)重载

​ 方法重载是指在一个类中定义多个同名的方法,但要求每个方法具有不同的参数的类型或参数的个数。

​ 方法重载的判断依据:

​ 1、必须在同一个类里

​ 2、方法名相同

​ 3、参数列表(方法参数的个数或参数类型)不同

​ 4、在使用this调用自身的其他构造方法时,只能作为第一条语句

注:在使用this调用自身的其他构造方法时,只能作为第一条语句

​ (3)构造方法和重载例子

public class Penguin {
	String name;
	int health;
	int love;
	String sex;
	/**
	*无参构造方法
  	*/
  public Penguin() {
  	name="楠楠";
    health=100;
  	love=20;
  	sex="Q妹";
  	System.out.println("执行构造方法");
  }
	/**
	 * 有参数的构造方法
	 */
	public PenguinSL8(String name,int health,int love,String sex) {
		this.name=name;
		this.health=health;
		this.love=love;
		this.sex=sex;
	}
public void print() {
	System.out.println("宠物的自白:\n我的名字叫"+this.name
			+"健康值是:"+this.health+",和主人的亲密度是"+this.love
			+",性别"+this.sex);
}
    /**
     * 测试构造方法
     */
public static void main(String[] args) {
	Penguin pgn =null;
    //测试无参构造方法
	pgn =new Penguin();
	pgn.print();
    //测试有参构造方法
    pgn =new PenguinSL8("美美",80,20,"Q仔");
	pgn.print();
}

1.2.3static修饰符

​ (1)static的定义

​ static可以用来修饰属性、方法和代码块。把static修饰的属性和方法成为类属性(类变量)和类方法,不用static修饰的属性和方法属于单个对象,通常称为实例属性(实例变量)和实例方法;例如main()方法。

​ 语法:

访问修饰符 static 数据返回类型 方法名(){}

​ 例如:

public class StaticTest {
	static int i;
	static int m = 30;
	int j;
	int k=25;
	static {
		i=10;
		System.out.println("i的初始值为"+i);
	}
	public StaticTest() {
		j=20;
		System.out.println("j的初始值为"+j);
	}
	public static void getNum() {
		System.out.println("得到i的值为"+i);
	}
	public static void main(String[] args) {
		StaticTest st =new StaticTest();
		System.out.println("i的值为:"+StaticTest.i);
		st.getNum();
		System.out.println("m的值为:"+st.m);
		System.out.println("k的值为:"+st.k);
	}
}

​ (2)注意事项

​ 1、在方法里不可以定义static变量,也就是说类的变量不能是局部变量。

​ 2、构造方法没有返回值类型。如果有则不是构造方法,而是和构造方法同名的成员方法。

1.3封装

1.3.1什么是封装

​ 封装是面向对象的三大特征之一。封装的实质就是将类的状态信息隐藏在类的内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问。

1.3.2封装的运用

步骤:

1.修改属性的可见性

2.设置setter和getter方法

3.设置属性的存取限制

例如:

public class Dog10 {
	private String name ="无名氏";
	private int health=100;
	private int love=0;
	private String strain="聪明的拉布拉多犬";
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name=name;
	}
	public int getHealth() {
		return health;
	}
	public void setHealth(int health) {
		this.health=health;
	}
	public int getLove() {
		return love;
	}
	public void setLove(int love) {
		this.love=love;
	}
	public String getStrain() {
		return strain;
	}
	public void setStrain(String strain) {
		this.strain=strain;
	}
	
	public void print() {
		System.out.println("宠物的自白:\n我的名字叫"+this.name
				+"健康值是:"+this.health+",和主人的亲密度是"+this.love
				+",我是一只"+this.strain);
	}
}

1.3.3封装的好处

​ 隐藏类的实现细节,让使用者只能通过程序规定的方法来访问数据,可以方便加入存取控制语句,限制不合理操作。

1.3.4访问修饰符

​ 1、公开级别:用public修饰,对外公开,可以被同一个项目中的所有类访问具有项目可见性,这是最大的访问权限

2、受保护级别:用protected修饰,对子类和同一个包中的类公开,可以被同一个包中的类访问,被同一个项目中不同包中的子类访问

3、默认级别:没有修饰符号,向同一个包的类公开,成员变量和方法只能被同一个包里的类访问,具有包可见性

4、私有级别:用private修饰,只有类本身可以访问,不对外公开,成员变量和方法只能在某定义的类中被访问,具有类可见性

第二章 继承

1.1继承

1.1.1什么是继承

​ 继承是面向对象的三大特征之一,是代码重用的一种方式,将子类共有的属性和行为放到父类中,JAVA只支持单继承,即每一个类只有一个父类,子类与父类是is-a关系。

1.1.2继承的使用

​ (1)继承的语法:

修饰符  子类  extends  父类{
    //类定义部分
}

​ (2)Java继承举例

//父类
public class Pet {
	private String name="无名氏";
	private int health=100;
	private int love=0;
	/**
	 * 无参构造方法函数
	 */
	public Pet() {
		this.health=95;
		System.out.println("执行宠物的无参构造函数");
	}
	/**
	 * 有参构造方法
	 */
	public Pet(String name) {
		this.name=name;
	}
	public String getName() {
		return name;
	}
	public int getHealth() {
		return health;
	}
	public int getLove() {
		return love;
	}
	public void print() {
		System.out.println("宠物的自白:\n我的名字是:"+this.name
				+"我的健康值是:"+this.health+"我和主人的亲密程度是"+this.love);
	}
}
//子类
public class Dog extends Pet {
	private String strain;//品种
	/**
	 * 有参构造函数
	 */
	public Dog(String name,String strain) {
		super(name);//此处不要this
		this.strain=strain;
	}
	public String getStrain() {
		return strain;
	}
}

1.1.3 访问修饰符的访问权限

访问修饰符本类同包子类其他
private
默认(friendly)
protected
public

1.2重写和继承关系中的构造方法

1.2.1重写中的构造方法

​ (1)重写的定义:在子类中可以根据需求对从父类继承的方法进行重新编写,成为方法的重写或方法的覆盖。

​ (2)重写的特点:

​ 1、方法名相同

​ 2、参数列表相同

​ 3、不同的类

​ (3)举例:

//子类
public class Dog extends Pet {
	private String strain;//品种
	/**
	 * 有参构造函数
	 */
	public Dog(String name,String strain) {
		super(name);//此处不要this,访问父类name属性
		this.strain=strain;
	}
	public String getStrain() {
		return strain;
	}
    /**
	 *重写父类print()方法
	 */
	public void print() {
		super.print();//调用父类的print()方法
		System.out.println("我是一只"+this.strain);
	}
}

1.2.2重写和重载的区别

​ (1)重载涉及同一个类中的同名方法,要求方法名相同,参数列表不同,与返回值类型,访问修饰符无关

​ (2)重写涉及的是子类和父类之间的同名方法,要求方法名相同、参数列表相同、返回值类型相同(或是其子类)、访问修饰符不能严于父类

1.2.3继承关系中的构造函数

​ (1)继承下的构造方法

public class Test {
	public static void main(String[] args) {
		//创建对象dog并输出信息
		Dog dog=new Dog("欧欧","雪纳瑞");
		dog.print();
	}
}

​ (2)继承条件下构造方法的调用规则

​ 1、如果子类的构造方法中没有通过super显示调用父类的有参构造方法,也没有通过this显示调用自身的其他构造方法,则系统会默认先调用父类的无参构造方法

​ 2、如果子类的构造方法中通过super显示调用父类的有参构造函数,则执行父类相应的构造方法,而不执行父类无参构造函数

​ 3、如果子类的构造函数中通过this显示调用自身的其他构造方法,则在相应构造方法中应用以上两条规则

​ 4、如果存在多级继承关系,则在创建子对象时,以上规则会多次向更高一级父类应用,一直执行到顶级父类Object类的无参构造方法为止

注:在构造方法中如果有this语句或者super语句出现,则只能是第一条语句

1.3抽象类

1.3.1抽象类

​ (1)抽象类的定义:用abstract关键字来修饰一个类时,这个类就是抽象类。例如:

public abstract class Pet{} 

​ (2)抽象类的特点:

​ 1、抽象类不能被实例化

​ 2、一旦类包含了abstract抽象方法,则这个类必须声明为abstract抽象类。

​ 3、当一个子类继承的父类是abstract抽象类的话,需要把抽象类的抽象方法全部实现。

​ (3)举例:

//抽象类
public abstract class Pet {
	private String name="无名氏";
	private int health=100;
	private int love=0;
	/**
	 * 有参构造方法
	 */
	public Pet(String name) {
		this.name=name;
	}
	public String getName() {
		return name;
	}
	public int getHealth() {
		return health;
	}
	public int getLove() {
		return love;
	}
	/**
	 * 输出信息
	 */
	public void print() {
		System.out.println("宠物的自白:\n我的名字叫:"+this.name
				+"健康值是"+this.health+"和主人的亲密度是"+this.love);
	}
}

1.3.2抽象方法

​ (1)抽象方法的定义:用abstract关键字来修饰一个方法时,这个方法就是抽象方法。例如:

public abstract void print();

​ (2)抽象方法的特点:

​ 1、抽象方法没有方法体

​ 2、抽象方法必须在抽象类里

​ 3、抽象方法必须在子类中被实现,除非子类是抽象类

​ (3)举例:

public abstract class Pet {
	private String name="无名氏";
	private int health=100;
	private int love=0;
	/**
	 * 有参构造函数
	 */
	public Pet(String name) {
		this.name=name;
	}
	public String getName() {
		return name;
	}
	public int getHealth() {
		return health;
	}
	public int getLove() {
		return love;
	}
	/**
	 * 抽象方法
	 */
	public abstract void print();
}

1.4final修饰符

​ 使用final注意事项

​ 1、用final修饰的类不能再被继承

public final class Pet{}
public class Penguin extends Pet {}//出错

​ 2、用final修饰的方法不能被子类重写

public class Pet{
    public final void print(){}
}
public class Penguin extends Pet {
    public void print(){}//出错
}

​ 3、用final修饰的变量将变成常量,只能赋值一次

public class Pet{
    final String name="酷酷";
    public void setName(String name){
        this.name=name;//出错
	}
}

第三章 多态

1.1多态的定义

​ (1)多态:是具有表现多种形态能力的特征;更专业化的说法:同一个实现接口(引用类型),使用不同的实例而执行不同的操作。

​ (2)多态存在的三个必要条件:继承,重写,父类引用指向子类对象。

​ (3)实现多态的三个要素:

​ 1、编写具有继承关系的父类和子类

​ 2、子类重写父类方法

​ 3、使用父类的引用指向子类的对象

​ (4)实现多态的两种方式:继承和接口。

1.2实现多态

1.2.1使用父类作为方法返回值实现多态

public class Master {
	private String name="";//主人名字
	private int money=0;//元宝值
	public Master(String name,int money) {
		this.name=name;
		this.money=money;
	}
    public Pet getPet(int typeId) {
        Pet pet =null;
        if(typeId==1) {
            pet =new Dog("欧欧","雪纳瑞");
        }else if(typeId==2) {
            pet =new Penguin("楠楠","Q妹");
        }
        return pet;
    }
}
/**
*测试类
*/
public class Test{
	public static void main(String[] args) {
		Master master =new Master("王先生",100);
		Scanner input =new Scanner(System.in);
		System.out.println("欢迎来到宠物店");
		System.out.print("请选择你要领养的宠物类型(1、狗狗 2、企鹅)");
		int typeId =input.nextInt();
		Pet pet =master.getPet(typeId);
		if(pet!=null) {
			System.out.println("领养成功!");
		}else {
			System.out.println("对不起,没有此类型的宠物,领养失败!");
		}
	}
}

1.2.2使用父类作为方法形参实现多态

public class Master {
	private String name="";//主人名字
	private int money=0;//元宝值
	public Master(String name,int money) {
		this.name=name;
		this.money=money;
	}
	/**
	 * 主人给Dog喂食
	 */
	public void feed(Dog dog) {
		dog.eat();
	}
	/**
	 * 主人给Penguin喂食
	 */
	public void feed(Penguin penguin) {
		penguin.eat();
	}
	/**
	 * 主人给宠物喂食
	 */
	public void feed(Pet pet) {
		pet.eat();
	}
}
/**
*测试类
*/
public class Test {
	public static void main(String[] args) {
		Master master1 =new Master("王先生",100);
		Pet pet =new Dog("欧欧","雪纳瑞");
		//Pet pet =new Penguin("楠楠","Q妹");
		master1.feed(pet);
	}
}

1.3父类到子类的转换

1.3.1向下转型

​ (1)instanceof运算符

​ 语法:

对象  instanceof 类或接口

​ (2)例如:

public class TestPoly2 {
	public static void main(String[] args) {
		Pet pet =new Penguin("楠楠","Q妹");
		//Pet pet =new Dog("酷酷","雪纳瑞");
		pet.eat();
		if(pet instanceof Dog) {
			Dog dog =(Dog)pet;
			dog.catchingFlyDisc();
		}else if(pet instanceof Penguin) {
			Penguin pgn =(Penguin)pet;
			pgn.swimming();
		}
	}
}
1.3.2向上转型
public class Test14 {
    public static void main(String[] args) {
        Pet pet =new Dog("欧欧","雪纳瑞");//向上转型
        pet.eat();
    }
}

1.3.3强制转型

public class Test14 {
	public static void main(String[] args) {
		Pet pet =new Dog("欧欧","雪纳瑞");
		pet.eat();
		Dog dog =(Dog)pet;//强制类型转换成狗对象
		dog.catchingFlyDisc();
		Penguin pg =(Penguin)pet;//强制类型转换成企鹅对象
		pg.swimming();
	}
}

第四章 接口

1.1接口基础知识

1.1.1为什么需要接口

​ 接口可以被编写的多个程序重复调用,可以节省电脑的存储空间,并且使用接口可以减少电脑代码运行时出现的错误,在运行多个程序时,也能更有效率的进行。

1.1.2什么是接口

​ (1)接口:接口就是给出一些没有内容的方法,封装到一起,到某个类要使用的时候,在根据具体情况把这些方法写出来。

​ (2)实现接口的语法:

[访问修饰符] interface 接口名  extends 父接口1,父接口2.....{
    //常量定义
    //方法定义
}
class 类名 extends 父类名  implements 接口1,接口2.....{
    //类成员
}
//当类在继承父类的同时又实现了多个接口时,extends关键字必须位于implements关键字之前

​ (3)接口的特征:

​ 1、接口不可以被实例化,接口中不能有构造方法

​ 2、实现类必须实现接口的所有方法

​ 3、实现类可以实现多个接口

​ 4、接口中所有的方法都不能有主体

​ 5、接口中的变量都是静态常量(属性都是全局静态常量,方法都是全局抽象方法)

1.2Java接口的运用

1.2.1接口表示一种能力

​ 使用接口实现防盗门功能

//门
public abstract class Door {
	public abstract void open();//开
	public abstract void close();//关
}
//门铃接口
public interface DoorBell {
	void takePictures();//拍照存档功能
}
//锁,接口
public interface Lock {
	void lockUp();//上锁
	void openLock();//开锁
}
//防盗门类
public class TheftproofDoor extends Door implements Lock,DoorBell{	
	public void lockUp() {
		System.out.println("插进钥匙,向左旋转钥匙三圈,锁上了,拔出钥匙。");
	}
	@Override
	public void openLock() {
		System.out.println("插进钥匙,向右旋转钥匙三圈,锁打开了,拔出钥匙。");
	}
	public void open() {
		System.out.println("用力推,门打开了!");
	}
	public void close() {
		System.out.println("轻轻拉门,门关上了!");
	}
	public void takePictures() {
		System.out.println("铃......咔嚓.....照片已存储");
	}
}
//测试类
public class DoorTest {
	public static void main(String[] args) {
		//创建具体防盗对象
		TheftproofDoor tfd =new TheftproofDoor();
		tfd.close();//关门
		tfd.lockUp();//上锁
		tfd.takePictures();//来访客人拍照存储(示例11)
		tfd.openLock();//开锁
		tfd.open();//开没
	}
}

1.2.2接口表示一种定义

​ 使用接口实现打印机打印功能

//纸张的接口
public interface Paper {
	/**
	 * 得到纸张大小
	 */
	public String getSize();
}
//A4纸类
public class A4Paper implements Paper{
    public String getSize() {
        return "A4";
    }
}
//B5纸类
public class B5Paper implements Paper{
	public String getSize() {
		return "B5";
	}
}
//墨盒接口
public interface InkBox {
	public String getColor();
}

//彩色墨盒
public class ColorInkBox implements InkBox {
	public String getColor() {
		return "彩色";
	}
}
//黑白墨盒
public class GrayInkBox implements InkBox{
	public String getColor() {
		return "黑白";
	}
}
//打印机类
public class Printer {
	InkBox inkBox;//墨盒
	Paper paper;//纸张
	/**
	 * 设置打印机墨盒
	 * @param inkBox 打印使用的墨盒
	 */
	public void setInkBox(InkBox inkBox) {
		this.inkBox=inkBox;
	}
	/**
	 * 设置打印机纸张
	 * @param paper 打印使用的纸张
	 */
	public void setPaper(Paper paper) {
		this.paper=paper;
	}
	/**
	 * 使用墨盒在纸张上打印
	 */
	public void print() {
		System.out.println("使用"+inkBox.getColor()+
				"墨盒在"+paper.getSize()+"纸张上打印");
	}
}
//测试类
public class Test {
	public static void main(String[] args) {
		//定义打印机
		InkBox inkBox =null;
		Paper paper =null;
		Printer printer =new Printer();
		
		//使用黑白墨盒在A4纸上打印
		inkBox = new GrayInkBox();
		paper =new A4Paper();
		printer.setInkBox(inkBox);
		printer.setPaper(paper);
		printer.print();
		
		//使用彩色墨盒在B5纸上打印
		inkBox =new ColorInkBox();
		paper =new B5Paper();
		printer.setInkBox(inkBox);
		printer.setPaper(paper);
		printer.print();
		
		//使用彩色墨盒在A4纸上打印
		paper =new A4Paper();
		printer.setPaper(paper);
		printer.print();
	}
}

1.3在C#中使用接口

1.3.1C#定义接口

​ (1)语法:

[修饰符] interface  接口名  : 父接口1,父接口2,.....{
    //属性定义
    //方法定义
}
class 类名 : 父类名,接口1,接口2....{}

​ (2)注意事项:

​ 1、接口之间可以通过":"来实现继承关系,一个接口可以继承多个接口,但接口不能继承类

​ 2、类只能继承一个父类,但可以实现多个接口,使用":"来继承类并实现接口

​ 3、接口中成员访问修饰符时public,定义接口时显示指定任意修饰符都是非法的;按照惯例,C#中接口以大写字母“I“开头

1.3.2C#接口的运用

​ 使用接口实现打印机打印功能

namespace ConsoleApp1
{
    //墨盒接口
    public interface InkBox
     {
      	string Color { get; }
     }
    //纸张接口
    public interface Paper
      {
         string Size { get; }
      }
        //打印机类
        class Printer
        {
            InkBox inkBox;//墨盒
        public InkBox InkBox
        {
            set { inkBox = value; }
        }

        Paper paper;//纸张
        public Paper Paper
        {
            set { paper = value; }
        }
        //打印
        public void print()
        {
            Console.WriteLine("使用" + inkBox.Color + "墨盒在" + paper.Size + "纸上打印");
        }
        //彩色墨盒
        public class ColorInkBox : InkBox
        {
            public string Color { get { return "彩色"; } }
        }
        //黑白墨盒
        public class GrayInkBox : InkBox
        {
            public string Color { get { return "黑白"; } }
        }
        //A4纸张
        public class A4Paper : Paper
        {
            public string Size { get { return "A4"; } }
        }
        //B5纸张
        public class B5Paper : Paper
        {
            public string Size { get { return "B5"; } }
        }
        static void Main(string[] args)
        {
            //定义打印机
            InkBox inkBox = null;
            Paper paper = null;
            Printer printer = new Printer();
            //使用黑白墨盒在A4纸上打印
            inkBox = new GrayInkBox();
            paper = new A4Paper();
            printer.InkBox = inkBox;
            printer.Paper = paper;
            printer.print();
            //使用彩色墨盒在B5纸上打印
            inkBox = new ColorInkBox();
            paper = new B5Paper();
            printer.InkBox = inkBox;
            printer.Paper = paper;
            printer.print();
            //使用彩色墨盒在A4纸上打印
            paper = new A4Paper();
            printer.Paper = paper;
            printer.print();
            Console.Read();
        }
    }
}

1.4Java接口与抽象类的区别

(1)接口只能存在public成员,而抽象类可以存在public,private,protected,default成员。

(2)接口只能存在抽象方法,抽象类存在抽象方法和实例方法。

(3)接口只能存在静态常量,而抽象类可以存在实例成员。

(4)接口没有构造方法,而抽象类存在。

  • 1
    点赞
  • 0
    评论
  • 2
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值