java基础学习笔记之java oop高级java面向对象基础（二）

面向对象、重载、构造、封装

一.Java面向对象:

1.1面向对象三大特征:封装、继承、多态
1.2.软件出现的目的:
2.1用计算机的语言描述现实世界
2.2用计算机解决现实世界的问题

1.3面向对象的设计步骤
1.第一步：发现类
2.第二步：发现类的属性
3.第三步：发现类的方法

二、方法重载（是实现多态的方式之一）

1.在一个类中想定义多个同名的方法必需构成方法重载
2.满足方法重载的条件:方法名相同，参数类型不同、参数个数不同、参数顺序不同即可构成重载，返回值不参于重载
3.作用:将一些相似的功能归档在一起的一种机制
代码示例

package 方法重载;

public class MyMath {
   //定义一个方法求圆的面积
	/**
	 * 求圆的面积
	 * @param r 半径  整型
	 */
	public void getMj(int r){
		double res=3.14*r*r;
		System.out.println("结果是:"+res);
	}
	/**
	 * 求圆的面积
	 * @param r 半径 小数
	 */
	public void getMj(double r){
		double res=3.14*r*r;
		System.out.println("结果是:"+res);
	}
	/**
	 * 求长度形的面积
	 * @param c 长
	 * @param k 宽
	 */
	public void getMj(int c,int k){
		double res=c*k;
		System.out.println("结果是:"+res);
	}
	
	public void getMj(double c,int k){
		double res=c*k;
		System.out.println("结果是:"+res);
	}
	public void getMj(int c,double k){
		double res=c*k;
		System.out.println("结果是:"+res);
	}
	public void getMj(double c,double k){
		double res=c*k;
		System.out.println("结果是:"+res);
	}
}

调用

package 方法重载;

public class TestMyMath {

	public static void main(String[] args) {
      MyMath mymath=new MyMath();
      mymath.getMj(2.2);
      mymath.getMj(2);
      mymath.getMj(2, 3);
      mymath.getMj(1.7, 2);
	}

}

输出结果

三、构造方法

1.什么是构造方法:当实例化对象时自动调用的方法称为构造方法
2.定义构造方法的语法:
public 方法名（参数列表）{
方体体…
作用:完成属性初始化工作
}
注意:a.构造方法名必需与类名相同
b.每个类中都有一个默认不带不做任何事情的构造方法
例如:public 类名(){}
c.只要手动实现构造，默认构造就不存,必需手动添加默认构造
代码示例

package com;
//学生类
public class Student {
 //定义属性
 public  int xh;
 public String name;
 public int age;

    //构造方法   
   //注意每个类中都有一个默认不带不做任何事情的构造方法
   // public Student(){}  //默认构造
  //  public Student(int xh,String name,int age){
        //System.out.println("每次创建对象时都必须调用构造方法");
        //属性初始化
  //  	 this.xh=xh;
  //  	 this.name=name;
  //  	 this.age=age; 
  //   }
 public  Student(){}  //
 public  Student(int xh,String name,int age){
	  this.name=name;
	  this.xh=xh;
	  this.age=age;
	 }
 //显示信息的方法
 public void show(){
	 System.out.print("学号是:"+this.xh);
	 System.out.print("姓名是:"+this.name);
	 System.out.println("年龄是:"+this.age);
 }

 
}

调用构造方法

package com;


public class TestStudent {

	public static void main(String[] args) {
        //创建对象的同时并初始信息(构造方法)
		Student stu=new Student(101,"张三",12);
		stu.show();
		
		//创建对象并赋值
		Student stu1=new Student();
		stu1.xh=11;
		stu1.name="麻子";
		stu1.age=22;
		stu1.show();
	}

}

四、访问修饰符

1.作用:限制类成员对外访问级别
2.访问修饰符分类:
public公有的:任何地方都可访问
private私有的:只能在类的类内部
protected受保护的:只能同一包中或者类的子类中可以访问
默认:同一个包中

五、封装

1.封装:将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现外隐藏信息的和访问
2.实现封装的步骤
2.1将类的属性定义为私有成员
2.2使用setter方法或者getter方法对私有成员进行封装
setter方法作用赋值
setter方法名:set属性名首字母大写()
getter方法作用取值
getter方法名:get属性名首字母大写()

代码示例

package 封装;

public class Student {
   private int xh;
   private String name;
   private int age;
   
   public  Student(){}  
   public  Student(int xh,String name,int age){
  	  this.name=name;
  	  this.xh=xh;
  	  this.age=age;
  	 }
   //显示信息的方法
   public void show(){
  	 System.out.print("学号是:"+this.xh);
  	 System.out.print("姓名是:"+this.name);
  	 System.out.println("年龄是:"+this.age);
   }
public int getXh() {
	return xh;
}
public void setXh(int xh) {
	this.xh = xh;
}
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;
}
  
}

package 封装;

public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//利用构造函数在类外对学生类的私有成员赋值
		//Student stu=new Student(11,"麻子",23);
		//stu.show();
		
		Student stu=new Student();
		stu.setXh(12);
		stu.setName("张三");
		stu.setAge(23);
		System.out.println("学号:"+stu.getXh());
		System.out.println("姓名是:"+stu.getName());
		System.out.println("年龄是:"+stu.getAge());
	}

}

输出结果

继承和多态

一、继承

1.什么是继承:就是用子类(派生类)去继承父类(基类|超类)
2.作用:实现代码的复用
3.使用extends关键字实现继承
例如:public class 子类 extends 父类{}
注意:a.子类只能继承一个父类(单继承),不能实现多继承(借接口实现多继承)
b.私有成员，构造方法不能被继承
代码示例
先建一个Person类

//人类
public class Person {
  public String name;  //姓名
  public int age; //年龄
  
  
  public Person(){
	  System.out.println("我是父类构造....");
  }
  
  public Person(String name,int age){
	  this.name=name;
	  this.age=age;
  }

  //显示信息的方法
  public void show(){
	  System.out.println("姓名是:"+this.name);
	  System.out.println("年龄是:"+this.age);
  }
}

student类继承Person类

//实现继承   学生类
public class Student extends Person {
	public Student(){
		super(); //调用父类构造
		System.out.println("我是子类构造...");
	}
	
    public Student(int xh,String name,int age)
    {
    	super(name,age);//显示调用父类构造
        this.xh=xh;  
    }
	
   public int xh; //学号
  
   public void show(){
	    System.out.println("学号:"+this.xh);
		//System.out.println("姓名:"+super.name);
		//System.out.println("年龄:"+this.age);
        //调父类方法
	    super.show();
   }

Test类调用

public class Test {

	public static void main(String[] args) {
		//创建对象时初始化属性 利用构造
		Student stu=new Student(12,"张三",21);
		stu.show();
	}

}

可以看到Student类中有继承Person的属性

二、super关键字的作用

1.使有super关键字访问父类成员
super.属性|方法();
2.使用super关键字调用父类构造方法
super(参数列表);

三、实例化子类时构造方法的调用过程

当实例化子类时，先匹配子类构造，在子类构造方法的第一行使super调用父类构造方法接着调子类构造方法.
注意:子类构造方法中第一行都有默认super()调用父类构造

四、方法重写(实现多态)

方法重载是发生同一个类中
方法重写发生在继承中

实现方法重写的步骤:
1.在子类中编写重写方法
在子类中定义与父类具有相同签名的方法(重写方法)
2.发生重写
父类名 引用名=new 任何子类名();
引用名.父类方法名();
代码示例
先定义一个父类

 //父类
public class Parent {
  public void walk(){
	  System.out.println("父类....");
  }
}

定义一个子类

public class Son extends Parent {
	  //理解为重写方法
	 public void walk(){
		  System.out.println("继承父类，重写方法");
	  }
	  
	  public void eat(){
		  
	  }
}

测试

public class Test {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
       /*子类拥有父类一样的行为*/
        //Son son=new Son();
        //son.walk();  //继承
      
		 /*子类与父类的行为不一样*/
	     //Son son=new Son();
	     // son.walk();  //继承
	      
	    //发生重写
	    //父类名 引用名=new 任何子类名();  
	    Parent p1=new Son();  //发生重写 
	    p1.walk();
	    //父类不能调子类的方法，重写方法除外
	    // p1.eat();
	      
	    //重写应用
	    
	}

}

五、抽象类

1.什么是抽象类
使用abstract定义的为抽象类
注意:a.抽象类中可以定义抽象方法
b.抽象类不能实例化，只能继承使用

2.什么是抽象方法
使用abstract定义且没有方法体的方法为抽象方法
例如: public abstract 返回值类型 方法名(参数列表);
代码示例

//父类
public abstract class Parent {
   
	//普通方法
  public abstract void get1000W();
}

public class Son extends Parent {

	@Override
	public void get1000W() {
	  System.out.println("son....");
	}

}

public class Son2 extends Parent {

	@Override
	public void get1000W() {
	  System.out.println("son2....");
	}

}

public class Test {


	public static void main(String[] args) {
        Parent p=new Son();
        p.get1000W();
	}

}

输出结果

多态的应用

一、final关键字

1.使用final修饰的类称为终态类,不能被继承
2.使用final修饰的方法称为最终方法，不能被重写
3.使用final修饰的属性必需初始化，不能重新赋值

二、static关键字

作用:定义静态成员,或者定义静态码块
注意:静态成员归类所有
1.定义静态属性
public static double money=100;

2.定义静态方法
public static void smethod(){
…
}
3.调用静态属性方法:
类名.属性名|方法名();
代码示例

//父类
//终态类： 不能被继承
//public final class Parent {
public  class Parent{
	//使用fianl修饰的属性为常量，不能被重新赋值
	public final String name="张三";
	public static double money=100;  //静态属性
	
	public static void smethod(){
		System.out.println("我会定义静态方法");
	}
	
	//静成代码块：对静态成员初始化
	//注意:当虚拟机加载字节码文件时被执行
	static{
		/*if(money>100)
		money=0;
		else
	    money=90;*/
		System.out.println("我什么时候执行的");
	}
	
	public  Parent(){
		System.out.println("我是构造");
	}
	//定义一个方法 
	public   void method(){
		System.out.println(money); 
	}
	public static void main(String[] args) {
	//System.out.println(name);
	//System.out.println(money);  //静态方法中使用静态成员
	   //访问静态成员:注意静态成员归类所有
	   //类名.属性名|方法名();
		//Parent.smethod();
		//Parent.money=90;
	
		Parent p=new Parent();
		//p.smethod();
		//System.out.println(p.money);
		
		
	}
}


class Son extends Parent{
	
}

三、多态

1.生活中的多态
同一种事物，由于条件不同，产生的结果也不同
2.程序中的多态:
同一个引用类型，使用不同的实例而执行不同的操作
父类 引用名=new 任何子类();
多态应用示例
USB类

public class Usb {
  public void service() {
	
  }  
}

鼠标类

public class Mouse extends Usb {
   //重写
	@Override
	public void service() {
  	System.out.println("鼠标开始工作....");
	}
}

键盘类

public class KeyBorad extends Usb {
  @Override
	public void service() {
	System.out.println("键盘开始工作....");
	}
}

测试类，usb可以实现键盘、鼠标功能

public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
     Usb usb=new KeyBorad(); //new Mouse();
     usb.service();
     
	}

}

运行结果

public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
     Usb usb=new KeyBorad(); //new Mouse();
     usb.service();
     
	}

}

四、子类与父类的转换

1.向上转型(自动转换):子类对象向父类转换
2.向下转型(强制转换):将父类引用转化为子类
//注意:父类不能访问子类成员，重写方法除外
子类名 对象象=(子类名)父类引用名;

3.instanceof关键字
作用:判断某个对象是不是该类的对象,是返回true,反之返回false
语法
对象 instanceof 类名

接口的使用

一、接口

作用:解决多重继承
1.使用interface关键字定义接口
public interface 接口名{
//一系列抽象方法
}
注意:a.接口不能被实例化,而只能被实现
b.接口中的方法都为抽象方法
[public abstract] void service();
c.接口也可以被继承
d.接口中的属性全是静态常量
[public static final ]int A=10;

2.使用implements关键字实现接口
public class 类 implements 接口1,接口2…{
//必需实现接口中所有的抽象方法
}

3.使用接口
接口名 引用名=new 任何实现接口类的对象();
引用名.方法名(); //调用重写方法
代码示例

//定义一个Usb的接口
public interface Usb {
   //一系列的静态常量
	//[public static final ]int a=10;
	  int a=10;
	
  //定义一个抽象方法
 // [public abstract] void service();
	 void service();  //public abstract省略不写	
}

//用类实现接口
public  class Mouse implements Usb {

	@Override
	public void service() {
		System.out.println("鼠标开始工作啦....");
	}

}

public class KeyBorad  implements Usb{

	@Override
	public void service() {
		System.out.println("键盘工作啦...");
	}

}

public class TestUsb {
	public static void main(String[] args) {
        //使用接口 
		Usb usb=new Mouse();
        usb.service();
	}

}

运行结果

二、理解接口的应用

1.接口表示一种功能(能力)
代码示例

//门铃接
public interface Bell {
   void sound();  //响铃
   }

  //门类
public class Door {
  //开门
	public void openDoor(){
	  System.out.println("门正在打开的过程中。。。开啦");	
	}
  //关门
	public void closeDoor(){
		 System.out.println("门正在关闭的过程中。。。关啦");	
	}
}

public class DoorLockBell extends Door implements Lock, Bell {

	@Override
	public void sound() {
	   System.out.println("小苹果唱起来......");
	}

	@Override
	public void openLock() {
	  System.out.println("左三圈右三圈...开锁");
	}

	@Override
	public void closeLock() {
		  System.out.println("右三圈左三圈...上锁");
	}

}

//锁接口
public interface Lock {
   void openLock();
   void closeLock();
}

//安全门       解决多重继承
public class SafeDoor extends Door implements Lock {

	@Override
	public void openLock() {
	 System.out.println("正三圈反三圈.....锁开啦");
	}

	@Override
	public void closeLock() {
		System.out.println("反三圈正三圈.....上锁啦");
	}
  
}

public class TestDoor {

	public static void main(String[] args) {
	      DoorLockBell door=new DoorLockBell();
	      System.out.println("客人来啦...");
	      door.sound();
	      System.out.println("主人来开门");
	      door.openLock();
	      door.openDoor();
	      System.out.println("请进来座座吧....好久没聊天了...");
	      door.closeDoor();
	      door.closeLock();
	}

}

2.接口表示一种约定
代码示例

//电脑类
public class Computer {
     //电脑使用接口
	public DiskUsb diskUsb;  //属性
	
	public void work() {
	  System.out.println("刚才有"+diskUsb.getSize()+"G的U盘被接入进来");
	}
}

 //U盘的接口
public interface DiskUsb {
      int getSize();    //获取U盘的容量
}

public class Product1 implements DiskUsb {

	@Override
	public int getSize() {
		// TODO Auto-generated method stub
		return 8;
	}

}

public class Product2 implements DiskUsb {

	@Override
	public int getSize() {
		// TODO Auto-generated method stub
		return 16;
	}
}

public class TestComput {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//创建一个U盘对象
		Product1 p1=new Product1();
		Product2 p2=new Product2();
        //创建一个电脑对象
		Computer computer=new Computer();
		computer.diskUsb=p1; /*约定*/
		computer.work();
	}

}

运行结果