Java面向对象的程序示例

1.对象的创建和使用(用“OO”表示)

(1)OOTest01
1)OOTest、Student类
//通过一个类可以实例化N个对象；
//实例化对象的语法：new 类名();
//new是java语言中一个运算符；
//new运算符的作用是创建对象，在JVM堆内存中开辟新的内存空间；
//方法区内存：在类加载的时候，class字节代码片段被加载到该内存空间中;
//栈内存(局部变量)：方法代码片段执行的时候，给该方法分配内存空间，压栈操作；
//堆内存:new对象在堆内存中存储；
//对象：new运算符在堆内存中开辟的内存空间；
//引用:引用是一个变量，这个变量保存了另一个java对象的内存地址；
//只能通过“引用”访问堆内存中对象内部的实例变量；
//局部变量在栈内存中存储
//成员变量中的实例变量(对象变量)在堆内存的java对象内部存储

public class OOTest01
{
	public static void main(String[] args){
		
		Student s=new Student();//Student是一个引用数据类型，s是一个局部变量(引用)，new Student()是一个学生对象；
	    
		//访问实例变量的语法格式：
		//读取数据：引用.变量名
		//修改数据：引用.变量名=值
		int stuNo=s.no;
		String stuName=s.name;
		int stuAge=s.age;
		boolean stuSex=s.sex;
		String stuAddr=s.addr;
        //各个数据类型的默认值
		System.out.println("学号="+stuNo);//0
		System.out.println("姓名="+stuName);//null
		System.out.println("年龄="+stuAge);//0
		System.out.println("性别="+stuSex);//false
		System.out.println("住址="+stuAddr);//null
        
		//对象变量进行赋值，输出变换另一种形式
		s.no=1120181123;
		s.name="灰色头像";
		s.age=23;
		s.sex=true;
		s.addr="上海";
        System.out.println("学号="+s.no);//1120181123
		System.out.println("姓名="+s.name);//灰色头像
		System.out.println("年龄="+s.age);//23
		System.out.println("性别="+s.sex);//true
		System.out.println("住址="+s.addr);//上海
		System.out.println("====================================");

		//再通过类实例化一个全新的对象
		//stu是一个引用
		//stu同时也是一个局部变量（放栈内存中）
		//Student是变量的引用数据类型
		Student stu=new Student();
        stu.no=1120181124;
		stu.name="JKscon";
		stu.age=23;
		stu.sex=true;
		stu.addr="俄罗斯";
        System.out.println("学号="+stu.no);//1120181124
		System.out.println("姓名="+stu.name);//JKscon
		System.out.println("年龄="+stu.age);//23
		System.out.println("性别="+stu.sex);//true
		System.out.println("住址="+stu.addr);//俄罗斯
        
		//编译报错，no这个实例变量不能直接用“类名.”的方式访问
		//no是对象级别的变量，是实例变量，必须用对象访问
		//System.out.println(Student.no);
	}
}

---

/*
学生类是一个模板，有共同特征【状态+行为=属性+方法】
当前类只描述学生状态信息【属性=状态】
*/
public class Student
{
	//类体=属性＋方法
	//成员变量：变量定义在类体当中，方法体之外；
	//局部变量：变量定义在方法体中；
	//学生信息（属性）需要通过对象访问，不能通过“类”直接访问，这种变量(属性)也叫实例变量（对象变量）；
	//不创建对象，学生的变量的内存空间不存在。
	int no;//学号
	String name;//姓名
	int age;//年龄
	boolean sex;//性别
	String addr;//住址
}
//成员变量没有手动赋值的话，系统赋默认值
//默认值
/*
数据类型                  默认值
------------------------------------
byte,short,int,long        0
float, double              0.0 
boolean                    false
char                       \u0000
引用数据类型               null 空值
*/

---

---

(2)OOTest02和OOTest03
1）用了OOTest02、Address、User类

//测试类(引用是一个变量，可以是局部变量，也可以是成员变量（实例变量/对象变量）)
public class OOTest02
{
	public static void main(String[] args){
		//创建User对象
		//u是局部变量，一个引用，保存地址指向堆内存的User对象
		User u=new User();//User引用数据类型，u是引用，用户对象new User();
		
		//输出User对象内部实例变量的值
        System.out.println(u.no);//默认值0
        System.out.println(u.name);//默认值null
		System.out.println(u.addr);//默认值null
		//赋值
		u.no=112;
		u.name="jack";//jack属于String对象
		u.addr=new Address();//创建Address对象，开辟内存空间

		//mian方法中只能看到一个引用“u”，一切都只能通过u进行访问
		System.out.println(u.name+"居住在哪个城市："+u.addr.city);
		System.out.println(u.name+"居住在哪个街道："+u.addr.street);
		System.out.println(u.name+"邮编："+u.addr.zipcode);
		//赋值运算
		u.addr.city="北京";
		u.addr.street="海淀区";
		u.addr.zipcode="112060";
        System.out.println(u.name+"居住在哪个城市："+u.addr.city);
		System.out.println(u.name+"居住在哪个街道："+u.addr.street);
		System.out.println(u.name+"邮编："+u.addr.zipcode);
	}
}

//家庭住址类
public class Address
{
	//属性【成员变量之实例变量】
	//城市
	//String是一种引用数据类型，city是一个实例变量（引用）
	String city;
	String street;//街道
	String zipcode;//邮编
}

//用户类
public class User
{
	//属性【以下都是成员变量之实例变量】
	//用户编号，int基本数据类型：整数型，no是一个实例变量
	int no;

	//用户名，String是一种引用数据类型：代表字符串
	//name是一个实例变量，一个引用
	String name;

	//家庭住址，Address是一种引用数据类型：代表家庭住址
	//addr是一个实例变量，一个引用
	Address addr;
}

---

2)用了OOTest03、User类

public class OOTest03
{
	public static void main(String[] args){
		User u=new User();//User.java中写过，创建对象，new 类名();
		//上一个02版本中编写
		//u.addr=new Address();

		//a是局部变量，是引用
		Address a=new Address();//创建Address对象，02版本未创建Address对象
		u.addr=a;
		System.out.println(u.addr.city);//null
        a.city="合肥";
        System.out.println(u.addr.city);//合肥 
	}
}

---

---

(3)OOTest04
1)OOTest04、Husband、Wife类

//测试类
public class OOTest04
{
	public static void main(String[] args){
		Husband huangxiaoming=new Husband();//丈夫对象创建
		huangxiaoming.name="黄晓明";
		Wife baby=new Wife();//妻子对象创建
		baby.name="杨颖";
		//通过妻子找到丈夫，丈夫找到妻子
		huangxiaoming.w=baby;
		baby.h=huangxiaoming;
		//黄晓明的妻子是杨颖
		System.out.println(baby.h.name+"的妻子是"+huangxiaoming.w.name);
		//杨颖的丈夫是黄晓明
		System.out.println(huangxiaoming.w.name+"的丈夫是"+baby.h.name);
	    System.out.println("=============================");
		//不经过关系的转换，直接写出
		System.out.println(huangxiaoming.name+"的妻子是"+baby.name);
        System.out.println(baby.name+"的丈夫是"+huangxiaoming.name);

	}
}

//妻子类
public class Wife
{
	String idCard;
	String name;
	Husband h;//妻子对象含有丈夫引用
}

//丈夫类，以下是成员变量 name idCard w
public class Husband
{
	String name;//姓名
	String idCard;//身份证号码
    Wife w;//丈夫对象中含有妻子
}

---

---

(4)OOTest05
1)OOTest05、Product、ProductTest类

public class OOTest05
{
	public static void main(String[] args){
		ProductTest iphone=new ProductTest();//创建ProductTest对象

		//间接访问iphone7
		//iphone.iphone7=new Product();//如果间接访问，这步不能少
		Product p=new Product();
		iphone.iphone7=p;//(以上2步)这种方式也能间接访问，自己任意选择
		iphone.name="联想";
		iphone.iphone7.price=5600;
		iphone.iphone7.productNo=0223;//八进制自动转换十进制输出
		System.out.println("笔记本的名字是"+iphone.name);
        System.out.println("笔记本的价格是"+p.price);
        System.out.println("笔记本的编号是"+iphone.iphone7.productNo);
       
		//间接访问huawei
        iphone.huawei=new Product();//如果间接访问，这步不能少
		iphone.name="华为";
		iphone.huawei.price=6600;
		iphone.huawei.productNo=5683;
		System.out.println("笔记本的名字是"+iphone.name);
        System.out.println("笔记本的价格是"+iphone.huawei.price);
        System.out.println("笔记本的编号是"+iphone.huawei.productNo);
		
		Product s=new Product();//创建Product对象
		iphone.iphone7=s;
		s.price=3400;
		iphone.iphone7.productNo=23900;
        System.out.println("笔记本的名字是"+iphone.name);
        System.out.println("笔记本的价格是"+s.price);
        System.out.println("笔记本的编号是"+s.productNo);
       
		Product A=new Product();//再创建另一个对象
		System.out.println("笔记本的价格是"+A.price);//默认值0.0
        System.out.println("笔记本的编号是"+A.productNo);//默认值0
	}
}

public class Product
{
	double price;
	int productNo;
}

public class ProductTest
{
	Product iphone7;
	Product huawei;
	String name;
}

---

---

(5)OOTest06
1)OOTest06、Computer、Student类

/*所有class代码可以写到一个文件夹中，不用在分着写*/
//创建一个Computer类
class Computer
{
	String brand;
	String style;
	String color;
}

//创建一个学生类
class Student
{
	int no;
	String name;
	Computer notepad;
}

//测试类
public class OOTest06
{   //主方法体
	public static void main(String[] args){
		//创建笔记本电脑对象
		Computer biJiBen=new Computer();
		//不采用系统默认值，赋值操作
		biJiBen.brand="联想";
		biJiBen.style="C12";
		biJiBen.color="black";
        //创建学生对象
		Student zhangsan=new Student();
		zhangsan.no=1233;
		zhangsan.name="张三";
		zhangsan.notepad=biJiBen;
		//让这个学生和笔记本对象产生关系【通过学生能找到他的笔记本】
		System.out.println(zhangsan.notepad.brand);
		System.out.println(zhangsan.notepad.style);
        System.out.println(zhangsan.notepad.color);

		//张三又买了一台新电脑,
		//Computer biJiBen=new Computer();,所以2个都可以
		zhangsan.notepad=new Computer();//新创建的，所有值均是默认值
        System.out.println(zhangsan.notepad.brand);//默认值null
		System.out.println(zhangsan.notepad.style);//null
        System.out.println(zhangsan.notepad.color);//null

	}
}

---

---

2.对象的封装

• 所有属性私有化，使用private关键词修饰private表示私有的，修饰的所有数据只能在本类中访问；
• 对外提供两个公开的方法，分别是set和get方法，修改变量的属性用set方法，读取变量的属性值，调用get方法；
• set方法命名规范：（没有返回值）public void setAge（int a）{
  age =a;}
• get方法命名规范：（要有返回值）
  public int getAge(){
  return age;}
• setter 和getter方法没有static关键字，用"引用.方法名（实参）"；
• 用eclipse可以直接用，不需要打。

*1)*CustomerTest、Customer类

/**结果：190
刘杰
23
南京大学物理楼
* */
package javase.duixiangchuangjian.Test03;
//顾客测试类
public class CustomerTest {

  public static void main(String[] args) {
  	Customer c=new Customer();//创建Customer对象
  	//c.id=340;//报错，属性私有化，外部不能直接访问，需要封装
  	c.setId(190);
  	c.setName("刘杰");
      c.setAge(23);
      c.setAddr("南京大学物理楼");
      System.out.println(c.getId());
      System.out.println(c.getName());
      System.out.println(c.getAge());
      System.out.println(c.getAddr());
  }

}

package javase.duixiangchuangjian.Test03;
//顾客类
public class Customer {
	//属性私有化，通过setter和getter方法（无static，引用.访问）进行访问实例变量
	private int age;
	private String name;
	private int id;
	private String addr;
	
	//无static的setter和getter方法
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		if(age>120||age<0) {
			System.out.println("您输入的年龄有误！");
		}
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getAddr() {
		return addr;
	}
	public void setAddr(String addr) {
		this.addr = addr;
	}
	
}

---

*2)*这里用到了业务逻辑控制语句，第二个程序，if条件语句
UserTest、User类

/*结果：对不起，您输入的年龄有误！
130
对不起，您输入的年龄有误！
-23
34
*/
package javase.duixiangchuangjian.Test03;

public class UserTest {

	public static void main(String[] args) {
		User user=new User();
		//System.out.println(user.age);//报错，属性私有化，外部程序不能直接访问，只能通过2个公开的方法访问
		user.setAge(130);//修改属性，调用是引用.方法名(无static)
		System.out.println(user.getAge());//读取
        user.setAge(-23);
        System.out.println(user.getAge());
        user.setAge(34);
        System.out.println(user.getAge());
	}
}

package javase.duixiangchuangjian.Test03;
/*封装*/
public class User {
	//属性私有化
	private int age;
	//set方法没有返回值，只负责修改数据。
	/*
	public void setAge(int age){
		age=age;//就近原则，这里没有给成员变量age属性赋值，这里的age都是局部变量。
	}
	 */
	//修改如下，setter
	public void setAge(int a) {
		//编写业务逻辑进行控制
		if(a<0||a>120) {
			System.out.println("对不起，您输入的年龄有误！");
		}		
			age=a;
	}
	//getter
	public int getAge() {
		return age;
	}
}

---

---

3.参数传递

1）Canshu01类

package javase.duixiangchuangjian.canshuchuandi05;
//参数传递，值传递
public class Canshu01 {
	public  static void main(String[] args) {
		//这个u保存的值是java对象内存地址，有时是字面值
		User u=new User(23);//调用下面的构造方法，ctrl加鼠标查看
		add(u);//调用add方法，有static（类名.省略）
		System.out.println("main-->"+u.age );//24
	}
	public static void add(User u) {
		u.age++;
		System.out.println("add-->"+u.age);//24
	}
}
class User{
	//实例变量
	int age;
	//构造方法
	public User(int i) {
		age=i;
	}
}

---

2)Canshu02类

package javase.duixiangchuangjian.canshuchuandi05;
/**
 * 结果：fun-->11
s--->10
p--->10
main-->10

参数传递的结果，java中传递的是值
 * */
public class Canshu02 {

	public static void main(String[] args) {
		int i=10;
		fun(i);
		U.s(i);
		U u=new U();
		u.p(i);
		System.out.println("main-->"+i);//10

	}
	public static void fun(int i){
		i++;
		System.out.println("fun-->"+i);//11
	}

}
class U{
	public static void s(int i) {
		System.out.println("s--->"+i);//10
	}
	public void p(int i) {
		System.out.println("p--->"+i);//10
	}
	
}

---

---

4.构造方法（创建对象、给实例变量赋值）

1.语法结构：<1>构造方法：【修饰符列表】 构造方法名（与类名一致） 【形参】{ 构造方法体}
                  <2>普通方法：【修饰符列表】 返回值类型 方法名（形参）{ 方法体}

2. 方法的调用：<1>构造方法：new 类名（实参）
                      <2>普通方法：静态方法：类名.方法名；无static的方法：引用.方法名 3.构造方法结束的时候，java自动返回类型值。
4.当一个类中没有定义任何构造方法的话，系统默认给该类提供一个无参数的构造方法，但最好手动构造。
5.构造方法支持重载机制，在一个类中编写多个构造方法，这多个构造方法构成重载机制。

1)ConstructorTest01、User类

package javase.duixiangchuangjian.Gouzao04;
/**结果：不带参数的构造器
带有int类型参数的构造器
带有string类型参数的构造器
带有int,string类型参数的构造器
doSome?
doSome?
doOther??

 * */
//构造方法的创建：new 构造方法名（实参），构造方法名与类名一致
public class ConstructorTest01 {
	public static void main(String[] args) {
		
		//创建User对象；调用User类的构造方法创建对象；以下程序创建了4个对象，只要构造函数调用就会创建对象。
		User u1=new User();
		User u2=new User(23);
		User u3=new User("杰克逊");
		User u4=new User(23,"杰克逊");
		
		//调用带static的方法：类名.方法名();
		ConstructorTest01.doSome();
		doSome();//本类中，可以不加类名
		
		//调用不带static的方法：引用.方法名();
		//doOther方法ConstructorTest01类当中，所以需要创建ConstructorTest01对象
		//创建ConstructorTest01对象，调用无参数构造方法
		ConstructorTest01 t=new ConstructorTest01();
		t.doOther();
	}
	public static void doSome() {
		System.out.println("doSome?");
	}
	public void doOther(){
		System.out.println("doOther??");
	}
}

• 1）.构造方法：[修饰符列表] 构造方法名（与类名一致）[形参列表]{
• 构造方法体}
• 2）.返回值类型不需指定，java自动返回，即为类名本身
• 3）.下面的4个构造方法也构成了方法重载：同一个类中，方法名（这里是类名）相同，参数列表不同：数量，顺序，类型均不同。

package javase.duixiangchuangjian.Gouzao04;

public class User {
	
	//无参数构造方法
	public User() {
		System.out.println("不带参数的构造器");
	}
	
	//有参数的构造方法
	public User(int i) {
		System.out.println("带有int类型参数的构造器");
	}
	
	//有参数的构造方法
	public User(String name) {
		System.out.println("带有string类型参数的构造器");
    }
	//有参数的构造方法
	public User(int i,String name) {
	    System.out.println("带有int,string类型参数的构造器");
	}
}	

---

2）ConstructorTest02、Account类

package javase.duixiangchuangjian.Gouzao04;
/**
 * 构造方法的作用：1)创建对象；2)给实例变量赋值
 * 结果：账号：null
余额：0.0
账号：1382
余额：0.0
账号：null
余额：345.78
账号：axt-08
余额：123.4

 * */
public class ConstructorTest02 {

	public static void main(String[] args) {
		//如何查看访问哪个属性，哪个方法?
		//按ctrl键，鼠标移动到查看的元素上，出现下划线的时候点击
		//创建对象
		Account act1=new Account();//调用Account无参数构造器，每次创建new对象，实例变量就要重新赋值（手动或默认）
		System.out.println("账号："+act1.getActno());//null
		System.out.println("余额："+act1.getBalance());//0.0
		
		Account act2=new Account("1382");//重新创建对象，实例变量重新赋值操作，构造方法调用Account(String s)有参数构造器,用ctrl加鼠标查看调用哪个方法
		System.out.println("账号："+act2.getActno());//1382
		System.out.println("余额："+act2.getBalance());//0.0
		
		Account act3=new Account(345.78);//重新创建对象，实例变量重新赋值操作
		System.out.println("账号："+act3.getActno());//null
		System.out.println("余额："+act3.getBalance());//345.78
		
		Account act4=new Account("axt-08",123.4);
		System.out.println("账号："+act4.getActno());//axt-08
		System.out.println("余额："+act4.getBalance());//123.4
	}
	

}

package javase.duixiangchuangjian.Gouzao04;
//账户类,封装和构造方法
public class Account {
	//账号
	private String actno;//属性私有化,成员变量(实例变量)actno,调用构造方法也只能通过setter和getter访问变量
	//余额
	private double balance;//属性私有,成员变量balance
	
    //无参数构造器
	public Account() {//与类名一致,无返回值类型	
		//初始化实例变量的内存空间，actno=null;balance=0.0;
	}
	public Account(String s) {
		actno=s;//手动赋值
		//balance=0.0;系统默认赋值
	}
	public Account(double d) {
		//actno=null;系统默认赋值，因为重新new对象，不再是上述
		balance=d;//手动赋值
	}
	public Account(String s,double d) {
		actno=s;//手动赋值
		balance=d;
	}
	
	//setter和getter方法
	public String getActno() {
		return actno;
	}
	public void setActno(String actno) {
		this.actno = actno;
	}
	public double getBalance() {
		return balance;
	}
	public void setBalance(double balance) {
		this.balance = balance;
	}
}

---

3） ConstructorTest03、Customer类

package javase.duixiangchuangjian.Gouzao04;
/**
 * 结果：0
null
null
1111
张三
1980-4-23
 * */
public class ConstructorTest03 {

	public static void main(String[] args) {
		Customer c1=new Customer();//无参数构造调用
		System.out.println(c1.getNo());//0
		System.out.println(c1.getName()); //null         
		System.out.println(c1.getBirth());//null         
		                                           
		Customer c2=new Customer(1111,"张三","1980-4-23");//有参数构造调用               
		System.out.println(c2.getNo());//1111            
		System.out.println(c2.getName());//张三      
		System.out.println(c2.getBirth());//1980-4-23    
	}                                              

}

package javase.duixiangchuangjian.Gouzao04;

public class Customer {
	private int no;
	private String name;
	private String birth;
	//无参数构造方法
	public Customer() {
		
	}
	//有参数构造方法
	public Customer(int a, String b, String c) {
		no = a;
		name = b;
		birth = c;
	}

	//setter和getter方法
	public int getNo() {
		return no;
	}
	public void setNo(int no) {
		this.no = no;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getBirth() {
		return birth;
	}
	public void setBirth(String birth) {
		this.birth = birth;
	}
	
}

---

---

5.java：继承

• 关于java语言中的继承：
• 1.继承是面向对象的三大特征之一：封装、继承、多态
• 2.继承的“基本”作用：代码复用，但是继承最“重要”的作用：有了继承才有“方法的覆盖”和“多态机制”。
• 3.继承语法格式：【修饰符列表】class 类名 extends父类名{
• 类体=属性+方法 }
• 4.Java语言中的继承只继承单继承，一个类中不能同时继承很多类，只能继承一个类
• 5.子类继承父类的规则：
  --私有的不支持继承、构造方法不支持继承、其他数据都可以被继承
• 6.在Java语言中虽然只支持单继承，但是一个类也可以间接继承其他类：
• --C extends B{ }
• B extends D{ }
• D extends F{ }
• C间接继承了D、F

1)Jicheng、JichengAccount、Account类

package javase.duixiangchuangjian.Jicheng;

public class Jicheng {
	//Eclipse快捷键：查找类型【Open Type】-->ctrl+shift+t
	//Eclipse快捷键：查找类型【Open Resource】-->ctrl+shift+r
	public static void main(String[] args) {
		Jicheng et=new Jicheng();
		String s=et.toString();//toString方法是系统自带的
		System.out.println(s);
		
		JichengAccount act=new JichengAccount();
		/*以下的代码都是在Account类中的方法，但是JichengAccount类继承了Account类,子类有父类的代码(私有不继承，构造方法不继承),所以act. 可以访问*/
		act.setId(123); 
		act.setMoney(37890.3); 
		act.setName("蒋光明");
	    System.out.println(act.getId()+","+act.getMoney()+","+act.getName());//123,37890.3,蒋光明，通过公开的setter和getter方法间接继承私有属性
	}
}

package javase.duixiangchuangjian.Jicheng;
//继承Account类
public class JichengAccount extends Account  {//JichengAccount继承Account
	String name;
	private double creadit;

	/*系统默认有无参构造函数，在类中只有无参构造时，可不写；若有有参构造方法，最好写无参，以防创建对象时new对象(无参)报错
	 * public JichengAccount() {
	 * 
	 * }
	 */
	public double getCreadit() {
		return creadit;
	}
	public void setCreadit(double creadit) {
		this.creadit = creadit;
	}
}

package javase.duixiangchuangjian.Jicheng;

public class Account {
	private int id;
	private String name;
	private double money;
	public Account() {
		
	}
	public Account(int id, String name, double money) {
		this.id = id;
		this.name = name;
		this.money = money;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getMoney() {
		return money;
	}
	public void setMoney(double money) {
		this.money = money;
	}
	
}

---

2）JichengTest、Test类

package javase.duixiangchuangjian.Jicheng;
/**
 * 结果：4
45.4
45.4
22
Jkchon
do some!

 * */
public class JichengTest {
	int id=4;
	static double money=45.4;
	public static void main(String[] args) {//含有static，不能出现this
		JichengTest v=new JichengTest();
		System.out.println(v.id);//4
		System.out.println(money);//45.4 同类省略类名，static
		System.out.println(JichengTest.money);//45.4
		
		Test test=new Test();
		test.setS(22);
		System.out.println(test.getS());//22
		System.out.println(test.name);//Jkchon
		
		C c=new C();//这里调用的是系统C类默认的无参构造方法
		c.doSome();//doSome是从C继承B继承A，C间接继承A
	}
}

class A{
	public void doSome() {
		System.out.println("do some!");
	}
}
class B extends A{
	
}
class C extends B{
	
}

package javase.duixiangchuangjian.Jicheng;

public class Test {
	private int s;
	String name="Jkchon";
	public int getS() {
		return s;
	}
	public void setS(int s) {
		this.s = s;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

---

---

6.方法覆盖

* 关于Java语言中的方法覆盖：

• 1.方法覆盖又被称为方法重写
• 2.方法覆盖在什么时候使用？
• --当父类中的方法已经无法满足当前子类的业务需求。
• --子类有必要将父类中继承过来的方法进行重新编写
• --这个重新编写的过程叫方法重写
• 3.什么条件会发生方法覆盖？
• --方法重写发生在具有继承关系的父子类之间
• –方法重写的时候：返回值类型相同，方法名相同，形参列表相同
• –方法重写的时候：访问权限不能更低，可以更高（public>protect>private）
• --方法重写的是时候：抛出异常不能更多，可以更少
• 4.方法覆盖时，最好复制粘贴父类，以免出错
• 5.注意：私有方法不能继承，所以不能覆盖;
  构造方法不能继承，所以不能覆盖;
  静态方法不存在覆盖;
  覆盖只针对方法，不谈属性。

package javase.duixiangchuangjian.Fugai;

public class FugaiTest {
	public static void main(String[] args) {
		Animal A=new Animal();
		A.move();
		
		Cat C=new Cat();
		C.move();
		
		Bird B=new Bird();
		B.move();
		
		yingwu y=new yingwu();
		y.move();

	}

}

package javase.duixiangchuangjian.Fugai;

public class Animal {
	public void move() {
		System.out.println("动物在移动！");
	}
}

package javase.duixiangchuangjian.Fugai;

public class Bird extends Animal{
	public void move() {
		System.out.println("鸟在移动！");
	}
}

package javase.duixiangchuangjian.Fugai;

public class Cat extends Animal{
	public void move() {
		System.out.println("猫在移动！");
	}
}

package javase.duixiangchuangjian.Fugai;

public class yingwu extends Bird {
	//此方法覆盖了Bird类中move方法
	public void move() {
		System.out.println("鹦鹉在吃虫");
	}
	
}

---

---

7.java:多态

1)Test、 Animal、Cat 类

package javase.duixiangchuangjian.DuoTai;
/**
 * 多态：向上类型:子类-->父类（自动类型转换）
 *       向下类型：父类-->子类（强制类型转换）
 * */
public class Test {

	public static void main(String[] args) {
		//java语言中特有的多态语法
		Animal A=new Cat();//父类型为引用数据类型，子类型为对象创建，允许这种语法
		A.move();//编译阶段是Animal类，但运行阶段还是Cat对象内存空间，------猫在跑步
		
		Cat C=new Cat();
		C.move();//引用Cat，----猫在跑步
		
		Animal a=new Animal();
		a.move();//引用Animal，----动物在跑步
	}

}

package javase.duixiangchuangjian.DuoTai;

public class Animal {
	public void move () {
		System.out.println("动物在跑步");
	}
}

package javase.duixiangchuangjian.DuoTai;

public class Cat extends Animal{
	public void move () {//重写move
		System.out.println("猫在跑步");
	}
}

---

2）Duotai02、Master、Pet、 Cat 、Dog、Snake类

package javase.duixiangchuangjian.Duotai02;
/**
 * 结果：小猫在吃鱼
小狗正在吃骨头
蛇吞象

 * */
public class Duotai02 {

	public static void main(String[] args) {
		//创建主人对象
		Master zhangsan=new Master();
		//创建猫对象
		Cat tom=new Cat();
		//主人喂养猫
		zhangsan.feed(tom);//引用.feed(实参)调用方法,可以写成zhangsan.feed(new Cat());
		//创建狗对象
		Dog erHa=new Dog();
		//主人喂养小狗
		zhangsan.feed(erHa);//也可以写成zhnagsan.feed(new Dog());
		//创建蛇对象
		Snake snake=new Snake();
		zhangsan.feed(new Snake());
	}
}

package javase.duixiangchuangjian.Duotai02;

public class Master {
//这种方式 没有运用java语言中的多态机制:多态必须在继承的基础上才行，extends
	/*
	public void feed(Cat c) {
		c.eat();	
	}
	public void feed(Dog erHa) {
		erHa.eat();	
	}
	//Master和cat、Dog这两个类型的关联程度很强，耦合度高，扩展力差
	*/

	//降低程序的耦合度，提高程序的扩展力
	//这里运用多态机制，只有一个抽象的Pet，没有具体的动物
	public void feed(Pet pet) {//Pet pet=new Cat()或=new Dog(),父类引用数据类型，创建子类对象，Java允许这种语法
		pet.eat();
	}
}

package javase.duixiangchuangjian.Duotai02;

public class Pet {
	public void eat() {
		Pet pet=new Pet();//写不写都不报错，因为Pet作为父类，继承的基础上创建了子类对象，实际调用的都是子类对象变量，与Pet无关
		
	}
}

package javase.duixiangchuangjian.Duotai02;

public class Cat extends Pet {
	public void eat() {
		System.out.println("小猫在吃鱼");
	}
}

package javase.duixiangchuangjian.Duotai02;

public class Dog extends Pet {
	public void eat() {
		System.out.println("小狗正在吃骨头");
	}
}

package javase.duixiangchuangjian.Duotai02;

public class Snake extends Pet {
	public void eat() {
		System.out.println("蛇吞象");
	}
}

---

---

8.This关键字

• 关于java 中this关键字：
• 1.this是一个关键字，翻译为：这个
• 2.this是一个引用，this是一个变量，this变量中保存了内存地址指向了自身，this存储在jvm堆内存对象内部
• 3.创建100个java对象，每一个对象都有this，就是说100个不同的this
• 4.this可以出现在“实例方法”中，this指向当前执行的动作对象，如果正在执行c1,则this就是c1；如果正在执行c2,则this就是c2。
• 5.this代表当前对象，可以省略this不写
• 6.this不能使用在带有static关键字的方法中
  
• 7.this用在哪些地方：只能用在构造方法、成员方法中；谁去调用这个方法，this就代表谁。
  1)Customer、CustomerTest类

package javase.duixiangchuangjian.This01;
public class Customer {
	String name;//实例变量：必须用"引用."的方式访问
	
	//构造方法：方法名与类名一致，无返回值类型，java自动返回Customer型
	public Customer(){
		
	}
	/**
	 * 1)没有static关键词的方法称为“实例方法”，访问就是"引用.方法"
	 * 2)没有static关键词的变量称为“实例变量”,访问就是“引用.变量”
	 * 3)当需要对象参与时，不需要static关键字
	 * 4)this可以是c1,也可以c2,即this.name为c1.name、c2.name都行
	 * **/
	public void shopping(){//无static关键词方法，说明存在this
		System.out.println(name+"在购物");//this代表当前对象可以省略不写
		System.out.println(this.name+"在shopping");//完整写法，当调用c1.shopping,this就是c1;当调用c2,this就是c2.
	}
	
	//带有static的方法
	public static void doSome(){
		//这个执行过程中没有“当前对象”，因为带static的方法是通过"类名."的方式访问
		//this代表当前执行这个动作的对象，这里类名.访问不了当前对象，故没有this
		//doSome方法调用不是对象去调用，是一个"类名."去调用,执行过程中没有“当前对象”，所以不能访问当前对象的name
		
		//System.out.println(name);//报错，static不存在引用.,除非创建对象
		//System.out.println(this.name);//报错，static不存在引用.,除非创建对象，更不存在this
	}
	
	//通过自己创建的新Customer对象，与之前的对象不同，代表的意义也不同，其static是类名.访问。没有this,只能c.name
	public static void doOther() {
		Customer c=new Customer();//新创建的对象
		System.out.println(c.name);//null,新创建的对象没有赋值，采用默认值
	}

}

package javase.duixiangchuangjian.This01;
/**
 * 结果：c1是张三
c2是李四
张三在购物
张三在shopping
李四在购物
李四在shopping
null

 * */
public class CustomerTest {

	public static void main(String[] args) {
		Customer c1=new Customer();
		c1.name="张三";//赋值操作
		Customer c2=new Customer();
		c2.name="李四";
	    System.out.println("c1是"+c1.name);//c1是张三,不带static的变量用"引用.变量"访问
		System.out.println("c2是"+c2.name);//c2是李四,同上
		c1.shopping();//无static时"引用.方法名"调用，这里无参调用
		c2.shopping();
		//采用“类名.”进行调用，有static
		Customer.doSome();
		//doSome();//省略就报错，因为不在当前类CustomerTest，
		//采用“类名.”进行调用，static
		Customer.doOther();
	}

}

---

2)ThisTest类

package javase.duixiangchuangjian.This02;
/**
 * 结果：12
hello
hello
你好
run execute
你好
你好
hello

 * */
public class ThisTest {
	int num=12;
	//带有static的main方法和其他带static的方法一样
	//都是类名.进行访问，没有当前对象，this没有
	//ThisTest.main(String[] args);调用
	public static void main(String[] args) {
		//System.out.println(this.num);//报错
		//System.out.println(num);//报错
        ThisTest c=new ThisTest();
        System.out.println(c.num);//12
        
        ThisTest.doSome();//类名.
        doSome();//static,当前类，可省略
       // ThisTest.doOther();//报错，实例方法先创建对象，通过引用.进行访问
        c.doOther();//含static的方法中不存在this，只能用引用c去调用实例方法
        c.run();
	}
	public static void doSome() {
		System.out.println("hello");
	}
	public void doOther() {//实例方法
		System.out.println("你好");
	}
	public void run() {//实例方法
		//大括号中执行run时存在了“当前对象”，就是说存在this
		System.out.println("run execute");
		doOther();//doOther是一个实例方法，this一般省略
	    this.doOther();//完整写法，run方法不含static，存在this,调用实例方法可用this调用，不需要创建对象用引用c.
	    doSome();
	}

}

---

3）UserTest 、 User类

package javase.duixiangchuangjian.This02;
//区分局部变量和实例变量不能省略this
public class User {
	//属性
	private int id;
	private String name;
	//构造方法调用，这些私有属性也需要setter and getter方法访问出来（封装）
    /*public void setId(int a) {
		id=a;
	}
	*/
	public void setId(int id) {
		//等号前面的this.id中id是实例变量，等号后面的id是局部变量
		//name也是
		this.id=id;//区分成员变量和局部变量，this.id是成员变量，id是局部变量
	}
	public void setName(String name) {
		this.name=name;
	}
	public int getId() {
		return id;
	}
	public String getName() {
		return name;
	}
	//构造方法
	public User(int id, String name) {
		this.id = id;
		this.name = name;
	}
	public User() {
			
		}
}

package javase.duixiangchuangjian.This02;

public class UserTest {

	public static void main(String[] args) {
		User v=new User();//无参构造调用
	    v.setId(34);//修改属性，赋值操作
		v.setName("张教授");
		System.out.println(v.getId());//34
		System.out.println(v.getName());//张教授
		User t=new User(32,"张起灵");//有参数构造调用，但这些私有属性（带private）还是需要setter和getter访问
		System.out.println(t.getId());//32
		System.out.println(t.getName());//张起灵
	}

}

---

4）Data、 DataTest类

• this可以用在哪里：
• 1.可以使用在实例方法中，代表当前对象【语法格式：this.】
• 2.可以使用在构造方法中，通过当前的构造方法调用其他的构造方法【语法格式：this(实参)；】
• 3.重点：this()这种语法只能出现在构造函数的第一行。
• 4.重要！！！：以后只要不带static的方法，这个方法就存在this,对其访问可以用this.

package javase.duixiangchuangjian.This03;

public class Data {
	//私有属性
	private int year;
	private int month;
	private int day;
	//构造函数
	public Data(int year, int month, int day) {//带参数
		this.year = year;
		this.month = month;
		this.day = day;
	}
	//默认创建日期是1970-7-8
	public Data() {
	/*
	this.year=1970;
	this.month=7;
	this.day=8;
	以上代码可以通过调用另一个构造方法完成，但前提是不能创建新的对象
	//new Data=(1970,7,8)
	 * 需要采用以下语法完成构造方法的调用，这种方式不会创建新的java对象，但同时又可
	 * 以达到调用其他构造方法的目的
	*/
	this(1970,7,8);
	}
	//setter and getter
	public int getYear() {
		return year;
	}
	public void setYear(int year) {
		this.year = year;
	}
	public int getMonth() {
		return month;
	}
	public void setMonth(int month) {
		this.month = month;
	}
	public int getDay() {
		return day;
	}
	public void setDay(int day) {
		this.day = day;
	}
	//对外提供一个实例方法，不带static(当中可以出现this)，引用.
	public void print() {
		System.out.println(this.year+"年"+this.month+"月"+this.day+"日");
	}
	
}

package javase.duixiangchuangjian.This03;
/**1.两个不带static方法就是this.
 * 2.各种调用形式结果：static调static，实例方法调实例方法，static调实例，实例调static
 * 1970年7月8日
2个不带static方法用this调用
2个不带static方法用this调用
实例方法调用static方法
2个不带static方法用this调用
12
实例方法调用static方法
2个不带static方法用this调用
12
2009年8月7日
实例方法调用static方法
2个不带static方法用this调用
12

 * */
public class DataTest {
	int h=12;//类体中，成员变量，不带static，“引用.变量”访问
	static int m=67;
	public static void main(String[] args) {
	Data time1=new Data();//构造调用
	time1.print();//引用.方法名，实例方法（不带static）调用

	DataTest v=new DataTest();
	v.time();
	
	Data time2=new Data(2009,8,7);//构造调用
	time2.print();//引用调用
	//System.out.println(this.year+"年"+this.month+"月"+this.day+"日");//不能使用this在static方法中
	doSome();
	}
	//不带static方法(当中能出现this)
	public void time() {
		/*System.out.println(this.year+"年"+this.month+"月"+this.day+"日");//访问不了，这些实例变量存在Data类中，
		 * 不在DataTest类中，所以即使访问了time方法，也编译不出来this，压根就不是一个类，也不是当前对象
		 */
		this.doOther();//time实例方法不带static，存在this，doOther实例方法也如此，2个实例方法，就用this.方法名调用
		doOther();//省略this
		DataTest.doSome();
		doSome();//省略DataTest,一个类中doSome带有static
	}
	//不带static方法
	public void doOther() {
		System.out.println("2个不带static方法用this调用");
	}
	//带static方法(当中不能出现this)
	public static void doSome() {
		System.out.println("实例方法调用static方法");
		DataTest b=new DataTest();
		b.doOther();
		System.out.println(b.h);//引用.访问变量h
		
	}

}

---

---

9.Static关键字

1.什么时候成员变量声明为实例变量？

• --所有对象都有这个属性，但是这个属性的值会随着对象的变化而变化【不同对象的这个属性具体的值不同】
  
  2.什么时候成员变量声明为静态变量呢？
• –所有对象都有这个属性，并且所有对象的这个属性的值是一样的，建议定义为静态变量，节省内存的开销。
  *静态变量在类加载的时候初始化，内存在方法区中开辟，访问的时候不需要创建对象，直接使用“类名.静态变量名”方式访问。
  
  1)Chinese、ChineseTest类

package javase.duixiangchuangjian.Static;

public class Chinese {
	String id;//实例变量,引用.访问
	String name;//实例变量
	static String country="中国";//静态变量，带static类名.访问
	public Chinese(String id, String name) {
		this.id = id;
		this.name = name;
	}
	
}

package javase.duixiangchuangjian.Static;
/*结果：23011399402346534,张三,中国
23011337702346534,李四,中国

 * */
public class ChineseTest {

	public static void main(String[] args) {
		Chinese zhangsan=new Chinese("23011399402346534","张三");
		System.out.println(zhangsan.id+","+zhangsan.name+","+Chinese.country);//类名.访问country
		Chinese lisi=new Chinese("23011337702346534","李四");
		System.out.println(lisi.id+","+lisi.name+","+Chinese.country);
		
		

	}

}

2)StaticTest01类

• 可以使用static关键字来定义“静态代码块”：
• 1.语法格式：
• static{

•   <font color="red"> java语句；
  

• }
• 2.静态代码块在类加载时执行，并且只执行一次
• 3.静态代码块在一个类中可以编写多个，并遵循自上而下的顺序依次执行
• 4.预备阶段，项目开始时

package javase.duixiangchuangjian.Static;

public class StaticTest01 {
	static {
		System.out.println("类加载--->1");
	}
	static {
		System.out.println("类加载--->2");
	}
	static {
		System.out.println("类加载--->3");
	}
	public static void main(String[] args) {
		System.out.println("main begian");

	}

}

3)Test类

• 实例语句块/代码块
• 1、实例代码块可以编写多个，也是遵循自上而下的顺序执行
• 2、实例代码块在构造方法块执行之前执行，构造方法依次执行
• 3、实例代码块也是java语言为程序员准备的特殊时机，对象初始化时期

package javase.duixiangchuangjian.Static;
/**
 * 结果：
 * hello
1
2
3
实例代码块在构造方法块执行之前执行
1
2
3
实例代码块在构造方法块执行之前执行
 * */
public class Test {
	//构造函数
	public Test() {
		System.out.println("实例代码块在构造方法块执行之前执行");
	}
	//实例代码块
	{
		System.out.println(1);
	}
	//实例代码块
	{
		System.out.println(2);
	}
	//实例代码块
	{
		System.out.println(3);
	}
	public static void main(String[] args) {
		System.out.println("hello");
		new Test();//创建无参构造方法
		new Test();//创建构造方法
	}
}

---

---

10.Final关键字

• 关于java语言中的final关键字：
• 1.final是一个关键字，表示最终的，不可变的。
• 2.final修饰的类无法被继承
• 3.final修饰的方法无法被覆盖
• 4.final修饰的变量一旦被赋值，不可重新赋值
• 5.fianl修饰的实例变量，必须手动赋值，不能采用系统默认值
• 6.final修饰的引用，一旦指向某个对象，不能再指向其他对象，但原先的对象内部内存可以更改
• 7.public static final 类型 常量名(大写)=值；
  
  
• 关于eclipse怎么链接源码?
• -打开某个.class字节码文件，当没有看到源码的时候：
• -点击“Attached Source ”:
• -Workspace…[源码在当前的工作区当中]
• –External Folder…[源码在某个目录里]

1)final01类，final修饰的变量一旦被赋值，不可重新赋值

package javase.duixiangchuangjian.Final;
public class final01 {
    //成员变量之实例变量
	//实例变量有默认值+final修饰的变量一旦被赋值不能重新赋值
	//final int age;报错，不能采用系统默认值
	
	//第一种解决方案
	final int age=23;//手动赋值
	
	//第二种解决方案
	final int num;
	public final01() {
		this.num=90;
	}
	public static void main(String[] args) {
		final int k;
		k=90;
		//k=45;final修饰的变量一旦被赋值，不可重新赋值
		
		final int z=88;
		//z=89;报错，不能二次赋值
	}
}

---

2)final02、Uesr类，final修饰的引用，一旦指向某个对象，不能再指向其他对象，但原先的对象内部内存可以更改

package javase.duixiangchuangjian.Final;

public class final02 {
	public static void main(String[] args) {
		//创建用户对象
		Uesr u=new Uesr(129);//Uesr u=0x1234
		
		//又创建了一个新的Uesr对象
		//程序执行到此处表示以上对象已变成垃圾数据，等待垃圾回收器的回收。
		u= new Uesr(34);//u=0x2345
		
		//创建用户对象
		final Uesr uesr=new Uesr(45);
		//uesr=new Uesr(67);//final修饰的引用，一旦指向某个对象，不能再指向其他对象，但原先的对象内部内存可以更改
		System.out.println(uesr.getId());//45
		uesr.setId(78);//这是在原先的对象内部进行更改
		System.out.println(uesr.getId());//78
		
		
		
	}
}

package javase.duixiangchuangjian.Final;

public class Uesr {
	private int id;
	private String account;
	//构造函数
	public Uesr() {
		super();
	}

	public Uesr(int id) {
		super();
		this.id = id;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getAccount() {
		return account;
	}

	public void setAccount(String account) {
		this.account = account;
	}
}

---

3）FinalTest类，public static final 类型 常量名(大写)=值；

package javase.duixiangchuangjian.Final;

public class FinalTest {
	public static void main(String[] args) {
		System.out.println(Chinese.GUO_JI);
		System.out.println(Math.PI);
	}
}

class Chinese{
	//public static final 类型 常量名(大写)=值；
	//final修饰的实例变量是不可变的，static存在是指这个变量值不需要变化，节省内存
    public static final String GUO_JI="中国";
}
class Math{
	public static final double PI=3.1415926;
}

---

4）A、B类，final修饰的类无法被继承，方法无法被覆盖

package javase.duixiangchuangjian.Final;

/*最终类A
 * public final class A {
 * 
 * }
 */
public class A{
	public final void move() {
		
	}
}

package javase.duixiangchuangjian.Final;

/*B不能继承A类，因为A类是final（最终的），不能被继承
 * public class B extends A {
 * 
 * }
 */
public class B extends A{
	

	/*
	 * public void move() {//报错，final修饰的方法无法覆盖
	 * 
	 * }
	 */
}

---

---

11.package、import

1.当两个类名不在同一个目录下，或者说不在同一个包下，分属两个不同的包，则需要加全部路径才能调用（创建对象），引入import包。
2.注：import语句用来完成导入其他类，同一个包下的类不需导入；
语法格式：import 类名 或 import 包名.*
3.import语句需要编写在package语句之下，class语句之上
4.java.lang.*不需手动导入，系统自动导入lang包，但是某些系统包也要导入，比如date包

package javase.duixiangchuangjian.Import;

//eclipse快捷键导包:ctrl+ shift+ o
//导入不同Test类的Cat类包，后面才能调用Cat，因为Cat与Test类属于不同的目录
import javase.duixiangchuangjian.Duotai02.Cat;//import 类名;
//import javase.duixiangchuangjian.Duotai02.*;这种方式也行：import 包名.*;

public class Test {

	public static void main(String[] args) {
		Cat c=new Cat();
		System.out.println(c);//结果：javase.duixiangchuangjian.Duotai02.Cat@2a84aee7
		
		//Cat c=new Cat();不加import包，则编译报错，因为不同目录下的类调用需要import导入包
		
		//这样写就不用开头写import包了，但是这样写比较繁琐，还是建议写import包
		javase.duixiangchuangjian.Duotai02.Cat t=new javase.duixiangchuangjian.Duotai02.Cat();
		System.out.println(t);//结果：javase.duixiangchuangjian.Duotai02.Cat@a09ee92
	}

}

---

---

12.访问权限符

• public:公有的，在任何位置都可以访问
• protected：同包下，子类都可以访问
• 缺省（不写）：同包下访问
• private：私有，只能在本类中访问
• private<缺省<protected<public
• 这些权限符可以修饰类、方法、变量······

package javase.duixiangchuangjian.Quanxianfu;

//以下是修饰变量的，修饰方法和类自己考虑
public class Quanxian {
	//以下都是实例或者静态变量
	public int i=23;
	long s=12L;//缺省
	protected String name="张三";
	private int b=34;
	private static double d=78.9;
	public static void main(String [] args) {
		Quanxian c=new Quanxian();
		System.out.println(c.b);//34  私有，本类访问 
		System.out.println(Quanxian.d);// 78.9  私有，本类访问或者System.out.println(d);
		System.out.println(c.i);//23  public访问
		int k=33;
		System.out.println(k);//33 缺省同包下访问
		System.out.println(c.name );///张三
		
	}
}

---

package javase.duixiangchuangjian.Quanxianfu;

public class test extends Quanxian {

	public static void main(String[] args) {
		Quanxian x=new Quanxian();
		System.out.println(x.s);//缺省，同包下
		System.out.println(x.i);//23,public公有的
		System.out.println(x.name);//protect，同一个包，子类中
		/*
		 * 私有，只能在本类
		 * System.out.println(x.b); 
		 * System.out.printlan(Quanxian.d);
		 */

	}

}