目录
类的继承:使用extends关键字。子类在继承父类的时候,自动继承父类的成员,子类可以继承父类的成员变量和成员属性,子类可以自己创建自己的成员变量属性。
方法的重写:在子类中有时需要对继承的父类的方法进行修改。就叫重写。
打印不同的图形,饲养员喂养动物,多彩的声音,学生和老师,图形的面积与周长计算程序,研究生薪资管理。
类的继承:使用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;
}
}