面向对象下java

最新推荐文章于 2024-06-19 15:09:37 发布

灭掉c与java

最新推荐文章于 2024-06-19 15:09:37 发布

阅读量141

点赞数

分类专栏： java 文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/laiyoumi/article/details/128403822

版权

java 专栏收录该内容

8 篇文章 1 订阅

订阅专栏

类的继承：使用extends关键字。子类在继承父类的时候，自动继承父类的成员，子类可以继承父类的成员变量和成员属性，子类可以自己创建自己的成员变量属性。

方法的重写：在子类中有时需要对继承的父类的方法进行修改。就叫重写。

super关键字：可以在子类中调用父类的成员。

final关键字：他的注意点用代码演示出来啦。

抽象类：

接口

打印不同的图形，饲养员喂养动物，多彩的声音，学生和老师，图形的面积与周长计算程序，研究生薪资管理。

编译是的异常和运行时候的异常，上网简单了解即可

自定义异常

类的继承：使用extends关键字。子类在继承父类的时候，自动继承父类的成员，子类可以继承父类的成员变量和成员属性，子类可以自己创建自己的成员变量属性。

注意：一个类只可以继承一个父类，多个类可以继承一个父类，java中可以多层继承。父类也可以有父类。子类不可以直接调用父类中的私有成员。只能单根继承。

子类的构造函数都默认调用父类的无参构造函数，如果子类构造函数第一句话为super（），就代表调用啦父类的无参构造函数。

继承的相关代码如下：

class Animal{
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	
}
class Dog extends Animal{
	
}




public class Example010 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Dog str=new Dog();
		str.setName("牧羊犬");
		str.setAge(30);
		System.out.println("名称："+str.getName()+"年龄："+str.getAge());
	}

}

class Animal{
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	
}
class Dog extends Animal{
	private String color;

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}
	
}




public class Example010 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Dog str=new Dog();
		str.setName("牧羊犬");
		str.setAge(30);
		str.setColor("黑色");
		System.out.println("名称："+str.getName()+"年龄："+str.getAge()+"颜色："+str.getColor());
	}

}

方法的重写：在子类中有时需要对继承的父类的方法进行修改。就叫重写。

重写父类的方法，除啦代码块，和权限不同，其他都相同。子类重写的方法的访问权限不能比父类的小，如父类的访问权限是public，子类的就不能是private

代码如下：

class Animal{
	void shou() {
		System.out.println("动物放出叫声");
	}	
}
class Dog extends Animal{
	void shou() {
		System.out.println("汪汪汪。。。");
	}
	
}




public class Example010 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Dog str=new Dog();
		str.shou();
	}

}

当父类中的方法被重写后，子类对象将无法对父类对象的该方法进行访问啦。这时就用到super。

super关键字：可以在子类中调用父类的成员。

他有两种使用方法，代码如下：

1.访问父类的成员变量：

class Animal{
	String name="牧羊犬";
	void shou() {
		System.out.println("动物放出叫声");
	}	
}
class Dog extends Animal{
	public void shou() {
		super.shou();
		System.out.println("汪汪汪。。。");
	}
	public void printName() {
		System.out.println("名字："+super.name);
	}
}
public class Example010 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Dog str=new Dog();
		str.shou();
		str.printName();
	}
}

2.访问父类中指定的构造方法：

class Animal{
	private String name;
	private int age;
	
	public Animal(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String info() {
		return "名称"+this.getName()+"年龄："+this.getAge();
	}
	}


class Dog extends Animal{
	private String color;
	public Dog(String name,int age,String color) {
		//调用啦父类有两个形参的构造方法
		super(name,age);
		this.setColor(color);
	}

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}	
	public String info() {
		return super.info()+"颜色"+this.getColor();
	}
	
}

public class Example010 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Dog str=new Dog("牧羊犬",3,"黑色");
		System.out.println(str.info());
	}
}

final关键字：他的注意点用代码演示出来啦。

1.他修饰的类不可以有子类

2.他修饰的方法不能被重写

3.它修饰的变量为常量，这个常量只能在声明的时候赋值，并且常量名全为大写的：

声明全局变量：

public static final INT i=2;

抽象类：

抽象方法与抽象类一样都需要 "abstract"关键字修饰。

抽象方法不可以使用private关键字修饰。

一个类有抽象方法，这个类必须是抽象类。

抽象类定义如下：

有抽象方法必须是抽象类，抽象方法只需要声明，如果一个非抽象类继承啦抽象类，那么这个类就要实现这个抽象类的全部的抽象方法。

代码如下：

abstract class Animal{
	abstract void shout();
	}


class Dog extends Animal{
	//如果一个非抽象类继承啦抽象类，那么这个类就要实现这个抽象类的全部的抽象方法。
	void shout() {
		System.out.println("汪汪汪...");
	}
}

public class Example010 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Dog str=new Dog();
		str.shout();
	}
}

接口

接口可以想象成一个纯的抽象类

作用：完成多继承

接口中的变量默认为全局变量，接口中的方法默认为抽象方法。接下来案例讲解接口的定义，以及接口的成员的调用。接口的实现类必须实现接口的所有方法

interface Animal{
	//设置啦全局常量，因为接口默认定义为全局常量
	int ID=1;
	String NAME="牧羊犬";
	//定义啦抽象方法,因为抽象方法默认public abstract,所以这里只需要写方法的类型和名字
	void shou();
	
	//定义啦静态方法
	static int getID() {
		return Animal.ID;
	}
	//定义抽象方法
	public void info();
}

interface Action{
	public void eat();
}


//接口的实现类必须实现接口的所有方法
class Dog implements Animal,Action{
	//重写Action中的抽象方法
	public void eat() {
		System.out.println("喜欢吃骨头");
	}
	
	public void shou() {
		System.out.println("汪汪....");
	}
	//重写Animal中的抽象方法
	public void info() {
		System.out.println("名称："+NAME);
	}
}

public class Example010 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//静态方法调用方式：只能通过接口名+方法名，的方式调用
		System.out.println("编号："+Animal.getID());
		//调用默认方法和抽象方法，只能通过接口实现类对象来调用：
		Dog str=new Dog();
		str.info();
		str.shou();
		str.eat();
		
		
	}
}

一个类既要实现接口，有继承父类的方法，使用案例：

interface Animal{

	public String NAME="牧羊犬";
	//定义啦抽象方法
	public void shou();
	//定义抽象方法
	public void info();
}

abstract class Action{
	//定义抽象方法
	public abstract void eat();
}


//接口的实现类必须实现接口的所有方法
class Dog extends Action implements Animal{
	//重写Action中的抽象方法
	public void eat() {
		System.out.println("喜欢吃骨头");
	}
	//重写Animal中的抽象方法
	public void shou() {
		System.out.println("汪汪....");
	}
	//重写Animal中的抽象方法
	public void info() {
		System.out.println("名称："+NAME);
	}
}

public class Example010 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//调用默认方法和抽象方法，只能通过接口实现类对象来调用：
		Dog str=new Dog();
		str.info();
		str.shou();
		str.eat();
		
		
	}
}

接口不可以继承抽象类，只可以继承接口。案例：

interface Animal{

	public String NAME="牧羊犬";
	//定义抽象方法
	public void info();
}
interface Color{
	public void black();
}

//接口继承啦其他的接口，这个相当于扩展了接口，把其他两个接口的方法集合到一起，并且自己也可以增加抽象方法
interface Action extends Animal,Color{
	//定义抽象方法
	public void shou();
}


//接口的实现类必须实现接口的所有抽象方法,
class Dog implements Animal{
	//重写Action中的抽象方法
	public void black() {
		System.out.println("黑色");
	}
	//重写Animal中的抽象方法
	public void shou() {
		System.out.println("汪汪....");
	}
	//重写Ac'ti'o'n中的抽象方法
	public void info() {
		System.out.println("名称："+NAME);
	}
}

public class Example010 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//调用默认方法和抽象方法，只能通过接口实现类对象来调用：
		Dog str=new Dog();
		str.info();
		str.shou();
		str.black();
		
		
	}
}

练习：

打印不同的图形，饲养员喂养动物，多彩的声音，学生和老师，图形的面积与周长计算程序，研究生薪资管理。

多态

多态就是不同对象在调用同一个方法时，表现出不同的功能。

实现多态有两种方法：

方法的重载，方法的重写。

案例：

package 第四章基础案例;



//抽象类
abstract class Animal{
	//定义抽象方法
	abstract void shou();
}

//下面定义两个类继承抽象类
class cat extends Animal{
	public void shou() {
		System.out.println("喵喵");
	}
}
class dog extends Animal{
	public void shou() {
		System.out.println("汪汪");
	}
}


public class example {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//向上转型
		Animal str=new cat();
		Animal str1=new dog();
		//表现出啦shou方法的不同功能，使用Animal类型的对象，调用各自类中的shou方法
		str.shou();
		str1.shou();

	}

}

对象类型的转换

这个分为两种：

向上转型：子类对象转成父类对象。

注意：发生向上转型，所调用的方法一定是被子类重写的方法。str1不可以调用子类dog中的eat方法，因为不是重写的方法，没有在父类里面定义

例子：

package 第四章基础案例;




class Animal{
	public void shou() {
		System.out.println("喵喵");
	}
	
}

class dog extends Animal{
	public void shou() {
		System.out.println("汪汪");
	}
	public void eat() {
		System.out.println("吃骨头");
	}
}


public class example {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//向上转型
		dog str=new dog();//创建子类dog的对象
		//向上转型
		Animal str1=str;
		//发生向上转型，所调用的方法一定是被子类重写的方法。str1不可以调用子类dog中的eat方法，因为不是重写的方法，没有在父类里面定义
		str1.shou();
		

	}

}

向下转型：

.父类对象转换成子类对象

他的前提是：必须先发生向上转型。

案例讲解：

package 第四章基础案例;
class Animal{
	public void shou() {
		System.out.println("喵喵");
	}
	
}

class dog extends Animal{
	public void shou() {
		System.out.println("汪汪");
	}
	public void eat() {
		System.out.println("吃骨头");
	}
}


public class example {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//向上转型
		Animal an=new dog();
		//发生向下转型
		dog dog=(dog)an;
		dog.shou();
		dog.eat();
		

	}

}

instanceof关键字

作用：判断一个对象是否是某个类的实例。是的话返回true。

使用方法：

package 第四章基础案例;
class Animal{
	public void shou() {
		System.out.println("喵喵");
	}
	
}

class dog extends Animal{
	public void shou() {
		System.out.println("汪汪");
	}
	public void eat() {
		System.out.println("吃骨头");
	}
}


public class example {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//向上转型
		Animal an=new dog();
		System.out.println("Animal an=new dog():"+(an instanceof Animal));
		System.out.println("Animal an=new dog():"+(an instanceof dog));
		Animal a2=new Animal();
		System.out.println("Animal an=new Animal():"+(a2 instanceof Animal));
		System.out.println("Animal an=new Animal():"+(a2 instanceof dog));
	}
}

Object类

它是所有类的父类，如果一个类没有用extends指明继承啦那个父类，那object就是他的父类。

他的常用方法：object类常用方法

方法toString()使用：

package 第四章基础案例;
class Animal{
	public void shou() {
		System.out.println("喵喵");
	}
	
}
public class example {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Animal a2=new Animal();
		System.out.println(a2.toString());
	}
}

也可以对这个方法重写：

package 第四章基础案例;
class Animal{
	public String toString() {
		return "喵喵";
	}
	
}
public class example {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Animal a2=new Animal();
		System.out.println(a2.toString());
	}
}

内部类

在一个类的内部定义类。内部类所在的类称为外部类

分类：成语，局部，静态，匿名内部类。

成员内部类

成员内部类可以访问外部类的所有成员。

使用案例：

package 第四章基础案例;

//这里是外部类
class outer{
	int m=0;
	void test1() {
		System.out.println("外部类成员方法test1()");
	}
	//定义成员内部类
	class inner{
		int n=1;
		void show1() {
			System.out.println("外部成员变量m="+m);
			//可以调用外部类的方法
			test1();
		}
		void show2() {
			System.out.println("内部成员方法show2()");
		}
	}
	//外部类方法
	void test2() {
		//访问内部类成员方法，变量
		inner inner=new inner();
		System.out.println("内部成员变量："+inner.n);
		inner.show2();
		
	}
	
}


public class example20 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		//实例化outer类
		outer outer=new outer();
		//实例化outer中的内部类inner的对象
		outer.inner inner=outer.new inner();
		inner.show1();
		outer.test2();
		
		
	}

}

局部内部类

他与局部变量一样，定义在成员方法中，有效范围只限在方法内部。

局部内部类可以访问外部类的成员变量和成员方法，但是局部内部类的成员方法，变量只能在所属方法里面访问。

案例：

package 第四章基础案例;

//这里是外部类
class outer{
	int m=0;
	void test1() {
		System.out.println("外部类成员方法test1()");
	}
	//外部类方法
	void test2() {
		//定义成员内部类
		class inner{
			int n=1;
			void show() {
				//访问外部类的成员变量
				System.out.println("外部成员变量m="+m);
				//可以调用外部类的方法
				test1();
			}
		}
		//访问局部内部类成员方法，变量
		inner inner=new inner();
		System.out.println("内部成员变量："+inner.n);
		inner.show();
		
	}
	
}


public class example20 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		//实例化outer类
		outer outer=new outer();
		//实例化outer中的内部类inner的对象
		outer.test2();
		
		
	}

}

静态内部类

用static修饰的内部类。他的功能：只能访问外部鳄梨的静态成员，通过外部类访问静态内部类成员时，可以跳过外部类直接访问静态内部类。

使用案例：

package 第四章基础案例;

//这里是外部类
class outer{
	static int m=0;
	//外部类方法
		//定义成员内部类
		static class inner{
			int n=1;
			void show() {
				//访问外部类的成员变量
				System.out.println("外部成员变量m="+m);
			}
		}	
}


public class example20 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		//实例化outer类
		outer.inner outer=new outer.inner();
		//实例化outer中的内部类inner的对象
		outer.show();
		
		
	}

}

匿名内部类

没有名称的内部类，在调用某个方法时，如果该方法的参数是接口类型，可以传入一个接口实现类，实现接口的方法。还可以使用匿名内部类作为该方法的参数，这个匿名内部类里面直接实现接口中的方法。匿名内部类是实现接口的一种简便的方法，对初学者而言，只需要了解他的语法即可。

下面看案例：

interface animal{
	void shou();
}



public class example23 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		String name="小米";
		
		
		//调用animalshou方法，在形参里面使用匿名内部类的定义。
		animalshou(
				//这个就是匿名内部类的定义方法，中括号里面就是对接口的shou方法。new animal相当于创建啦一个实例对象，并将实例对象作为参数传给animalshou方法。{}表示创建的对象为animal的子类实例。
				new animal() {
					@Override
					public void shou() {
						System.out.println(name+"喵喵。。。");
					}
				}
				
				
				);
	}
	
	//animalshou方法的参数为接口类型，可以使用匿名内部类为参数快速实现接口的方法
	public static void animalshou(animal an) {
		an.shou();
	}

}

异常

通过异常类的形势对非正常的情况进行封装，通过异常处理机制对程序运行时的错误进行处理。

大量的异常类都继承自Throwable类。throwable类有两个子类：一个是Error类，它是错误类，我们不怎么学他。另外一个是Exception类，它是异常类，我们重点学他。throwable类有三个常用方法。后面学习会提到。

try...catch和finally

try...catch用于异常捕获，在程序运行过程中，有时应为异常导致程序终止下来，就用这个让代码查找错误的类型。这个时候回退出程序。

案例使用：

package 面向对象程序思想下;

public class example25 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//定义一个try用于捕获异常,try的{}里面放可能会出现异常的代码段，当该代码段出现异常，就会执行catch{}中的代码。
		try {
			int result = divide(4,0);
			System.out.println(result);
			//下面定义catch，()里面需要参数需要指明异常类型，这个参数必须要是exception的子类
		}        catch(Exception e){
			System.out.println("捕获的异常信息为："+e.getMessage());
			
		}
		
		

	}
	public static int divide(int x,int t) {
		int result=x/t;
		return result;
	}

}

finally关键字：作用：当异常捕或后向继续执行程序段，就用它。无论是进入的try还是执行啦catch中的语句，都执行fainally中的语句。除非在执行finally语句前面执行啦System.exit(0)语句，则不执行finally语句中的代码，System.exit(0)表示退出当前的Java虚拟机。

使用案例：

package 面向对象程序思想下;

public class example25 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//定义一个try用于捕获异常,try的{}里面放可能会出现异常的代码段，当该代码段出现异常，就会执行catch{}中的代码。
		try {
			int result = divide(4,0);
			System.out.println(result);
			//下面定义catch，()里面需要参数需要指明异常类型，这个参数必须要是exception的子类
		}        catch(Exception e){
			System.out.println("捕获的异常信息为："+e.getMessage());
			
			
			//无论是进入的try还是执行啦catch中的语句，都执行fainally中的语句。
		}   finally{
			System.out.println("进入finally代码区域");
		}
		
		

	}
	public static int divide(int x,int t) {
		int result=x/t;
		return result;
	}

}

throws关键字：

用于声明某一个方法是否存在异常，以为别人的代码段不知道是否有异常，使用它就可以确定是否需要对该方法使用异常处理机制。使用它抛出异常后可以继续编译程序，但是没有对异常做处理程序就会异常终止。

下面通过程序讲解他的使用：

package 面向对象程序思想下;

public class example25 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//定义一个try用于捕获异常,try的{}里面放可能会出现异常的代码段，当该代码段出现异常，就会执行catch{}中的代码。
		try {
			int result = divide(4,0);
			System.out.println(result);
			//下面定义catch，()里面需要参数需要指明异常类型，这个参数必须要是exception的子类
		}        catch(Exception e){
			//打印捕获的异常信息
			e.printStackTrace();
		} 
	}
	//使用关键字声明出异常，throws关键字后面的异常类型可以有多个
	public static int divide(int x,int t) throws Exception{
		int result=x/t;
		return result;
	}

}

编译是的异常和运行时候的异常，上网简单了解即可

自定义异常

Java允许用户自定义异常，自定义异常定义时，必须是exception的子类。如下案例：

//自定义一个异常就相当与继承exception类定义一个新的类
public class exception21 extends Exception{
	//定义一个无参构造函数
	public exception21(){
		super();
	}
	//定义一个有参构造函数
	public exception21 (String message){
		super(messsage);
	}
	
	
}

用throw关键字声明异常的实例对象。案例讲解

通过这个案例讲解，可以确切是感受以上关键字的使用。

package 面向对象程序思想下;

public class example25 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//定义一个try用于捕获异常,try的{}里面放可能会出现异常的代码段，当该代码段出现异常，就会执行catch{}中的代码。
		try {
			int result = divide(4,-7);
			System.out.println(result);
			//下面定义catch，()里面需要参数需要指明异常类型，这个参数必须要是exception的子类
		}        catch(Exception e){
			//打印捕获的异常信息
			e.printStackTrace();
		} 
	}
	//使用关键字声明出异常，throws关键字后面的异常类型可以有多个
	public static int divide(int x,int t) throws Exception{
		if(t<0) {
			//用这个方式声明异常的实例对象
			throws new exception21("除数是负数");
		}
		int result=x/t;
		return result;
	}

}