11.多态
1.多态:同一个对象拥有不同的形态。
2.先引出一个例子。
package com.itppf.dao;
public class Noodle {
public void cook(){
System.out.println("做一碗面条!");
}
}
package com.itppf.dao;
public class Rice {
public void cook(){
System.out.println("做一碗米饭!");
}
}
package com.itppf.dao;
public class Cookier {
public void cook(Noodle n){
n.cook();
}
public void cook(Rice r){
r.cook();
}
}
然后创建做饭的场景。
package com.itppf.dao;
public class Client {
public static void main(String[] args) {
Noodle n=new Noodle();
Rice r=new Rice();
Cookier c=new Cookier();//new一个厨师
c.cook(n);//让厨师做面条
c.cook(r);//让厨师做米饭
}
}
3.由上面的例子可知,无论是做米饭还是做面条都需要创建不同的方法,这样以来就十分繁琐,那么我们有没有方法能简化这一步操作呢?
答案是可以的,我们可以定义一个食物类,面条和米饭同属于食物。
为了更直观体现,再新建一个soup类
package com.itppf.dao;
public class Noodle extends Food{
public void cook(){
System.out.println("做一碗面条!");
}
}
package com.itppf.dao;
public class Rice extends Food{
public void cook(){
System.out.println("做一碗米饭!");
}
}
package com.itppf.dao;
public class Soup extends Food {
public void cook(){
System.out.println("做一碗汤!");
}
}
然后创建食物类
package com.itppf.dao;
public class Food {
public void cook(){
System.out.println("烹饪食物");//主要使用cook方法,这里写不写都行
}
}
创建厨师类
package com.itppf.dao;
public class Cookier{
// public void cook(Noodle n){
// n.cook();
// }
// public void cook(Rice r){
// r.cook();
// }
public void cook(Food food){ //接收传进来的食物类型,也就是接收实例化的食物值,然后让不同的食物去实现各自的方法。
food.cook();
}
}
创建做饭的场景
package com.itppf.dao;
public class Client {
public static void main(String[] args) {
// Noodle n=new Noodle();
// Rice r=new Rice();
//
// Cookier c=new Cookier();//new一个厨师
// c.cook(n);//让厨师做面条
// c.cook(r);//让厨师做米饭
Food food1=new Noodle(); //把面条、米饭、汤当做食物来看,把子类的对象赋值给父类的引用,向上转型。向下转型
//Noodle noodle=(Noodle)food1 强制转型、
Food food2=new Rice();
Food food3=new Soup();
Cookier cookier=new Cookier();
cookier.cook(food1);
cookier.cook(food2);
cookier.cook(food3);
}
}
练习:
4.根据类图,写游戏代练,其实和上面的例子一样,就是看你方法里面写什么。
//先根据UML图写出Game类
package com.itppf.entity;
public class Game {
public void start(){
System.out.println("开始游戏");
}
public void play(){
System.out.println("开始进入游戏");
}
public void end(){
System.out.println("结束游戏");
}
}
//LOL
package com.itppf.entity;
public class LOL extends Game {
public void play(){
System.out.println("开始玩LOL!");
}
}
//DNF
package com.itppf.entity;
public class DNF extends Game {
public void play(){
System.out.println("开始玩DNF!");
}
}
//CS
package com.itppf.entity;
public class CS extends Game {
public void play(){
System.out.println("开始玩CS!");
}
}
//玩家
package com.itppf.entity;
public class Player{
public void happy(Game game){
game.play();
}
}
//游戏场景
package com.itppf.entity;
public class GameClient {
public static void main(String[] args) {
Game game1=new DNF();
Game game2=new LOL();
Game game3=new CS();
Player player=new Player();
player.happy(game1);
player.happy(game2);
player.happy(game3);
}
}
12.final关键字
1.final:被final修饰的变量不可以被改变(无论是成员变量还是局部变量都不可改变),最终的,最后的,不可以被改变的。
2.被final修饰的方法不能够重写。
3.被final修饰的类不可以被继承。
举个例子
package com.itppf.entity;
public class Car {
public final void type(){
System.out.println("你的车是什么类型啊!");
}
}
13.抽象
1.在java中:只声明,不实现。
2.abstract修饰方法,这个方法就是一个抽象方法,抽象方法没有方法体。
3.类中如果有个抽象方法,这个类必须是一个抽象类,否则会报错。
4.抽象类的特点:
5.不可以创建对象,没有实例,不存在的东西。
6.抽象类的子类,必须重写父类中的抽象方法。
7.简单说明一下,抽象类继承父类的时候,由于父类中的方法是抽象方法,所以子类中的方法也是抽象方法,这时要求子类重写父类的方法才能够实现实例化。
注:父类是抽象类,子类不一定是抽象类。
如何让它不报错?
必须重写父类的方法。
重写之后不报错。
8.作用:通过抽象类可以强制要求子类中必须有哪些方法。
添加一个抽象方法shape()后,子类必须重写这个方法,否则会报错。
重写之后。
抽象类更多的是规范化的作用,在父类中定义抽象方法,然后在子类中必须去重写这些方法,然后利用多态性进行操作。
EG:1.抽象化的父类
package com.itppf.entity;
public abstract class Fruit {
public abstract void type();
public abstract void color();
}
2.两个子类继承父类并且重写方法。
package com.itppf.entity;
public class Peach extends Fruit{
public void type(){
System.out.println("这个水果的名字叫桃子!");
}
public void color(){
System.out.println("这个苹果的颜色是红色的!");
}
}
package com.itppf.entity;
public class Apple extends Fruit{
public void type(){
System.out.println("这个水果的名字叫苹果!");
}
public void color(){
System.out.println("这个苹果的颜色是红色的!");
}
}
3.售卖者
package com.itppf.entity;
public class Saler {
public void sale(Fruit fruit){ //这里接收参数,并且调用各自类中的方法。
fruit.type();
fruit.color();
}
}
4.售卖场景
package com.itppf.entity;
public class FruitClient {
public static void main(String[] args) {
Fruit fruit1=new Apple();
Fruit fruit2=new Peach();
Saler saler1=new Saler();
saler1.sale(fruit1); //这里将苹果的参数传到售卖者那里。
System.out.println("*******************");
saler1.sale(fruit2); //这里将桃子的参数传到售卖者那里。
}
}
8.注意:抽象类中可以添加别的方法,类似于
package com.itppf.entity;
public abstract class Fruit {
public abstract void type();
public abstract void color();
public void weight(){
System.out.println("这个水果很重!");
}
}
14.接口
1.接口是一种特殊的抽象类。
2.接口中所有的方法都是抽象方法,省略掉abstract。
3.接口使用interface来声明。
4.接口中的方法都是公开的,公共的。
5.能继承接口的只能是接口。
6.接口和类只能是实现关系。
笔记记到这里,学了抽象类之后突然明白了接口存在的意义。总结一下,就是标准化、规范化地定义一个东西,人人都能拿到接口去做自己的东西。
package com.itppf.dao;
public interface place {
public abstract void point();
}
package com.itppf.dao;
public class home implements place {
public void point(){ //必须要实现接口方法,其实就是重写。
}
}
继承和接口用法几乎差不多,接口也具有多态性。
接口可以把不相关的东西进行整合。
注:类只能单继承,但接口可以多实现。
注:接口里面的变量都是全局静态变量。
在接口里面定义了面积,然后去调用会报错。
在HomeTest中调用会报错。
因为被隐藏到的是
public static final int area=100;
这样可以打印出来
System.out.println(home1.area);
这个例子可以比较形象地展现接口。
package com.itppf.dao;
public interface Country {
public abstract void specificcountry();
}
package com.itppf.dao;
public interface Province {
public abstract void specificprovince();
}
package com.itppf.dao;
public interface Area {
public abstract void specificsize();
}
package com.itppf.dao;
public interface Type {
public abstract void specifictype();
}
package com.itppf.dao;
public class Place {
public void specificplace(){
System.out.println("你家具体在哪个地方?");
}
}
package com.itppf.dao;
//单继承,多实现。
public class Home extends Place implements Country,Province,Area,Type{
//类可以实现多个接口,而接口也可以被多个接口继承。
//这里要讲,你的家不仅仅在这个国家里面,而且在这个城市里面,或者定义大小,你家有多大?多态性的体现。
//重写了一个继承的父类和三个接口,一个是展示你居住地的省份,一个是国家,还有一个是居住面积。
@Override //表示这个方法是重写的
public void specificplace() {
// super.specificplace(); //super调用的是父类的方法。
System.out.println("你家居住的具体位置在哪里?");
}
@Override
public void specificsize() {
System.out.println("你家的居住面积多大?");
}
@Override
public void specificprovince() {
System.out.println("你家居住在哪个省份?");
}
@Override
public void specificcountry() {
System.out.println("你家居住在哪个国家?");
}
@Override
public void specifictype() {
System.out.println("你家是什么建筑风格?");
}
}
package com.itppf.dao;
public class HomeTest {
public static void main(String[] args) {
// Home home1=new Home();
// home1.specificpoint();
Home home1=new Home(); //从家的方面去看我家,创建对象“hom1”;
Type home2=new Home(); //从件筑风格的方面去看我家,创建对象“hom2”;(向上转型)
Area home3=new Home(); //从建筑面积的方面去看我家,创建对象“hom3”; (向上转型)
Province home4=new Home(); //从哪个省的方面去看我家,创建对象“hom4”; (向上转型)
Country home5=new Home(); //从哪个国家的方面去看我家,创建对象“hom1”;(向上转型)
//以上很好地展现出了java的多态性。
System.out.println("-----从家的方面去调用home1具体实例-----");
home1.specificplace();
home1.specifictype();
home1.specificsize();
home1.specificprovince();
home1.specificcountry();
System.out.println("*******");
System.out.println("-----从建筑风格的方面去调用home2具体实例-----");
// home2.specificplace();
home2.specifictype();
// home2.specificsize();
// home2.specificprovince();
// home2.specificcountry();
// 由上可知,在建筑风格的角度去调用,只能看到家里建筑风格,大小,国家,省份看不到
System.out.println("*******");
System.out.println("-----从建筑大小的方面去调用home3具体实例-----");
// home3.specificplace();
// home3.specifictype();
home3.specificsize();
// home3.specificprovince();
// home3.specificcountry();
// 由上可知,在建筑大小的角度去调用,只能看到家里建筑大小,风格,国家,省份看不到
System.out.println("*******");
System.out.println("-----从居住省份的方面去调用home4具体实例-----");
// home4.specificplace();
// home4.specifictype();
// home4.specificsize();
home4.specificprovince();
// home4.specificcountry();
// 由上可知,在居住省份的角度去调用,只能看到家里居住的省份,大小,国家,建筑风格看不到
System.out.println("*******");
System.out.println("* *");
System.out.println("* *");
System.out.println("*******");
System.out.println("-----从居住国家的方面去调用home5具体实例-----");
// home5.specificplace();
// home5.specifictype();
// home5.specificsize();
// home5.specificprovince();
home5.specificcountry();
// 由上可知,在居住国家的角度去调用,只能看到家里居住的国家,大小,风格,省份看不到
System.out.println("*******");
}
}
接口练习
综合以上,方案二比较好,类如果都实现了接口方法,则是实现类,否则都是抽象类。
方案一:
package com.itppf.dao;
public interface IDAO {
public abstract void connect();
public abstract void add();
public abstract void del();
public abstract void upd();
public abstract void sel();
}
package com.itppf.dao;
public class MysqlDAO implements IDAO{
@Override
public void connect() {
System.out.println("连接mysql");
}
@Override
public void add() {
System.out.println("增加数据");
}
@Override
public void del() {
System.out.println("删除数据");
}
@Override
public void upd() {
System.out.println("更新数据");
}
@Override
public void sel() {
System.out.println("查询数据");
}
}
package com.itppf.dao;
public class OrcaleDAO implements IDAO{
@Override
public void connect() {
System.out.println("连接Orcale");
}
@Override
public void add() {
System.out.println("增加数据");
}
@Override
public void del() {
System.out.println("删除数据");
}
@Override
public void upd() {
System.out.println("更新数据");
}
@Override
public void sel() {
System.out.println("查询数据");
}
}
package com.itppf.dao;
import com.sun.org.apache.xpath.internal.operations.Or;
import java.util.Scanner;
public class FirstClient {
public static void main(String[] args) {
System.out.println("你想要连接哪一个数据库");
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
if(n==1){
IDAO idao=new MysqlDAO();
idao.connect();
idao.add();
idao.del();
idao.upd();
idao.sel();
}else if(n==2){
IDAO idao=new OrcaleDAO();
idao.connect();
idao.add();
idao.del();
idao.upd();
idao.sel();
}
}
}
以上方案一可以看得出程序代码的复用性很差。
方案二:
package com.itppf.entity;
public interface IDAO {
public abstract void connect();
public abstract void add();
public abstract void del();
public abstract void upd();
public abstract void sel();
}
package com.itppf.entity;
public abstract class AbstractDAO implements IDAO {
@Override
public void add() {
System.out.println("增加数据");
}
@Override
public void del() {
System.out.println("删除数据");
}
@Override
public void upd() {
System.out.println("更新数据");
}
@Override
public void sel() {
System.out.println("查询数据");
}
}
package com.itppf.entity;
public class MysqlDAO extends AbstractDAO {
@Override
public void connect(){
System.out.println("连接mysql数据库!");
}
}
package com.itppf.entity;
public class OrcaleDAO extends AbstractDAO{
@Override
public void connect() {
System.out.println("连接orcale数据库!");
}
}
package com.itppf.entity;
import com.sun.xml.internal.bind.v2.model.core.ID;
import java.util.Scanner;
public class ScondClient {
public static void main(String[] args) {
System.out.println("你想连接哪个数据库?1-mysql 2-orcale");
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
//全局声明
IDAO idao=null;
if(n==1){
idao=new MysqlDAO();
}else if(n==2){
idao=new OrcaleDAO();
}
idao.connect();
idao.add();
idao.del();
idao.upd();
idao.sel();
}
}
方案二则是将公有的方法从接口里面抽出来,形成一个抽象类,然后子类继承父类并且将不同的部分进行重写。
注:java接口可以被继承,而且是多继承,但是只能是接口继承接口,类只能实现接口。一个接口可以继承另一个接口或多个,一个普通类可以实现多个接口。
15.成员变量初始值
1.java中的变量必须先声明,再赋值,最后才能使用。
2.java中的成员变量,在创建对象的时候,都会执行一次初始化的操作,默认一个初始值。
3.基本数据类型默认值都是0,引用数据类型默认值都是null,null表示的是占位符。
public class InitialValue {
byte b;
float f;
double d;
int i;
char c;
boolean bool;
short s;
long l;
String str;
InitialValue inital;
}
public class InitialTest {
public static void main(String[] args) {
InitialValue i=new InitialValue();
System.out.println("byte="+i.b);
System.out.println("float="+i.f);
System.out.println("double="+i.d);
System.out.println("int="+i.i);
System.out.println("char="+i.c);
System.out.println("boolean="+i.bool);
System.out.println("short="+i.s);
System.out.println("long="+i.l);
System.out.println("String="+i.str);
System.out.println("InitialValue="+i.inital);
}
}
16.object
1.object是基类,任何类都要继承自它。
2.我们写的类,即使不继承自父类,也会继承自它。继承的父类也是object的子类。
17.equals和==
1.==判断左右的数据是否相等。
2.object类提供的一种方法,判断两个对象是否相等。
public class Cow {
String name;
String color;
int age;
public Cow(String name,String color,int age){
this.name=name;
this.color=color;
this.age=age;
}
public static void main(String[] args) {
Cow cow1=new Cow("小黄","黄色",12);
Cow cow2=new Cow("小黄","黄色",12);
System.out.println(cow1==cow2);
System.out.println(cow1.equals(cow2));
}
}
输出:
false
false
3.”==”一般默认基本数据类型是否相等,判断两个内存的地址是否一致,这里new开辟了新空间,所以肯定不一致。
4.”equals”默认是object提供的方法。
public class Cow {
String name;
String color;
int age;
public Cow(String name,String color,int age){
this.name=name;
this.color=color;
this.age=age;
}
public boolean equals(Cow cow){
if(this.name==cow.name && this.color==cow.color){
return true;
}else{
return false;
}
}
public static void main(String[] args) {
Cow cow1=new Cow("小黄","黄色",12);
Cow cow2=new Cow("小黄","黄色",12);
// System.out.println(cow1==cow2);
System.out.println(cow1.equals(cow2));
}
}
输出:
true
5.上面代码中的”equals”是子类对于父类object方法的不满,然后行的扩展,然后进行重写。
if(this.name==cow.name && this.color==cow.color){ //这句中的条件可以写一个两个或者全部。
EG:举个例子,cow1和cow2只有名字一样其余都不一样,然后根据name判断是否相等?
public class Cow {
String name;
String color;
int age;
public Cow(String name,String color,int age){
this.name=name;
this.color=color;
this.age=age;
}
public boolean equals(Cow cow){
if(this.name==cow.name){
return true;
}else{
return false;
}
}
public static void main(String[] args) {
Cow cow1=new Cow("小黄","黑色",11);
Cow cow2=new Cow("小黄","黄色",12);
// System.out.println(cow1==cow2);
System.out.println(cow1.equals(cow2));
}
}
输出:
true
6.说明equals很灵活,纵使颜色和年龄都不同,然后根据name相等依然可以得出两者相同。
7.同理,只有年龄不同,依然可根据name&&color得出相同。
经典案例一:
package com.itppf;
public class Tiger {
public static void main(String[] args) {
String str1="老虎";
String str2="老虎";
System.out.println(str1==str2);
System.out.println(str1.equals(str2));
}
}
输出:
true;
true;
这里str1开辟了内存地址,str2发现一样后也指向了“老虎”。
经典案例二:
package com.itppf;
public class Tiger {
public static void main(String[] args) {
String str3=new String("老虎");
String str4=new String("老虎");
System.out.println(str3==str4);
System.out.println(str3.equals(str4));
}
}
输出:
false;//new String来引入(”老虎“),是不同的对象。
true;//两个字符串的内容是一致的。
练习模拟登陆。
import java.util.Scanner;
public class Login {
public static void main(String[] args) {
String username="admin";
String userpassword="admin";
Scanner scanner=new Scanner(System.in);
System.out.println("请输入用户名:");
String uname=scanner.nextLine();
System.out.println("请输入密码:");
String upassword=scanner.nextLine();
if (uname.equals(username) && userpassword.equals(upassword) ){
System.out.println("登陆成功");
}else{
System.out.println("登录失败");
}
}
}
这里涉及到一个问题,扫描仪调用的next()、nextInt()、nextLine()到底有什么区别?
1.他们的区别在于对于空格的处理方式不同,以及返回值不同。
2.使用nextLine()方法时,不将空格看做是两个字符串的间隔,而是看作字符串的一部分,返回时,它作为String类型一并返回。
3.使用next()方法时,将空格看作是两个字符串的间隔。
4.使用nextInt()方法时,与next()方法类似,只是它的返回值是int类型的,依旧将空格看作是两个输入的数据的间隔。
18.toString
1.toString()对一个对象字符串的表现形式。
2.java中建议对toString()方法进行重写,原本默认是方法是包名+类名+内存地址。
直接赋值:
package com.itppf.entity;
public class Dog {
String name="小黄";
String color="绿色";
int age=13;
public static void main(String[] args) {
Dog dog1=new Dog();
System.out.println(dog1);
System.out.println(dog1.toString());
}
}
突然我在这里意识到了一个问题,那就是:
直接赋值和使用构造方法有什么区别?
直接赋值内存地址和值都相同,构造方法赋值,内存地址不同,值同。直接赋值比较耗费内存,而使用构造方法可以起到懒加载的作用,创建对象后开始赋值。
使用构造方法:
package com.itppf.entity;
public class Dog {
String name;
String cllor;
int age;
public Dog(String name,String color,int age){
this.name=name;
this.cllor=color;
this.age=age;
}
@Override
public String toString() { //这是idea提供的自动重写方法。
return "Dog{" +
"name='" + name + ''' +
", cllor='" + color + ''' +
", age=" + age +
'}';
}
//public String toString(){ 这是我重写的构造方法。
// return "我的狗的名字叫:"+this.name+"我的狗的颜色是:"+this.color+"年龄:"+this.age;
//}
public static void main(String[] args) {
Dog dog2=new Dog("小黄","黄色",13);
System.out.println(dog2.toString());
}
}
这是idea提供的自动重写方法。
这是我重写的构造方法。
19.instanceof关键字
1.主要判断对象属于哪种类型的。
package com.itppf.entity;
public class Mouse extends Animal {
public static void main(String[] args) {
Animal animal=new Mouse();
//Animal animal=new Animal();这不是老鼠。
if(animal instanceof Mouse){
System.out.println("这是一只老鼠");
}else{
System.out.println("这不是老鼠");
}
}
}
20.参数传递的问题
1.值传递(java中就是值传递)。
2.引用传递。
package com.itppf.entity;
public class ChairTest {
public static void chang(Chair chair){
chair=new Chair("长椅子");
}
public static void main(String[] args) {
Chair chair=new Chair("短椅子");
chang(chair);
System.out.println(chair.name);
}
}
输出:
短椅子
package com.itppf.entity;
public class ChairTest {
public static void chang(Chair chair){
chair.name="长椅子";
}
public static void main(String[] args) {
Chair chair=new Chair("短椅子");
chang(chair);
System.out.println(chair.name);
}
}
输出:
短椅子
这里使用到了内存分析,需要画图分析。
总结:面向对象,上帝视角,把控全局。
1.类与对象:对象操作程序,类创建对象,类与对象就是对数据的封装。
2.构造:给对象设置属性值,出厂化的设置、(this表示当前类的对象,拿到这个对象内容、访问构造方法。super 调用自己类中父类的内容,子类和父类中重名的内容可以区分,调用父类的构造方法)。
3.访问权限:
4.继承:父类有的功能,子类可以进行扩展,简化开发。
5.多态:同一个对象有不同的形态,你可以是儿子,可以是爸爸,可以是弟弟。
6.抽象:abstract,抽象方法可以不写方法体,抽象类可以写抽象方法也可以写正常的方法,对子类的约束,必须重写抽象类中的抽象方法。
7.接口:特殊的抽象类,interface。能继承接口的必须是接口。类可实现接口,一个类可以实现多个接口,为了弥补java不能多继承,java可以多实现。
8.内存分析:
21.异常处理
编译异常:语法错误,编码错误。
1.运行异常:编译的时候是没有错误的,语法方面是绝对正确的,找的就是运行时候的错误。
2.抛异常:发现错误的时候,会创建一个错误的对象对错误进行收集,丢出错误对象的过程叫抛异常。
3.捕获异常:默认由JVM来捕获异常,对错误信息进行打印,JVM会终止程序的进行。
1.异常的分类:
Throwable是所有异常的根,所有的异常都继承自Throwable,类似于Object。
Error:系统级的错误。
RuntimeExpection:运行异常,不手动处理,出问题了处理,例子(车爆胎)。
其他Exception:必须要经过手动处理,例子(路障)。
2.异常处理try…catch
语法:
try{
尝试执行的代码;
}catch(Exception e){ //catch抓住,Exception类型的e来接收异常。
处理异常的代码;
}finally //无论是否出错,都要finally
举个例子
package com.itppf.entity;
public class YcTest {
public static void main(String[] args) {
try{
System.out.println(1/0);
}catch (Exception e){
e.printStackTrace(); //打印出错误,面向程序员。
System.out.println("程序出错了!"); //面向用户
}finally{
System.out.println("执行finally");
}
}
}
如果程序是对的呢?
finally:很有用,代码没有错,可以使用finally看到。
使用finally关闭文件,否则文件始终处于打开状态。
3.异常处理throws和throw
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class FileTest {
public static void read(){
InputStream inputStream=new FileInputStream(new File("hello,world!"));
}
}
第一种:try…catch
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class FileTest {
public static void read(){
try{
InputStream inputStream=new FileInputStream(new File("hello,world!"));
}catch (Exception e){
System.out.println("出错");
}finally{
System.out.println("结束");
}
}
}
第二种方法:代表当前异常不处理这个错误,扔出去,有人调用这个方法,谁调用谁处理。
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class FileTest {
public static void read() throws Exception{ //代表当前异常不处理这个错误,扔出去,有人调用这个方法,谁调用谁处理。。
InputStream inputStream=new FileInputStream(new File("hello,world!"));
}
public static void main(String[] args) {
try {
read();
} catch (Exception e) {
e.printStackTrace();
}
}
}
或者继续抛出。
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class FileTest {
public static void read() throws Exception{ //代表当前异常不处理这个错误,扔出去,有人调用这个方法,谁调用谁处理。。
InputStream inputStream=new FileInputStream(new File("hello,world!"));
}
public static void main(String[] args) throws Exception{
read();
}
}
这样一直抛,等于会抛给用户。
尽量能处理的问题不要抛给用户
4.自定义异常
直接继承Exception或者RuntimeException来实现自定义异常。
public class Person {
String name;
String gender;
public Person(String name,String gender){
this.name=name;
this.gender=gender;
}
}
public class Bathhouse {
public void manBathhouse(Person person) throws GenderException{
if(person.gender.equals("男")){
System.out.println("欢迎来到男浴室"); //如果是男,欢迎来到男浴室。
}else { //否则抛出异常
throw new GenderException("走错了");
}
}
}
//自己定义的必须继承Exception或者RuntimeException
public class GenderException extends Exception {
public GenderException(String msg){
super(msg); //调用父类的构造方法
}
}
public class GenderTest {
public static void main(String[] args) throws GenderException{
Person person1=new Person("张三","男");
Person person2=new Person("李四","女");
Bathhouse bathhouse=new Bathhouse();
// bathhouse. manBathhouse(person1);
bathhouse.manBathhouse(person2);
}
}
以上就是我跟这IT老男孩学习的面向对象的笔记,大多是我自己感悟,有的也不一定正确,希望大家批评指正。我觉得经过学习后基本了解了面向对象,以后需要学习的还有很多,数据结构以及数组,对接口,继承,封装,多态的深入了解,以及java的二十三种设计模式,加油吧。
笔记和代码已放到github上面:
笔记:https://github.com/FSDWNS/theory.git
代码:https://github.com/FSDWNS/java.git
【信息由网络或者个人提供,如有涉及版权请联系COOY资源网邮箱处理】
暂无评论内容