Java面向对象基础

最新推荐文章于 2022-09-21 21:58:40 发布

Switchvov

最新推荐文章于 2022-09-21 21:58:40 发布

阅读量2.3w

点赞数 15

分类专栏： JavaSE 文章标签： java 面向对象面向对象编程 class 对象

如需转载，请联系本人获取许可且必须注明出处，详见联系方式。

本文链接：https://blog.csdn.net/q547550831/article/details/49664653

版权

JavaSE 专栏收录该内容

29 篇文章 1 订阅

订阅专栏

面向对象编程基础

1、类与对象

java语言是面向对象的

计算机语言的发展由面向机器向面向对象发展的，是越来越符合人的思维习惯的。

符合人类思维习惯程度

低 → 高

面向机器

汇编语言

面向过程

C语言

面向对象

Java语言

类和对象的关系

类是对象抽象出来的概念性的通用性的东西。

实例和对象的关系

(对象就是实例，实例就是对象)java最大的特点就是面向对象。

//定义类
public class Test{
	public static void main(String []args){
		//创建一个猫对象
		Cat cat1=new Cat();//Cat是定义的一个数据类型
		//Cat cat1;
		//cat1=new Cat();// 等同于 Cat cat1=new Cat();
		//访问属性的 对象名.属性名字
		cat1.age=3;
		cat1.name="小白";
		cat1.color="白色";

		//创建第二只猫
		Cat cat2=new Cat();
		cat2.age=100;
		cat2.name="小花";
		cat2.color="花色";  
	}
}
class Cat{
	//下面的就是类的成员变量/属性
	int agr;
	String name;
	String color;
}

类和对象的区别和联系

1、类是抽象的，概念的，代表一类事物，比如人类，动物类..

2、对象是具体的，实际的，代表一个具体事物，比如人类的对象“张三”..

3、类是对象的模板，对象是类的一个具体实例

类--如何定义类

一个全面的类定义比较复杂，如下：

package 包名;
class 类名 extends 父类 implements 接口名{
 	成员变量;
 	构造方法;
成员方法;
}

类--类的成员变量

成员变量是类的一个组成部分，一般是基本数据类型，也可是引用类型。

对象--如何创建对象

创建一个对象有两种方法

1、先声明再创建

1、对象声明：类名对象名

2、对象创建：对象名=new 类名()

如下：

Cat cat;
cat = new Cat();

2、声明创建一起

类名对象名=new 类名()

如下：

Cat cat = new Cat();

对象--如何访问(使用)对象的成员变量

对象名.变量名; //先这样理解，以后加下访问控制符此表达就不准确了。

如下：

cat.name = “小花”;

***对象总是存在内存中的(具体应该在系统分配给JVM的堆区)

类--类的成员方法定义

成员方法也叫成员函数。

public 返回数据类型 方法名(参数列表)
	{
		语句;//方法(函数)主体
	}

1、参数列表：表示成员方法的输入参数

2、返回数据类型：表示成员方法的输出

3、方法主体：表示实现某一功能的代码块

定义名字的规范写法：(PS:很多类型在之后的内容中会展示，这里做个总结)

类型	命名规范	关键字	举例
类名	首字母大写	class	MyClass
变量和方法	(除第一个单词外)首字母大写	int,byte,String等等	cat,myCat
包名	全小写	package	com.animal
常量	全大写(用下划线隔开)	final	PI,MY_CONST

除了上述驼峰法标准写法之外，还可以用下滑线法，如 my_class,my_cat

//方法名在有不同参数的情况下可以使用同一个方法名，即有参数和没参数的方法可以同名
class Person{ //请注意类名首写字母应为大写如Person为类名 
	int age;
	String name;
	//1、可以输出我是好人方法
	public void speak(){  //请注意方法名的首写字母应为小写如speak为方法名
		System.out.println("我是一个好人");
	}
	//2、可以计算1+..+1000的方法
	public void jiSuan(){
		int result=0;
		for(int i=1;i<=1000;i++){
			result=result+i;
		}
	System.out.println("1+..+1000结果是"+result);
	}
	//3、带参数的成员方法,可以输入n值并计算1+..+n
	public void jiSuan(int n){
		int result=0;
		for(int i=1;i<=n;i++){
			result+=i;
		}
		System.out.println("1+..+n结果是"+result);
	}
	//4、计算两个数的和
	public void add(int num1,int num2){
		int result=0;	//与下面一句等同于return num1+num2;
		result=num1+num2;
		System.out.println("num1+num2="+result);
	}
	//5、计算两个数的和，并将结果返回给主调(调用它的)方法
	//注意：返回类型和返回结果的类型要一致
	//注意：在调用某个成员方法的时候，给出的具体数值的个数
	//和类型要相匹配。
	public int add2(int num1,int num2){
		return num1+num2;
	}
	//6、计算两个float数的和，并将结果返给主调方法
	public float add3(int num1,float num2,float num3){
		return num1+num2+num3;
	}
}

类的成员方法--声明

public int test(int a);/*方法声明*/

这句话的作用是声明该方法，声明的格式为：

访问修饰符数据类型方法名(参数列表);

在给Person类添加add方法的例子中，关键字return的功能是把表达式的值返回的值返回给主调方法。

	return 表达式;

类的成员方法(函数)--特别说明

1、方法的参数列表可以是多个

参数列表可以是多个，并且数据类型可以是任意的类型int float double char..

访问修饰符 返回数据类型 方法名(参数列表){
		语句; //方法主体
	}

2、方法可以没有返回值

返回类型可以是任意的数据类型(int,float,double,char..)也可以没有返回值void表示没有返回值

访问修饰符 返回数据类型 方法名(形参列表){
		语句; //方法主体
}

2、构造方法(函数)

类的构造方法介绍

构造方法是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点：

1、方法名和类名相同

2、没有返回值

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

特别说明：

一个类可以定义多个不同的构造方法。

//定义一个人类
class Person{
	int age;
	String name;
	//自定义默认构造方法
	public Person(){
	}
	//构造方法的主要用处是：初始化你的成员属性(变量)
	//自定义带参数构造方法
	public Person(int age,String name){
		age=age;
		name=name;
	}
	//构造方法2
	public Person(String name){
		name=name;
	}
}

类的默认构造方法

如果没有定义构造方法，系统会自动生成一个默认构造方法。当创建Person对象时Person per1=new Person();默认的构造方法就会被自动调用。

类的构造方法小结：

1、构造方法名和类名相同；

2、构造方法没有返回值；

3、主要作用是完成对新对象的初始化；

4、在创建新对象时，系统自动的调用该类的构造方法；

5、一个类可以有多个构造方法；

6、每个类都有一个默认的构造方法。

3、this关键字

this是属于一个对象，不属于类的。java虚拟机会给每个对象分配this,代表当前对象。

注意事项：this不能在类定义的外部使用，只能在类定义的方法中使用。

/*	
	this的必要性
*/
public class Test{
	public static void main(String []args){
		Dog dog1=new Dog(2,"大黄");
		Person p1=new Person(dog1,23,"张三");
		Person p2=new Person(dog1,24,"李四");
		p1.showInfo();	
		p1.dog.showInfo();
	}
}
//定义一个人类
class Person{
	//成员变量
	int age;
	String name;
	Dog dog;//引用类型
	public Person(Dog dog,int age,String name){
		//可读性不好
		//age=age;
		//name=name;
		this.age=age; //this.age指this代词指定是成员变量age
		this.name=name; //this.name指this代词指定是成员变量name
		this.dog=dog;
	}
	//显示人名字
	public void showInfo(){
		System.out.println("人名是："+this.name);
	}
}

class Dog{
	int age;
	String name;
	public Dog(int age,String name){
		this.age=age;
		this.name=name;
	}
	//显示狗名
	public void showInfo(){
		System.out.println("狗名叫"+this.name);
	}
}

4、类变量、类方法

类变量

类变量是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量。

定义类变量：

访问修饰符 static 数据类型 变量名;

例如Person类中的

public static int num;

访问类变量：

类名.类变量名或者对象名.类变量名

例如

Person.num;

或者

Person person = new Person();
person.num;

类方法

类方法是属于所有对象实例的，其形式如下：

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

注意：类方法中不能访问非静态变量(类变量)。

使用：类名.类方法名或者对象名.类方法名

*重点*static静态的方法可以访问static静态变量(类变量)，不能访问非静态变量，非静态方法可以访问非静态变量同时也可以访问static静态变量(类变量)。

public class Test{
	public static void main(String []args){
		//创建学生对象
		Stu stu1=new Stu(29,"aa",340);
		Stu stu2=new Stu(29,"aa",240);
		System.out.println(Stu.getTotalFee());
	}
}

//学生类
class Stu{
	int age;
	String name;
	int fee;
	static int totalFee;
	public Stu(int age,String name,int fee){
		this.age=age;
		this.name=name;
		totalFee+=fee;
	}
	//返回总学费[这是一个类方法(静态方法)]
	//java中规则：类变量原则上用类方法去访问或操作
	public static int getTotalFee(){
		return totalFee;
	}
}

类变量小结

1、当某一属性是所有对象所公有(共用)的情况用类变量

2、类变量与实例变量区别：

加上static称为类变量或静态变量，否则称为实例变量

类变量是与类相关的，公共的属性

实例变量属于每个对象个体的属性

类变量可以通过 [类名.类变量名] 直接访问

类方法小结

1、当某一方法只使用或不使用静态变量(类变量)的情况用类方法

类方法属于与类相关的，公共的方法

实例方法属于每个对象个体的方法

类方法可以通过 [类名.类方法名] 直接访问

5、java面向对象编程的四大特征(抽象/封装/继承/多态)

抽象

把一类事物的共有的属性和行为提取出来，形成一个模型(模版)。这种研究问题的方法称为抽象。

封装

封装就是把抽象出来的数据和对数据的操作封装在一起，数据被保护在内部，程序的其它部分只有通过被授权的操作(成员方法)，才能对数据进行操作。

封装--访问控制修饰符

java提供四种访问控制修饰符号控制方法和变量的访问权限：

1、公开级别：用public修饰，对外公开

2、受保护级别：用protected修饰，对子类和同一个包中的类公开

3、默认级别：没有修饰符号，向同一个包的类公开

4、私有级别：用private修饰，只有类本身可以访问，不对外公开

4种访问级别的访问范围
访问级别	访问控制修饰符	同类	同包	子类	不同包
公开	public	√	√	√	√
受保护	protected	√	√	√	╳
默认	没有修饰符	√	√	╳	╳
私有	private	√	╳	╳	╳

包--必要性

包--三大作用

1、区分相同名字的类

2、当类很多时，可以很好的管理类

3、控制访问范围

包--导包命令

package com.自定义名字;

注意：导包命令一般放在文件开始处。

包--命名规范

小写字母比如 com.test

包--常用的包

一个包下，包含很多的类，java中常用的包有：

包名	作用
java.lang包	默认导入，提供了Java语言进行程序设计的基础类。
java.util包	提供了包含集合框架、日期和时间等各种实用工具类。
java.io包	通过文件系统、数据流和序列化提供系统的输入与输出
java.net包	提供实现网络应用与开发的类。
java.sql包	提供了使用Java语言访问并处理存储在数据库中的数据API。
java.awt包	提供了创建界面和绘制图形图像的所有类。
javax.swing包	提供了一组“轻量级”的组件。
java.text包	提供了与自然语言无关的方式来处理文本、日期、数字和消息的类和接口。

上表中的这些包，除了第一个包是自动导入外，其余的包都需要使用import语句导入，才可使用其包里面的类与接口。

包--如何引入包

语法：import 包;

比如import java.awt.*;

引入一个包的主要目的要使用该包下的类。

继承

继承--基础知识

继承可以解决代码复用，让编程更加靠近人类思维。当多个类存在相同的属性(变量)和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends语句来声明继承父类：

语法：class 子类 extends 父类

这样，子类就会自动拥有父类定义的某些属性和方法。

继承--深入讨论

1、

父类	子类
public 属性	继承
protected 属性
无修饰符属性
public 方法
protected 方法
无修饰符方法
private 属性	不继承
private 方法	不继承

2、结论

从表可以看出，父类的public修饰符的属性和方法；protected修饰符的属性和方法；默认修饰符属性和方法被子类继承了，父类的private修饰符的属性和方法不能被子类继承。

继承--注意事项

1、子类最多只能继承一个父类(指直接继承)

2、java所有类都是Object类的子类 (所有的子类都可以逐级继承，例:爷->父->子->孙)

多态

方法重载(overload)和方法覆盖(override)

在实现多态前，必须先弄明白方法重载(overload)和方法覆盖(override)。

方法重载(overload)

方法重载就是类的同一种功能的多种实现方式，到底采用哪种方式，取决于调用者给出的参数。

注意事项：

1、方法名相同

2、方法的参数类型，个数，顺序至少有一项不同

3、方法返回类型可以不同(只是返回类型不一样，不能构成重载)

4、方法的修饰符可以不同(只是控制访问修饰符不同，不能构成重载)

//方法重载(overload)getMax
public class Test{
	public static void main(String []args){
		MyMath mymath=new MyMath();
		System.out.println(mymath.getMax(12,14));
		System.out.println(mymath.getMax(24f,20f));
	}
}

class MyMath2{
	//返回较大的整数
	public int getMax(int i,int j){
		if(i>j){
			return i;
		}else{
			return j;
		 }
	}
	public float getMax(float a,float b){
		if(a>b){
			return a;
		}else{
			return b;
		 }
	}
}

方法覆盖(override)

方法覆盖就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，这就是子类的这个方法覆盖了父类的那个方法。

注意事项：

方法覆盖有如下条件：

1、子类的方法的返回类型，参数，方法名称，要和父类的返回类型，参数，方法名称完全一样，否则编译出错。

2、子类方法不能缩小父类方法的访问权限。

//子类方法覆盖父类方法
public class Test{
	public static void main(String []args){
		//创建一只猫
		Cat cat1=new Cat();
		cat1.cry();
		Dog dog1=new Dog();
		dog1.cry();
	}
}
//动物类
class Animal{
	int age;
	String name;
	//都会叫
	public void cry(){
		System.out.println("Animal not cry");
	}

}
//猫类
class Cat extends Animal{
	//覆盖父类方法
	public void cry(){
		System.out.println("Cat cry");
	}
}
//狗类
class Dog extends Animal{
	//覆盖父类方法
	public void cry(){
		System.out.println("Dog cry");
	}
}

多态--概念

多态是指一个引用(类型)在不同情况下的多种状态。也可以理解成：多态是指通过指向父类的指针，来调用在不同子类中实现的方法。

实现多态有两种方式：1、继承；2、接口

public class Test{
	public static void main(String[] args) {
		//多态
		Animal an=new Cat();
		an.cry();
		an=new Dog();
		an.cry();
	}
}
//动物类
class Animal{
	String name;
	int age;
	//动物会叫
	public void cry(){
		System.out.println("Animal not cry");
	}
}
//创建Dog子类并继承Animal父类及覆盖cry方法
class Dog extends Animal{
	//狗叫
	public void cry(){
		System.out.println("Dog cry");
	}
}
class Cat extends Animal{
	//猫自己叫
	public void cry(){
		System.out.println("Cat cry");
	}
}

多态--注意事项：

1、java允许父类的引用变量引用它的子类的实例(对象)

Animal an=new Cat();//这种转换时自动完成的

2、如果需要访问子类中父类没有的数据，需要强制转换为子类

Animal an=new Cat();//这种转换时自动完成的
Cat cat = (Cat)an;		//这是需要手动设置的

多态--补充

继承是多态得以实现的基础。从字面上理解，多态就是一种对象引用(类型)表现出多种状态。将一个方法调用同这个方法所属的主体(也就是对象或类)关联起来叫做绑定，分前期绑定和后期绑定两种。下面解释一下它们的定义：

1、前期绑定：在程序运行之前进行绑定，由编译器和连接程序实现，又叫做静态绑定。比如static方法和final方法，注意，这里也包括private方法，因为它是隐式final的。

2、后期绑定：在运行时根据对象的类型进行绑定，由方法调用机制实现，因此又叫做动态绑定，或者运行时绑定。除了前期绑定外的所有方法都属于后期绑定。

多态就是在后期绑定这种机制上实现的。多态给我们带来的好处是消除了类之间的偶合关系，使程序更容易扩展。

6、抽象类

当类的一些方法不能确定时，可以用abstract关键字来修饰该方法[抽象方法]，用abstract来修饰该类[抽象类]。

public class Test {
	public static void main(String[] args) {
		//Animal an=new Animal();抽象类不允许实例化
		Animal an=new Cat();
		an.cry();
		an=new Dog();
		an.cry();
	}
}
//抽象类abstract关键词
abstract class Animal{
	String name;
	int age;
	//动物会叫，使用了abstract抽象方法
	abstract public void cry();//抽象类中可以没有abstract抽象方法
	//抽象类内可以有实现方法
	public void sx(){
		System.out.println("实现方法");
	}
}
//当一个子类继承的父类是abstract抽象类的话，需要把抽象类的抽象方法全部实现。
class Cat extends Animal{
	//实现父类的cry
	public void cry(){
		System.out.println("Cat cry");
	}
}
class Dog extends Animal{
	//实现父类的cry
	public void cry(){
		System.out.println("Dog cry");
	}
}

抽象类--深入讨论

1、用abstract关键字来修饰一个类时，这个类就是抽象类。

2、用abstract关键字来修饰一个方法时，这个方法就是抽象方法。

3、abstract抽象类中的abstract抽象方法是不允许在抽象类中实现的，一旦实现就不是抽象方法和抽象类了。abstract抽象方法只能在子类中实现。

4、抽象类中可以拥有实现方法。

抽象类--注意事项

1、抽象类不能被实例化

2、抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract抽象方法。

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

4、抽象方法不能有主体。

正确的抽象方法例：abstract void abc();

错误的抽象方法例：abstract void abc(){}

7、接口

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

接口建立语法：

interface 接口名{方法;}

接口实现语法：

class 类名 implements 接口{
		方法;
		变量;
}

小结：

接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体。接口体现了程序设计的多态和高内聚低偶合的设计思想。

接口--注意事项

1、接口不能被实例化

2、接口中所有的方法都不能有主体。错误语法例：void aaa(){}，接口可以看作更加抽象的抽象类。

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

4、接口中可以有变量[但变量不能用private和protected修饰]

a、接口中的变量，本质上都是static的而且是final类型的，不管你加不加static修饰

b、在java开发中，经常把常用的变量，定义在接口中，作为全局变量使用

访问形式：接口名.变量名

5、一个接口不能继承其它的类，但是可以继承别的接口，而且可以多继承

6、当一个类实现了一个接口，要求该类把这个接口的所有方法全部实现

//USB接口
interface Usb{
public void start();
public void stop();
}
class Camera implements Usb{
	public void start(){
		System.out.println("我是相机，开始工作了..");
	}
	public void stop(){
		System.out.println("我是相机，停止工作了..");
	}
}
//编写了一个手机，并实现了usb接口
class Phone implements Usb{
	public void start(){
		System.out.println("我是手机，开始工作了..");
	}
	public void stop(){
		System.out.println("我是手机，停止工作了..");
	}
}
//计算机
class Computer{
	//开始使用usb接口
	public void useUsb(Usb usb){
		usb.start();
		usb.stop();
	}
}
public class Test{
	public static void main(String[] args) {
		//创建 Computer
		Computer computer=new Computer();
		//创建Camera
		Camera camera1=new Camera();
		//创建Phone
		Phone phone1=new Phone();
		computer.useUsb(camera1);
		computer.useUsb(phone1);
	}
}

实现接口VS继承类

java的继承是单继承，也就是一个类最多只能有一个父类，这种单继承的机制可保证类的纯洁性，比C++中的多继承机制简洁。但是不可否认，对子类功能的扩展有一定影响。

所以：

1、实现接口可以看作是对继承的一种补充。(继承是层级式的，不太灵活。修改某个类就会打破继承的平衡，而接口就没有这样的麻烦，因为它只针对实现接口的类才起作用)

2、实现接口可在不打破继承关系的前提下，对某个类功能扩展，非常灵活。

8、final关键字

final基本概念

1、final中文意思：最后的，最终的。

2、final可以修饰变量或者方法。

3、被final修饰的变量其数据就不能改变了，就成为了常量(const)。

在某些情况下，可能有以下需求：

1、当不希望父类的某个方法被子类覆盖(override)时，可以用final关键字修饰。

2、当不希望类的某个变量的值被修改，可以用final修饰。如果一个变量是final，则必须赋初值，否则编译出错。

3、当不希望类被继承时，可以用final修饰。

//final方法的使用
public class Test{
	public static void main(String[] args) {
		Aaa aaa=new Aaa();
		aaa.show();
		Bbb bbb=new Bbb();
		bbb.show();
	}
}
class Aaa{ 
//如果a不赋初值,a是0。定义类型后应赋值
	int a=0;	
//圆周率不让修改
	//带有final修饰的变量命名时应有_下划线来区分表示并且单词应该是全大写。
//需要强制不被修改的数据一定要用final锁定
	final float REATE_1=3.1415926f;

//使用final定义变量时一定要赋初值否则报错。
	//final int b;  
	//b=1;
	final public void sendMes(){//给成员方法用final来修饰则表示不可以被修改，不可被覆盖。
		System.out.println("发送消息");
	}
	public void show(){
		System.out.println("a="+a);
	}
}
final class Bbb extends Aaa{//定义类前加final表示该类不允许被继承
	public Bbb(){
		a++;
//不可以被修改
		//REATE_1+=1;
	}
	/*不能被覆盖
public void sendMes(){
		System.out.println("发送消息")
	}*/
}

final--注意事项

1、final修饰的变量又叫常量，一般用XX_XX_XX(大写)来命名。(带下划线)

2、final修饰的变量在定义时，必须赋值，并且以后不能再赋值。

final--什么时候用

1、类的某个方法不允许修改。

2、类不想被其它的类继承。

3、某些变量值是固定不变的，比如圆周率3.1415926

9、补充

初始化代码块与静态初始化代码块

public class Test{
	static int i=1;
	static{
		//该静态初始块只被执行一次
		i++;
		System.out.println("执行一次");
	}
	public Test(){  
		System.out.println("执行二次");
		i++;
	}
{
//该初始块每次创建对象被执行一次
i++;
		System.out.println("执行二次");

}
	public static void main(String []args){
		Test t1=new Test();  
		System.out.println(t1.i);

		Test t2=new Test();
		System.out.println(t2.i);
	}
}

结论：

1、静态代码块只会在类加载进内存时，被执行一次。

2、代码块会在每次创建对象被执行一次。

3、代码块的访问顺序是从上至下，依次访问。

----------参考《韩顺平.循序渐进学.java.从入门到精通》

----------参考《JDK_API_1_6_zh_CN》

Java学习笔记--导航http://blog.csdn.net/q547550831/article/details/49819641

Switchvov

关注

15
点赞
踩
46

收藏

觉得还不错? 一键收藏
4
评论
Java面向对象基础

面向对象编程基础1、类与对象java语言是面向对象的计算机语言的发展由面向机器向面向对象发展的，是越来越符合人的思维习惯的。符合人类思维习惯程度低 → 高面向机器汇编语言面向过程C语言面向对象Java语言类和
复制链接

扫一扫