面向对象

 

面向对象的实质就是一种认识事物的方法。，是一种以对象为中心的思维方式。

每个对象都有特征和属性两大要素，属性是对象静态特征的描述，行为是对象动态特征的描述。

类是具有相同属性和相同行为的对象集合。

类是对象的抽象，而对象是类的实例。

面向对象的三个主要特征：封装，继承，多态。

 

静态方法通常用于工具类，反复调用一个类用静态（申明为静态类）。

静态类直接用类名调用，（因为它们不要求创建类的实例），非静态的需要实例化后用引用名调用。

静态变量适合用于常量和对类的所有对象都公开的全局型变量。

 

 

 

 

类的实例化    类名 引用名=new 类的构造函数；

java是值传递，没有子传递。

构造方法与类名相同，可以不需要返回类型，返回当前类型，一般方法可返回任意类型。

写一个带参数的构造函数最好必须声明一个不带参数的构造函数。

全局变量所有的数值类型和字符型都被赋予的初始值为0，所有的逻辑型都初始化为false,所有的对象类都被初始化为空值。

 

继承

两个或者两个以上的类一旦拥有共有的方法且行为一致就抽象出来作为父类。

类不想被继承在 public 后面加 fianl.

如果一旦实例子类，它会首先实例父类的构造函数，如果实例父类，子类构造函数不会执行。

调用本类方法 用关键字this,调用父类方法用super

子类继承父类就是继承了父类所有共有的方法。

父类的构造函数不能被子类拥有。

任何子类都可以自由重写父类的方法（注：方法名必须和父类的方法名一样，并代替父类的方法被执行）

如果子类方法覆盖了父类的方法，那么在实例子类时，调用时执行的是子类重写的方法。

任何时候，将类作为字符串使用时，都会调用toString（）方法，并将该方法的结果返回给该字符串。

java中所有的类都是从java.lang.Object类继承而来。

对象之间的共同属性和行为被称为共性，他们属于共同的超类。

 

接口

接口使用关键字 interface 创建 例创建一个接口 public interface Jiekou{ }

所有接口都是 public 和abstract类型

接口包含属性，所有属性都是static 和final类型

接口天生就是抽象的,但是为了方便读懂，都在方法前面加abstra.其里面的方法都是抽象方法，而且必须都是未实现的方法.

实现接口用关键字 implements 例 public class Test implements Jiekou{ } ,实现接口必须实现接口里面的全部抽象方法。

多重继承

java使用接口实现多重继承

例 创建两个接口 实现多重继承

public interface T1{ } public interface T2{ } public class Test implements T1,T2{ }

接口只能有抽象方法，只规范类行为使用接口，抽象类可以有已实现和抽象方法。

用父类保存子类实例，用接口保存实现类的实例 称为动态绑定，是多态的一种表现形态。高类聚，低耦合。

 

异常

try{

} // 使用try 此处代码可能引发异常

catch(){

} // catch 捕获异常并进行处理

finally{

} // finally 块的目的是运行那些在try块里面无论运行成功与否都要执行的代码

一个try块后面可以跟零到多个catch块，如果没有catch块必须有一个finally块。

在catch块里return 语句 finally 优先return 执行。

 

 

java用关键字extends进行类与类之间的继承

具体语法如下：[public] [qualifiers] class A extends B;

public ：可带有值public或不带任何值，可确定软件包的访问权限。

qualifiers:合法的限定符有 final,abstract,static,也可以不带任何限制符

 

将类定义为final意味着该类不能被继承

例：public final class B{}

 

将类定义为abstract类型意味着该类必须带有子类，而该类本身不能被实例化，抽象类通常至少包含一个抽象方法。抽象方法不包含

方法体，该用分号结束声明。

例如：public abstract void shiLi();

 

private  方法和变量仅可以从该类的内部访问而不能从类的外部访问。

protected  方法和变量则可以从该类及其所有子类的内部访问，但不能从该类的外部访问。

最终结果是：如果将方法和变量声明为public,那么任何需要调用他们的代码包括其子类都可以访问这些方法和变量，如果将其定义为

private,则该类之外的任何代码包括其子类都无法访问这些方法和变量。

 

总结

 

通过继承，子类拥有父类的所有非私有成员。子类也可以继承父类的构造函数，遵循的原则：子类无条件地继承父类的不含参数的构造函数；如果子类自己没有构造函数，则它将继承父类的无参数构造函数作为自己的构造函数；如果子类自己定义了构造函数，则在创建新对象时，它将先执行继承父类的无参数构造函数，然后再执行自己的构造函数；对于父类的含参数构造函数，子类可以通过在自己构造函数中使用“super”关键字来调用它，但这个调用语句必须是子类构造函数的第一个可执行语句。

子类对继承自父类的类成员重新进行定义，就称为覆盖，要进行覆盖，就是在子类中对需要覆盖的类成员以父类中相同的格式，再重新声明定义一次。在子类中引用直接父类中的相应属性或方法，可以使用super关键字。

 

向子类添加属性和行为，从而定义超类不具备但子类具备的特殊行为。

允许同一超类的不同子类执行相同的行为，但具体的实现方式不同。

final意味着不能派生任何子类了。

abstract类型意味着该类必须带有子类。

不同的访问修饰符有不同的 访问权限级别

重写在有继承关系的不同类中发生，方法名，参数表和返回类型要一致。

重载在同一个类中发生，方法名相同，参数表不同。

不同的对象，收到同一消息可以产生不同的结果，这现象为多态性。

 

java里面数组没有length方法，只有length属性，字符串才有length（）方法，

String是赋值开辟一个新的内存空间

StringBuffer是修改统一内存空间的值

String s =“test”;

String s1=s;

s+="abc" ;

打印s1 是 test

因为声明变量s,为它开辟了一个新的内存空间，把它的值赋值给s1,这是两个变量同时指向堆内存里面的值test，当s+="abc"时重新为s开辟了新的内存空间

引用名放在栈内存，实际的值放在堆内存。

String s1="test";

String s3="test";

String s2=new String ("test")

String s4=new String("test")

s1.equals(s2) 比较的是s1和s2的值是否相同，比较的是堆内存里面的值

s1==s2比较的是指向的内存地址是否相同 比较的是栈内存。

静态方法是加载到静态内存域

继承简易代码示例：

写简易计算器

计算类

package chandeh;

import javax.swing.JOptionPane;

        public class Jisuan {

                 public double sum(double i,double j){

                     double sum1=i+j;

                    JOptionPane.showMessageDialog(null, sum1);

                    return sum1;

                }

                public double cha(double i,double j){

                     double cha1=i-j;

                    JOptionPane.showMessageDialog(null, cha1);

                    return cha1;

                 }

                public double ji(double i,double j){

                      double ji1=i*j;

                     JOptionPane.showMessageDialog(null, ji1);

                     return ji1;

                 }

                public double shang(double i,double j){

                      double shang1=i/j;

                     JOptionPane.showMessageDialog(null, shang1);

                      return shang1;

                 }

}

输入判断类

package chandeh;

import javax.swing.JOptionPane;

public class Start {

public double shuRu() {

Jisuan js = new Jisuan();

String str1 = JOptionPane.showInputDialog(null, "请输入一个数");

String str2 = JOptionPane.showInputDialog(null, "请输入第二个数");

String str3 = JOptionPane.showInputDialog(null, "请输入运算符,输入#退出循环");

double number1 = Double.parseDouble(str1);

double number2 = Double.parseDouble(str2);

                  if (str3.equals("+")) {

return js.sum(number1, number2);

} else if (str3.equals("-")) {

return js.cha(number1, number2);

} else if (str3.equals("*")) {

return js.ji(number1, number2);

} else if (str3.equals("/")) {

return js.shang(number1, number2);

} else if (str3.equals("#")) {

System.exit(0);

return 0;

} return 0;

}

}

开始类

package chandeh;

import javax.swing.JOptionPane;

  public class Kaishi {

public static void main(String[] args) {

Start st = new Start();

while (true) {

st.shuRu();

}

}

}

父类：

package people331;

public abstract class People {

public void eatRice(){

System.out.println("吃饭");

}

public void walk(){

System.out.println("行走");

}

public abstract void useTool();

}

子类1：

package people331;

 

public class Man extends People {

public void useTool() {

System.out.println("使用电脑");

}

public void superAbility(){

System.out.println("有超能力");

}

public void eatRice(){

System.out.println("吃大米饭");

}

public void print1(){

this.eatRice();

super.eatRice();

superAbility();

useTool();

} 

}

子类2：

package people331;

public class Woman extends People{

public void useTool() {

System.out.println("使用手机");

 

}

public void birthChild(){

System.out.println("生孩子");

}

}

开始类

package people331;

public class Start {

public static void main(String[] args) {

Woman m = new Woman();

//Man m=new Man();

//m.useTool();

 

m.useTool();

          }

}