面向对象思想
类与对象
类的定义
class Person{
//实例变量
//类变量
//构造方法
//空构造方法
//有参构造方法
//实例方法
//类方法
}对象的创建与构造方法
//构造方法
public Circle(){
}
//构造方法的重载
public Circle(double radius){
this.radius=radius;
}
//通过对象调用实例变量
//通过空构造方法创建对象
Circle circle = new Circle();
//通过有参构造方法创建对象
Circle circle1 = new Circle(20);类变量与实例变量
实例变量
//实例变量
/* 实例变量在对象创建的时候创建，在对象销毁的时候销毁 实例变量具有默认值，数字为0，布尔为false，引用类型为null 实例变量常用private修饰，用getter和setter方法操作。 实例变量只能由对象名访问 */
private double radius;//半径类变量
//类变量
/* 类变量也叫静态变量 无论一个类有多少对象，类变量只有一份。 静态变量在程序开始时就创建，在程序结束时才销毁，不随对象转移。 类变量常用public修饰 类变量和实例变量一样的使用，而且还可以在静态代码块中声明。 如果public static final修饰，那么作为常量，名称使用大写。 类变量可以由类名和对象名访问 */
public static final double PI=3.14;//圆周率
public static double sRadius;类方法与实例方法
实例方法
//实例方法
/* 实例方法可以操作实例变量和类变量 实例方法只能由对象名访问 */
public double area(){
return this.radius*this.radius*PI;
}类方法
//类方法
/* 类方法只能访问类变量 类方法中不能出现this或者super 类方法可以由类名或者对象名访问 */
public static double getCircle(){
return sRadius*sRadius*PI;
}面向对象综合实例
/** * Java面向对象——类 */
class Circle{//类的定义
//实例变量
/* 实例变量在对象创建的时候创建，在对象销毁的时候销毁 实例变量具有默认值，数字为0，布尔为false，引用类型为null 实例变量常用private修饰，用getter和setter方法操作。 实例变量只能由对象名访问 */
private double radius;//半径
//类变量
/* 类变量也叫静态变量 无论一个类有多少对象，类变量只有一份。 静态变量在程序开始时就创建，在程序结束时才销毁，不随对象转移。 类变量常用public修饰 类变量和实例变量一样的使用，而且还可以在静态代码块中声明。 如果public static final修饰，那么作为常量，名称使用大写。 类变量可以由类名和对象名访问 */
public static final double PI=3.14;//圆周率
public static double sRadius;
//构造方法
public Circle(){
}
//构造方法的重载
public Circle(double radius){
this.radius=radius;
}
//实例方法
/* 实例方法可以操作实例变量和类变量 实例方法只能由对象名访问 */
public double area(){
return this.radius*this.radius*PI;
}
//类方法
/* 类方法只能访问类变量 类方法中不能出现this或者super 类方法可以由类名或者对象名访问 */
public static double getCircle(){
return sRadius*sRadius*PI;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
public static double getsRadius() {
return sRadius;
}
public static void setsRadius(double sRadius) {
Circle.sRadius = sRadius;
}
}
public class 面向对象 {
public static void main(String[] args) {
//通过类名调用类变量
System.out.println(Circle.PI);
Circle.sRadius=10;
//通过类名调用类方法
System.out.println(Circle.getCircle());
//通过对象调用实例变量
//通过空构造方法创建对象
Circle circle = new Circle();
//通过有参构造方法创建对象
Circle circle1 = new Circle(20);
circle.setRadius(1);
circle.setsRadius(2); //对象操作类变量
System.out.println(circle.getRadius());
System.out.println(circle.sRadius);//对象获取类变量
System.out.println(Circle.sRadius); //类名操作类变量
System.out.println(circle.getCircle());
System.out.println(Circle.getCircle());
System.out.println(circle.area());
}
}封装
封装的主要功能在于我们能修改自己的实现代码，但是不需要修改调用程序部分。
也就是说，修改类中的实现，而不需要修改Main函数。
封装的优点：
1. 良好的封装可以减少耦合
2. 类内部的结构可以*修改
3. 可以对成员变量进行更精确的控制
4. 隐藏信息，实现细节
Java实现封装的步骤
1. 限制对属性的访问
2. 对属性提供对外的公共方法
3. 关键词private,protected,public,default其中default是隐藏的
public class Person{
private String name;
private int age;
public int getAge(){
return age;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public void setName(String name){
this.name = name;
}
}
继承
继承的格式
class Animal{
//code
}
class Dog extends Aniaml{
//code
}继承的优点
1. 实现代码的可重用
2. 增加了代码的可维护性
继承的特性
1. 子类拥有符类非private的属性和方法
2. 子类可以拥有自己的属性和方法，即拥有继承权，同时也拥有自己的个性。
3. 子类可以对父类的方法进行重写，即同一件事，孩子可以青出于蓝而胜于蓝。
4. java是单继承的。
5. 继承的缺点就是增加了代码的耦合性。耦合性就是代码之间的联系。
super和this关键字
- super，引用当前对象的父类
- this，引用本对象
final关键字
- 修饰变量则表示常量 final double PI=3.14;
- 修饰类，表示该类不能被继承 final class Person{}
- 修饰方法，表示该方法不能被子类重写 final int getMax(int a,int b){return a>b?a:b;}
构造方法
1. 子类不能继承父类的构造方法
2. 父类的构造方法必须在子类的构造方法中优先调用。
3. 如果是父类是有参构造方法，那么需要通过super(参数)显式调用。
4. 如果父类有无参构造方法，那么java会自动调用super()构造方法
多态
同一个事件发生在不同对象上会产生不同的结果，这就是多态
多态的优点
消除类型之间的耦合关系
可替换，可扩充，灵活，接口，简化出现多态的3个必要条件
1. 继承
2. 重写
3. 父类引用指向子类引用
public class Test {
public static void main(String[] args) {
show(new Cat()); // 以 Cat 对象调用 show 方法,参数中是Animal cat = new Cat();
show(new Dog()); // 以 Dog 对象调用 show 方法,参数中是Animal dog = new Dog();
Animal a = new Cat(); // 向上转型 ,父类引用指向子类
a.eat(); // 调用的是 Cat 的 eat
Cat c = (Cat)a; // 向下转型
c.work(); // 调用的是 Cat 的 work
}
public static void show(Animal a) {
a.eat();
// 类型判断
if (a instanceof Cat) { // 猫做的事情
Cat c = (Cat)a;
c.work();
} else if (a instanceof Dog) { // 狗做的事情
Dog c = (Dog)a;
c.work();
}
}
}
abstract class Animal {
abstract void eat();
}
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void work() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
public void work() {
System.out.println("看家");
}
}
多态的实现方式
- 方式一、重写
- 方式二、接口
- 方式三、抽象类和抽象方法
抽象类与接口
抽象类
抽象类的特点
抽象类用abstract修饰
抽象类必须继承使用，必能实例化对象
抽象类可以包含抽象方法和非抽象方法。
有抽象方法的必须声明为抽象类。
子类必须重写父类的所有抽象方法，如果全部重写，那么子类也必须是抽象类
构造方法和类方法不能声明为抽象方法
abstract class Animal{
private String name;
private int age;
public abstract void sleep();
public abstract void eat();
public void drink(){
System.out.println(this.name+"正在喝水...");
}
public String getName(){
return this.name;
}
public void setName(String name){
this.name=name;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age=age;
}
}
class Cat extends Animal{
public void sleep(){
System.out.println(this.getName()+"正在睡觉");
}
public void eat(){
System.out.println(this.getName()+"正在吃饭");
}
}接口
接口的特点
* 接口不能实例化对象
* 接口没有构造方法
* 接口所有方法都是抽象方法
public abstract void print();
* 接口不能包含成员变量，只包括全局常量
public static final MSG="hello";
* 接口需要被类实现。
* 接口支持多实现
接口实例
interface Usb{
public static final length=30;
public static final weight=10;
}
//接口的继承
interface DataUsb extends Usb{
public abstract void dataStream();//数据传输
}
interface ChongDianUsb extends Usb{
public abstract void chongDian();//充电
}
class Computer implements DataUsb{
public void dataStream(){
//code
}
}
//接口多实现
class Phone implements DataUsb,ChongDianUsb{
public void chongDian(){
//code
}
}