Java入门之面向对象三大特性

面向对象的三大特性

三大特性之封装

面向对象程序的封装性体现在了数据封装和函数封装的，数据封装就是将实体类中的成员变量的修饰符改为private只有类的内部可以访问到，如果在类外要对数据进行操作，我们需要提供对应的get和set方法。而get和set方法好处在于不仅可以用eclipse自动生成，更重要的是在后期进行项目开发用到数据传送时，都是利用反射的机制进行数据的封装，而方法的封装在于进行工具的封装，我们在调用函数里面的方法时我们只需要知道如何去使用这个方法，而不用关心方法具体是怎么样实现的这样使软件开发变得简单，也更利于结构化程序设计的模块化思想的普及。而构造器和本类中对this和super等关键字的引用在于，this指的是当前对象，而super指的是父类的方法封装代码演示如下：

public class User {
private int workCard;  //账号
private String password; //密码
private String userName; //名字
//get set方法便于实现变量的访问
public String getUserName() {
	return userName;
}
public void setUserName(String userName) {
	this.userName = userName;
}
private String sex; //性别
private int age;    // 年龄
private String address; //地址
//无参构造器
public User(){
	super();
}

//重载了toString方法，便于打印输出
@Override
public String toString() {
	return "User [workCard=" + workCard + ", password=" + password + ", userName=" + userName + ", sex=" + sex
			+ ", age=" + age + ", address=" + address + "]";
}
public int getWorkCard() {
	return workCard;
}
public void setWorkCard(int workCard) {
	this.workCard = workCard;
}
public String getPassword() {
	return password;
}
public void setPassword(String password) {
	this.password = password;
}
public String getSex() {
	return sex;
}
public void setSex(String sex) {
	this.sex = sex;
}
public int getAge() {
	return age;
}
public void setAge(int age) {
	this.age = age;
}
public String getAddress() {
	return address;
}
public void setAddress(String address) {
	this.address = address;
}}

方法重载----【多态】重写

方法名必须一样参数

个数或者类型不同

返回类型可以不一样

数组的定义

语法type [] arr = new type[];

一连串的同类型的数据，里面的数据被称为数组元素，利用下标去访问数组中的数据。

数组是java程序中最简单的数据结构，这种数据结构在使用的时候简单易用，方便简洁。

可变长度的数组的定义

语法 数据类型…args

学习JDBC进行写DAO工具的时候使用。

操作数组的工具类是Arrays

二维数组的定义相当于在数组中又建了一个一维数组。

包的使用

包的出现是为了避免类名冲突，在eclipse中包的使用是很清晰的，直接在项目源代码的文件下直接新建一个包就可以，在记事本下新建一个包所编译的程序的命令是java -d . 源程序文件。

三大特性之继承

继承是面向对象程序的一大特性，继承是指程序在设计时，把一些列对象都具有的属性和行为进行抽象，抽象起来形成一个新的类，其他的类只要继承了这个抽象出来的类就可以使父类中的非私有的方法和属性。这样一来相当于把一部分代码写成公共的代码，任何类只要继承了父类，就可以使用父类中的一部分代码。在java中提供的是单继承，多实现，一个类有且仅有一个父类，但是一个类可以被多个类同时继承。但是java可以进行间接继承，也就是隔代继承，A类继承自B类，B类又继承自C类，这样一来，A类的对象就有B类和C的所有的非私有属性和方法。上面是对类进行初步的抽象形成了父类，如果再对父类在进行抽象可以形成抽象类，抽象类的抽象，极致的抽象可以形成接口。

代码演示

public class Animal {
protected String name;
protected int age;

public void eat(){
	System.out.println(name+"在吃东西");
}
public void sleep(){
	System.out.println(name+"在睡觉");
}
}
public class Dog extends Animal{
public void kanmen(){
	System.out.println(name+"在看门");
}}

public class Cat extends Animal{}
public class Test {
public static void main(String[] args) {
	Dog a = new Dog();
	a.name = "旺财";
	a.eat();
	a.sleep();
	a.kanmen();
}
}

修饰符的范围问题

				同类	同包	子类	不同包

公有 public √ √ √ √
受保护 protected √ √ √
默认 缺省 √ √
私有 private √

方法重写的问题

机制，在子类中将父类中已经继承过来的成员方法，进行重新编写（方法体）。
1、子类如果要重写父类，方法签名不能够改变（一样）。
2、方法体可以重新编写。

重载：
1、是在一个类实现的机制
2、根据参数的不同，动态决定调用哪个方法。
重写：
1、多个 类，并且父类和子类
2、在子类将父类中的方法体重新编写，以符合子类实际需求

**继承(大–>小) 由 抽象 变为 具体 **
人–>教师–>语文教师
[抽象类]

super关键字的使用

子类在实例化的时候，子类首先调用父类中的构造函数,所以子类的构造函数要和父类皮匹配
【super】 ----只存在继承关系中，调用父类中成员

		super.变量名; 变量
		super.方法名();   方法
		super(XXX,XXX);  构造方法

基本类库

基本类库(Java支持库)
java.uitl.Scanner

java.lang.*; 自动导入。
System.out.println();

Object类

【Object类】 直接继承或者间接继承。
定义的类，没有手动通过extends继承别的类的话，会自动继承Object (隐士)

equals和toString方法的使用

【equals(Object obj)】 比较2个对象是否“相等”。子类需要"重写"
int a=10,b=10; if(ab)
对象类型不能够使用比较，使用比较对象的地址。
比较String类型的数据使用equals()方法，而不是
String类默认重写了equals()方法，自定义的类，需要进行equals()比较，就需要重写

obj instanceof UserInfo obj是否是UserInfo这个类构造出来的对象

父–>子 大–>小 子类对象可以在父类之间来回转换
UserInfo --> Object 自动转换 user2–>参数 -->Object obj
Object obj = user2;

Object—>UserInfo 强制转换
UserInfo user2 = (UserInfo)obj;

【toString() 返回该对象的字符串表示。】 子类需要“重写”
希望对象可以调用toString()方法，按照固定格式输出，需要在子类中重写Object的toString()方法。
Java基本类库中提供的有些类，已经默认重写了Object的toString()方法。 比如Integer这个类。

三大特性之多态

多态是面向对象程序的基本特性之一，也是最重要的特性，多态是建立在继承和封装的基础之上。多态的基本里含义是一种对象多种态性，我们可以声明父类的变量用子类的构造器去创建出来，这样一来在编译时变量是父类的，但是在实际运行时，变量的类型又是子类的，体现了一种态性的不同实现。在调用该对象的函数时其实是看对象到底是通过谁new出来的，new出来的是谁，就调用谁的函数体。

代码演示

package com.sram.code;
class Dunk{

public int dunkID;
public Dunk(int dunkID){
	this.dunkID = dunkID;
}
public void go(){
	System.out.println("出发");
}

}

class RunDunk extends Dunk{
public RunDunk(int dunkID){
super(dunkID);
}
@Override
public void go() {
System.out.println(“编号为”+dunkID+“跑着出发了…”);
}
}

class FlyDunk extends Dunk{
public FlyDunk(int dunkID){
super(dunkID);
}
@Override
public void go() {
System.out.println(“编号为”+dunkID+“飞着出发了…”);
}
}

public class DunkMain {
public static void main(String[] args) {
//存储50只鸭子
long rand=0l;
//Dunk d = new RunDunk(11);
Dunk[] array = new Dunk[50];

	for(int i=0;i<array.length;i++){
		rand=Math.round(Math.random()*10);
		if(rand<5){  //飞
			array[i] = new FlyDunk(i+1);
		}else{  //跑
			array[i] = new RunDunk(i+1);
		}
	}
	
	System.out.println("鸭子组织完毕");
	for(int index=0;index<array.length;index++){
		array[index].go();
	}
}
}

final修饰符的使用

【final】修饰符----终结(状态最终)—>不可改变

final 变量--->此变量的值不能被修改。 		(变量)反(常量)  静态常量(大写)
	  Math:public static final double PI = 3.1415926d;
	  	   使用：不需要实例化类    		类名.静态常量         Math.PI;
	  
	  final 变量----必须初始化，初始化后不能改变值（运行加载）   对象.常量
	  static final变量-----必须初始化，初始化后不能改变值（类加载）   类名.常量
final 方法--->此方法将不能够重写（覆盖）
	     隐士:-->方法声明 priavte 类型，是隐士的final方法，不能重写
	     隐士：-->final类中所有的方法都是隐士的final方法，因为不能继承，就不存重写
final 类--->此类不能够继承。例如：String、Integer等

static修饰符的使用

【static】修饰符 static----到达内存的时间点不一样。（类加载）
类(加载)–(运行)
new 类(); //创建某个类对象的时候才加载内存。
static 变量\常量
public static int count=0;
1、所有的类实例化后，共享一个静态变量。（统计一个类被实例化了多少次）
2、静态变量调用：a、可以通过类对象去调用 c1.count; b、也可以直接使用类名 去调用 StaticClass.count;
3、普通方法可以使用静态变量，静态方法只能使用静态变量(不能使用普通变量)
static 方法
public static void fun(){}
static 类

抽象类和接口

父类的方法不写方法体。（抽象方法）
如果一个类中有一个抽象方法，那么这个类必须为抽象类。

abstract(抽象的)----方法（抽象方法）、类（抽象类）。
抽象方法----子类继承父类（抽象类），子类必须实现（重写）抽象类中抽象方法。

【抽象类和普通类】
1、抽象类得到一个可以拥有抽象方法的能力，但是失去了一个new的能力。（不能实例化）
2、抽象类中的构造方法，是给子类调用实例化的。
3、定义抽象类，但是没有抽象方法。抽象类还是不能被new 实例化。
4、抽象类中可以声明变量和普通成员方法。

【接口】----更加纯粹的抽象类。
1、没有构造函数。
2、没有成员变量。静态常量。
3、没有成员方法。抽象方法。

定义：[修饰符] interface 接口名{
	静态常量;
	抽象方法;
	内部类，接口，枚举...
}

接口名：见名知意 驼峰命名。最好形容词，Teachable。 CSharp 名 ITeachable
类描述对象的属性和方法。
接口包含类所有实现方法。
接口是不能被继承的，只能被实现。实现关键词：implements
一个子类不是抽象类，实现了一个接口，就必须实现接口中所有的抽象方法
一个类可以实现多个接口
1、声明 的方法，默认就是abstract的、并且是public2
2、声明的变量，默认就是public static final ，默认就是静态常量
抽象类和接口 异同点
共同点：
1、代表系统的抽象层
2、都不能new 实例化
3、都能够包含“抽象方法”，不需要给出方法具体实现。
​
区别 1、抽象类可以具有“成员方法”，接口中只能包含“抽象方法”
2、抽象类中可以具有“构造函数”，接口不能有构造函数。
3、抽象类可以有“成员变量”，接口只能“静态常量”
4、一个子类可以继承一个抽象类，但是可以实现多个接口。
5、抽象类定义好，可以往类中任意添加一个“成员方法”，不会对子类造成影响。
但是接口，一旦定义好，就不应该改变。
【标识接口】 ---- 标识。
interface Ic{
}

序列化和反序列化。

【Comparable排序接口】
compareTo(T o) //排序规则 2,44,12,25,18
this o
1个数<2个数 return -1; 负数
1个数>2个数 return 1; 正数
1个数==2个数 return 0;

数据库操作
接口I1(3个方法,删，更新，查询)
    |          |
   MYSQL      Oracle
   (实现)       (实现)

I1 a = 动态;
a.删除();