对象的多态性:
abstract class Person{ private String name; private int age; Person(String name,int age){ this.setName(name); this.setAge(age); } public void setName(String name){ this.name = name; } public void setAge(int age){ this.age = age; } public String getName(){ return this.name; } public int getAge(){ return this.age; } public void say(){ System.out.println(this.fun()); } public abstract String fun(); } class Student extends Person{ private float point; public Student(String name,int age,float point){ super(name,age); this.setPoint(point); } public void setPoint(float point){ this.point = point; } public float getPoint(){ return this.point; } public String fun(){ return "学生信息:"+"\n姓名:"+super.getName()+ "\t年龄:"+super.getAge()+"\t成绩:"+this.getPoint(); } } class Worker extends Person{ private float salary; public Worker(String name,int age,float salary){ super(name,age); this.setSalary(salary); } public void setSalary(float salary){ this.salary = salary; } public float getSalary(){ return this.salary; } public String fun(){ return "工人信息:"+"\n姓名:"+super.getName()+ "\t年龄:"+super.getAge()+"\t工资:"+this.getSalary(); } } public class JavaDemo97{ public static void main(String args[]){ Person stu = new Student("李岩",24,99.5f); stu.say(); Person wkr = new Worker("李小岩",25,33333.33f); wkr.say(); } } |
接口的使用:通过对象的多态性,有子类为接口对象实例化。
interface A{ public void fun(); } class B implements A{ public void fun(){ System.out.println("BBBBBBBB"); } } public class JavaDemo98{ public static void main(String args[]){ A a = new B(); a.fun(); } } |
开发中优先使用接口,接口支持多继承。
interface USB{ public void start(); public void stop(); } class PC{ public static void plugin(USB u){ u.start(); u.stop(); } } class MP3 implements USB{ public void start(){ System.out.println("MP3开始工作了!!!"); } public void stop(){ System.out.println("MP3停止工作了!!!"); } } class UDisk implements USB{ public void start(){ System.out.println("UDisk开始工作了!!!"); } public void stop(){ System.out.println("UDisk停止工作了!!!"); } } public class JavaDemo99{ public static void main(String args[]){ PC.plugin(new MP3()); PC.plugin(new UDisk()); } } |
接口中都是抽象方法,则子类必须覆写接口中的全部抽象方法,如果子类不希望全部覆写呢?适配器设计模式:接口》抽象类》子类
interface A{ public void fun1(); public void fun2(); public void fun3(); } abstract class B implements A{ public void fun1(){} public void fun2(){} public void fun3(){} } class C extends B{//选择我想实现的方法,class C起到了适配器的作用 public void fun2(){ System.out.println("适配器操作模式!!!"); } } public class JavaDemo100{ public static void main(String args[]){ A a = new C(); a.fun2(); } } |
工厂设计模式:
interface USB{ public void start(); public void stop(); } class MP3 implements USB{ public void start(){ System.out.println("MP3开始工作了!!!"); } public void stop(){ System.out.println("MP3停止工作了!!!"); } } class UDisk implements USB{ public void start(){ System.out.println("UDisk开始工作了!!!"); } public void stop(){ System.out.println("UDisk停止工作了!!!"); } } class Factory{ public static USB getUSBInstance(){ //return new MP3(); return new UDisk(); //main()是一个客户端,当需要修改时在工厂内部完成 } } public class JavaDemo101{ public static void main(String args[]){ USB u = Factory.getUSBInstance(); u.start(); u.stop(); } } |
抽象类和接口都可以实例化,通过对象的多态性。
所有的类都必须继承自Object类,Java中大部分的类都是继承关系。
Object:是最大的类,所有类的父类,一切对象都可向Object类转型。
toString():在对象打印时默认调用,但默认情况下调用的是Object类中的toString(),如果一个类希望按照自己的方法打印对象,则可以覆写toString()。
//Object类是所有类的父类,如果一个类没有明确声明继承自哪个类 //则肯定会继承Object类 class Person //extends Object { public String toString(){ return "Object类中的toString()被覆写了!!!"; } } public class JavaDemo102{ public static void main(String args[]){ Person p = new Person(); // 默认情况下打印对象,实际上就相当于调用对象中的toString方法 //System.out.println(p.toString()); System.out.println(p); } } |
案例:为Person类中添加name和age属性,打印对象时,自动打印姓名和年龄。
class Person{ private String name; private int age; Person(String name,int age){ this.setName(name); this.setAge(age); } public void setName(String n){ this.name = n; } public void setAge(int a){ this.age = a; } public String getName(){ return this.name; } public int getAge(){ return this.age; } public String toString(){ return "姓名:"+this.getName()+"\t 年龄:"+this.getAge(); } } public class JavaDemo103{ public static void main(String args[]){ Person p = new Person("Rock",23); System.out.println(p);//Person类覆写Object类中的toString方法 } } |
equals():是一个对象比较的方法,在String类中调用的equals()肯定是已经被String类覆写的方法。根据自己的需要覆写equals()
class Person{ private String name; private int age; Person(){} Person(String name,int age){ this.setName(name); this.setAge(age); } public boolean equals(Object obj){ if (!(obj instanceof Person)){ //做一判断,防止类似于String类的匿名对象为obj初始化,确保obj为Person初始化 return false; } Person p2 = (Person)obj; if (this==p2){ return true;//判断是否是同一引用 } if (this.name.equals(p2.name)&&this.age==p2.age){ return true; }else{ return false; } } public void setName(String n){ this.name = n; } public void setAge(int a){ this.age = a; } public String getName(){ return this.name; } public int getAge(){ return this.age; } public String toString(){ return "姓名:"+this.getName()+"\t 年龄:"+this.getAge(); } } public class JavaDemo104{ public static void main(String args[]){ Person p1 = new Person("Rock",23); Person p2 = new Person(); p1 = p2; //Person p2 = new Person("Rock",23); System.out.println(p1.equals(p2)); System.out.println(p1.equals("Rock")); //字符串是匿名对象 String类和Person类没有关系 } } |
内部类:在一个类中定义一个类。格式:
class 外部类
{
class 内部类{}
}
class Outer{ private String info = "Rock Lee"; class Inner{//内部类 public void print(){ System.out.println("info = "+info); } } public void fun(){ new Inner().print(); } } public class JavaDemo105{ public static void main(String args[]) { Outer o = new Outer(); o.fun(); } } |
内部类可以节省代码,但是造成类的结构混乱。内部类本身也会产生*.class
案例:在类的外部直接去实例化内部类
class Outer{ private String info = "Rock Lee"; class Inner{//内部类 public void print(){ System.out.println("info = "+info); } } public void fun(){ new Inner().print(); } } public class JavaDemo106{ public static void main(String args[]) { Outer o = new Outer(); Outer.Inner in = o.new Inner(); in.print(); } } |
内部类可以在任何地方,如方法中:
class Outer{ private String info = "Rock Lee"; public void fun(final int len){//必须用final关键字,让内部类可以访问方法中的变量 class Inner{ public void print(){ System.out.println("len = "+len); System.out.println("intfo = "+info); } } new Inner().print(); } } public class JavaDemo107{ public static void main(String args[]){ new Outer().fun(10); } } |
在方法中的内部类要访问方法中的变量,则变量必须加final,但是此final并不表示一个常量,只是一个标记,一定要加上的标记。
匿名内部类:这个内部类只是用一次,一次之后就不用了,匿名内部类是在抽象类和接口上发展而来的。
interface A{ public void funA(); } class B implements A{ public void funA(){ System.out.println("Rock Lee"); } } class C{ public void funC(){ this.print(new B()); } public void print(A a){ a.funA(); } } public class JavaDemo108{ public static void main(String args[]){ new C().funC(); } } |
interface A{ public void funA(); } class C{ public void funC(){ this.print (new A()//匿名内部类 { public void funA() { System.out.println("Rock Lee"); } } ); } public void print(A a){ a.funA(); } } public class JavaDemo109{ public static void main(String args[]){ new C().funC(); } } |
包就是一个文件夹,包里面存放了大量的类,在使用类时必须有包。在同一文件夹下不能有重名的文件,多人开发中很难保重没有重名类,但可以见每个人开发的类放在不同的文件夹里。包定义格式:package 包名称;
package sky; class JavaDemo110{ public static void main(String args[]){ System.out.println("Rock Lee"); } } |
定义包之后就相当于包与类同时使用,定义一个类时,格式:包名.类名称
定义的类如果要位外部访问,必须声明为public class
格式:包的定义:package 包名称; 包的访问:import包名称
package demo1; import demo2.*;//*表示所有类 public class JavaDemo111{ public static void main(String args[]){ new JavaDemo112().print(); } } |
package demo2; public class JavaDemo112{ public void print(){ System.out.println("package demo ; JavaDemo112!!!!"); } } |
javac *.java:表示当前文件夹下的一切.java文件都进行编译
JDK提供了一个功能,可以根据定义的package自动生成class文件
格式:javac -d . JavaDemo113.java
-d:表示生成一个文件夹,文件夹的名称是package定义的
.:表示在当前文件夹下保存的文件
一个包可以有多个子包。
package sky.sky1.sky2;//用“.”定义子包 class JavaDemo113{ public static void main(String args[]){ System.out.println("Rock Lee"); } } |
public class含义:
1、类名称必须与文件夹名称一直
2、此类可以被外部的包所访问
在java中可以通过*进行集体导入,*是为了使用方便,程序会自动根据所需的类进行导入。
如果出现重名类的情况(在不同包中),则在使用重名类时要明确声明包的路径
import sky.*; import text.*; public class JavaDemo114{ public static void main(String args[]){ sky.JavaDemo115 j = new sky.JavaDemo115(); j.fun1();//类文件重名时,明确指出包路径 } } |
异常实际上是程序中错误导致中断了正常的指令流的一种事件,只要一出现异常程序就会中断。
public class JavaDemo116{ public static void main(String args[]){ System.out.println(1 / 0); } } |
异常在Java中称为throwable:
Error表示错误:JVM出错,程序无法运行
Exception表示异常:表示程序运行时出现的错误,可以由人为处理。
public class JavaDemo117{ public static void main(String args[]){ System.out.println("--------------异常发生之前---------------"); System.out.println(1 / 0); System.out.println("--------------异常发生之后---------------"); } } |
使用try...catch...表示程序出错之后可以向后继续运行。
public class JavaDemo118{ public static void main(String args[]){ System.out.println("--------------异常发生之前---------------"); try{ System.out.println(1 / 0);//可能出现异常的语句 System.out.println("********"); //一但出现了错误就不在执行try中的语句直接跳到catch语句 } catch (ArithmeticException ae){//出现的异常跟上ae对象 //如果try中没有出现异常则不会执行catch中的语句 System.out.println("发生了异常:"); System.out.println(ae); } System.out.println("--------------异常发生之后---------------"); } } |
特性:异常发生之后,发生异常代码之后的程序将不再被执行,当try中出现异常的时候才会执行catch中的代码,如果没有异常,则不会执行。
一个try语句后可以加入多个catch语句
public class JavaDemo119{ public static void main(String args[]){ System.out.println("--------------异常发生之前---------------"); try{//跑出的是一个异常类的实例化对象,这个对象去和catch中的参数进行匹配 System.out.println("第一个参数:"+args[0]); System.out.println(1 / 0); System.out.println("********"); } catch (ArithmeticException ae){ System.out.println("发生了异常:"); System.out.println(ae); } catch(ArrayIndexOutOfBoundsException abe){ System.out.println("发生了异常:"); System.out.println(abe); } System.out.println("--------------异常发生之后---------------"); } } |
如果一个程序中有多个异常?try抛出的是一个异常对象,而所有的异常类都是Exception的子类,可以简单的用Exception接受。
public class JavaDemo120{ public static void main(String args[]){ System.out.println("--------------异常发生之前---------------"); try{//跑出的是一个异常类的实例化对象,这个对象去和catch中的参数进行匹配 System.out.println("第一个参数:"+args[0]); System.out.println(1 / 0); System.out.println("********"); } catch(Exception e){ System.out.println("程序出错了:"); System.out.println(e); } System.out.println("--------------异常发生之后---------------"); } } |
try...catch....注意:try后可以跟多个catch,但catch中顺序和ACL一样,严格的放在前面,宽松的放在后面
public class JavaDemo121{ public static void main(String args[]){ System.out.println("--------------异常发生之前---------------"); try{//跑出的是一个异常类的实例化对象,这个对象去和catch中的参数进行匹配 System.out.println("第一个参数:"+args[0]); System.out.println(1 / 0); System.out.println("********"); } catch (ArithmeticException ae){//细致的条件方法在前面,像ACL System.out.println("发生了异常:"); System.out.println(ae); } catch(ArrayIndexOutOfBoundsException abe){ System.out.println("发生了异常:"); System.out.println(abe); } catch(Exception e){ //宽泛的条件方法在后面,如果细致的条件方法款放的条件后,将不会被执行 System.out.println("程序出错了:"); System.out.println(e); } System.out.println("--------------异常发生之后---------------"); } } |
finally:表示一个异常的统一出口,不管程序是否出现了异常,都必须执行finally代码。
public class JavaDemo122{ public static void main(String args[]){ System.out.println("--------------异常发生之前---------------"); try{ System.out.println("第一个参数:"+args[0]); System.out.println(1 / 0); } catch (Exception e){ System.out.println("发生了异常:"); System.out.println(e); } finally{//一般用于释放资源的链接 System.out.println("无论是否发生异常都要执行finall内的语句!!!"); } System.out.println("--------------异常发生之后---------------"); } } |
throws用在方法的声明出,表示此方法内部不处理异常,而是交给调用此方法处进行处理。
class Maths{ public int div(int i ,int j ) throws Exception{ //表示不处理异常,让客户端处理异常,谁调用我,谁处理我 return i / j ; } } public class JavaDemo123{ public static void main(String args[]){ try{ System.out.println(new Maths().div(10,0)); } catch (Exception e ){ System.out.println(e); } } } |
如果在main方法处编写了throws语句,则表示此异常交给JVM去处理,默认情况下,所有异常就是通过JVM处理的。
class Maths{ public int div(int i ,int j ) throws Exception{ return i / j ; } } public class JavaDemo124{ public static void main(String args[]) throws Exception{//把错误抛个JVM处理 System.out.println(new Maths().div(10,0)); } } |
异常抛出:不是出错产生的,而是人为抛出。
public class JavaDemo125{ public static void main(String args[]) { try{//本身抛出的就是一个异常类的对象 throw new Exception("自己跑出一个异常!!!"); } catch (Exception e){ System.out.println(e); } } } |
一般throw语句和if语句连用
class Maths{ public int div(int i ,int j ) throws Exception{ if (j == 0){ throw new Exception ("除数不能为零!!!"); } return i / j ; } } public class JavaDemo126{ public static void main(String args[]){ try{ System.out.println(new Maths().div(10,0)); } catch (Exception e ){ System.out.println(e); } } } |
包的访问权限:
public:最大的,公共方法问的
private:最小的,只能在本类中访问
defaut:默认的,只能在本包中访问
protected:本包,以及不同包的子类中可以访问
Java中的命名规则:
类:每个单词的首字母大写
方法:第一个单词首字母小写,之后每个单词的首字母大写
属性:第一个单词首字母小写,之后每个单词的首字母大写
常量:所有单词字母大写
包:所有单词小写 没有包的类是不存在的。