Java面向对象（二）

source:http://blog.java1234.com/index.html?typeId=1

Java类的继承

1，继承定义以及基本使用

定义：子类能够继承父类的属性和方法；

注意点：Java中只支持单继承；私有方法不能继承；

2，方法重写

所谓方法的重写我们可以在子类中根据实际业务把父类的方法重写；

3，对象实例过程以及super关键字

对象实例化先实例化调用父类构造方法，再调用子类实例化构造方法；

super关键主要是调用父类方法或者属性；

/*** 动物类* @author user**/
public class Animal {private String name; // 姓名private int age;  // 年龄/*** 无参父类构造方法*/public Animal() {System.out.println("无参父类构造方法");}/*** 有参父类构造方法* @param name 姓名* @param age 年龄*/public Animal(String name,int age) {System.out.println("有参父类构造方法");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 void say(){System.out.println("我是一个动物，我叫："+this.name+",我的年龄是："+this.age);}
}/*** 定义一个Cat类，继承自Animal* @author user**/
public class Cat extends Animal{private String address;public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}public Cat() {super();System.out.println("子类无参构造方法");}public Cat(String name, int age,String address) {super(name, age);this.address=address;System.out.println("子类有参构造方法");}/*** 重写父类的say方法*/public void say(){super.say(); // 调用父类的say()方法System.out.println("我是一个猫，我叫："+this.getName()+",我的年龄是："+this.getAge()+"，我来自："+this.getAddress());}public static void main(String[] args) {Cat cat=new Cat("Mini",2,"火星");/*cat.setName("Mini");cat.setAge(2);*/cat.say();}
}

运行输出：

有参父类构造方法

子类有参构造方法

我是一个动物，我叫：Mini,我的年龄是：2

我是一个猫，我叫：Mini,我的年龄是：2，我来自：火星

final关键字

final是终结完结的意思；

使用final声明的类不能被继承；

使用final声明的方法不能被子类覆盖；

使用final声明的变量不能被修改，即为常量；

抽象类

定义：在java中，含有抽象方法的类称为抽象类，同样不能生成对象；

注意点：

1，包含一个抽象方法的类是抽象类；

2，抽象类和抽象方法都要用abstract关键字修饰；

3，抽象方法只需要声明而不需要实现；

4，抽象类必须被子类（假如不是抽象类）必须重写抽象中的全部抽象方法；

5，抽象类不能被实例化；

/*** 定义一个抽象类People* @author user**/
public abstract class People {private String name;public String getName() {return name;}public void setName(String name) {this.name = name;}public void say(){System.out.println("我的姓名是："+this.getName());}/*** 定义一个抽象方法 职业 让子类去具体实现*/public abstract void profession();}public class Student extends People{@Overridepublic void profession() {System.out.println("职业是：学生");}}public class Teacher extends People{@Overridepublic void profession() {System.out.println("职业是：老师");}
}public class Test {public static void main(String[] args) {Student student=new Student();student.profession();Teacher teacher=new Teacher();teacher.profession();}
}

运行输出：

职业是：学生

职业是：老师

接口

接口定义：一种特殊的“抽象类”，没有普通方法，由全局常量和公共的抽象方法所组成；

1，接口的定义

接口定义用关键字 interface，注意点：由于接口里的方法都是抽象的，所以abstract可以省略，实际开发一般都是省略的，开发者的习惯；

2，实现接口可以实现一个或者多个接口，实现接口我们用implements关键字；

3，继承类和实现接口先继承，后实现接口；

4，接口的继承接口可以多继承；

对象的多态性

多态性表现：

1，方法的重载和重写；

2，可以用父类的引用指向子类的具体实现，而且可以随时更换为其他子类的具体实现；

public class Animal {public void say(){System.out.println("我是一个动物");}
}
public class Cat extends Animal{public void say(){System.out.println("我是一个猫");}
}
public class Dog extends Animal{public void say(){System.out.println("我是一个狗");}
}
public class Test {public static void main(String[] args) {Dog dog=new Dog();dog.say();Cat cat=new Cat();cat.say();}
}

运行输出：

我是一个狗

我是一个猫

//多态测试，父类引用指向子类具体实现
public class Test {public static void main(String[] args) {// 父类引用指向Dog子类的具体实现Animal animal=new Dog();animal.say();// 更换实现animal=new Cat();animal.say();}
}

运行输出：

我是一个狗

我是一个猫

对象的转型：

向上转型：子类对象->父类对象安全

向下转型：父类对象->子类对象不安全

Object类

Object类是所有类的父类；

Object类的常用方法

1，public String toString() 返回该对象的字符串表示；

2，public boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”；

instanceof关键字

作用：判断一个对象是否属于一个类

格式：对象 instanceof 类返回布尔类型

public class Animal {public void say(){System.out.println("我是一个动物");}
}
public class Dog extends Animal{public void say(){System.out.println("我是一只狗");}
}
public class Cat extends Animal{public void say(){System.out.println("我是一只猫");}
}
public class Test {public static void main(String[] args) {Animal dog=new Dog();System.out.println("dog对象是否属于Animal类："+(dog instanceof Animal));System.out.println("dog对象是否属于Dog类："+(dog instanceof Dog));System.out.println("dog对象是否属于Cat类："+(dog instanceof Cat));}
}

运行输出：

dog对象是否属于Animal类：true

dog对象是否属于Dog类：true

dog对象是否属于Cat类：false

匿名内部类

类的内部再定义类；

匿名内部类这里指的是实例化内部对象就是没有名字的内部类；

作用：假如某个类只使用一次，则可以使用匿名内部类；

包装类

每个基本类型都有一个对应的类；就是所谓的包装类；

1，装箱和拆箱

基本类型和类类型可以相互转换；

基本类型到类类型的转换叫做装箱；

类类型到基本类型的转换叫做拆箱；

public static void main(String[] args) {int a=1;Integer i=new Integer(a); // 装箱int b=i.intValue(); // 拆箱System.out.println("a="+a);System.out.println("i="+i);System.out.println("b="+b);
}

运行输出：

a=1

i=1

b=1

2，自动装箱和拆箱

在类类型和基本类型的转换中，是自动转换的无需强制类型转换；

public static void main(String[] args) {Integer i=1; // 自动装箱的过程 自动把基本类型转换成类类型int i2=i; // 自动拆箱的过程 自动把类类型转成基本类型System.out.println("i="+i);System.out.println("i2="+i2);
}

运行输出：

i=1

i2=1

3，包装类的作用

因为包装类是类类型所有jdk里提供了很多有用的方法给我们用；

比如从用户界面来两个字符串数据a,b 然后我们程序里要进行相加运算。这时候包装类就派上用场了，我们可以用包装类的方法类进行类型转换。

public static void main(String[] args) {String a="3";String b="5";int m=Integer.valueOf(a); // 调用Integer类的valuesOf方法 把字符串类型转换成int类型int n=Integer.valueOf(b);System.out.println("a+b="+(m+n));
}

运行输出：

a+b=8

单例模式

在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在；

有两种实现，一种是饿汉式，一种是懒汉式；

public class Singleton {/*** 构造方法私有*/private Singleton(){}/*** 饿汉式单例实现*/private static final Singleton single=new Singleton();/*** 获取实例*/public static Singleton getInstance(){return single;}
}public class Singleton2 {/*** 构造方法私有*/private Singleton2(){}/*** 懒汉式单例实现 在第一次调用的时候实例化*/private static Singleton2 single;/*** 获取实例*/public synchronized static Singleton2 getInstance(){if(single==null){System.out.println("第一次调用的实例化");single=new Singleton2();}return single;}
}public class Test {public static void main(String[] args) {Singleton singleton1=Singleton.getInstance();Singleton singleton2=Singleton.getInstance();System.out.println("饿汉式："+(singleton1==singleton2));Singleton2 singleton3=Singleton2.getInstance();Singleton2 singleton4=Singleton2.getInstance();System.out.println("懒汉式："+(singleton3==singleton4));}
}

运行输出：

饿汉式：true

第一次调用的实例化

懒汉式：true

表示图形

//实现一个类，用来表示图形，定义方法，可以分别计算出矩形和圆形的面积和周长
/*** 图形接口* @author user**/
public interface Graphical {/*** 求面积方法* @return*/public float mianji();/*** 求周长方法* @return*/public float zhouChang();
}/*** 矩形类* @author user**/
public class Rectangle implements Graphical{private float c; // 长度private float k; // 宽度public Rectangle(float c, float k) {super();this.c = c;this.k = k;}@Overridepublic float mianji() {return c*k;}@Overridepublic float zhouChang() {return 2*(c+k);}}/*** 圆形* @author user**/
public class Circular implements Graphical{private float r; // 半径public Circular(float r) {super();this.r = r;}@Overridepublic float mianji() {return (float) (Math.PI*r*r);}@Overridepublic float zhouChang() {return (float) (2*Math.PI*r);}}public class Test {public static void main(String[] args) {Rectangle r=new Rectangle(2,3.5f);System.out.println("矩形的面积："+r.mianji());System.out.println("矩形的周长："+r.zhouChang());Circular c=new Circular(1.5f);System.out.println("圆形的面积："+c.mianji());System.out.println("圆形的周长："+c.zhouChang());}
}

运行输出:

矩形的面积：7.0

矩形的周长：11.0

圆形的面积：7.0685835

圆形的周长：9.424778

public void f1(){

System.out.println("汪汪...");

}

转载于:https://www.cnblogs.com/CareyZhao/p/10329639.html