对象的创建和使用练习:
package com.huake.java;
public class TestCar {
public static void main(String[] args) {
Car c=new Car();
c.info();
c.setName("玛莎拉蒂");
c.setWheel(4);
c.info();
Factory f=new Factory();
Car c1=f.produceCar();
f.describeCar(c1);
Car c2=f.produceCar("沃尔沃",4);
f.describeCar(c2);
}
}
class Factory{
//制造车(以下两个方法构成重载)
public Car produceCar(){
return new Car();
}
public Car produceCar(String n,int w){
Car c =new Car();
c.name=n;
c.wheel=w;
return c;
}
//描述车的信息
public void describeCar(Car c){
c.info();
}
}
class Car{
//1.属性
String name;
int wheel;
//2.方法
public void info(){
System.out.println("name:"+name+"wheel:"+wheel);
}
public void show(){
System.out.println("我是一辆车");
}
public String getName(){
return name;
}
public void setName(String n){
name=n;
}
public void setWheel(int w){
wheel=w;
}
}
对象作为参数传递的练习:
package com.huake.exer;
/*
* (1)定义一个Circle类,包含一个double类型的radius属性代表圆的半径,
* 一个findArea()方法返回元的面积
* (2)定义一个类PassObject,在类中定义一个方法printAreas(),该方法的定义如下
* public void printAreas(Circle c,int time)
* 在printAreas方法中打印输出1到time之间的每个整数半径值,以及对应的面积。
* 例如:time为5,则输出半径1,2,3,4,5以及对应的面积
* 在main方法中调用printAreas()方法,调用完毕后输出当前半径值*/
public class PassObject {
public void printAreas(Circle c,int time){
System.out.println("Radius"+"\t\t"+"Area");
// for(int i=1;i<=time;i++){
// c.setRadius(i);
// System.out.println(c.getRadius()+"\t\t"+c.findAreas());
// }
int i=1;
while (i<=time){
c.setRadius(i);
System.out.println(c.getRadius()+"\t\t"+c.findAreas());
i++;
}
c.setRadius(i);
}
public static void main(String[] args) {
PassObject p=new PassObject();
Circle c=new Circle();
p.printAreas(c, 5);
System.out.println("now radius is "+c.getRadius());
}
}
class Circle{
double radius;
public double findAreas(){
return radius*radius*3.14;
//return 3.14*getRadius()*getRadius();
}
public void setRadius(double r){
radius=r;
}
public double getRadius(){
return radius;
}
}
一.匿名类对象:创建的类的对象是匿名的
1)当我们只需要一次调用类的对象的时候,我们可以考虑使用匿名的方式创建类的对象
2)特点:创建的匿名类的对象 只能调用一次
二.体会可变个数的形参:
下面采用数组形参来定义方法
public static void test(int a,String [] books);
以可变个数形参来定义方法
public static void test(int a,String ...books);
说明:
1.可变参数:方法参数部分指定类型的参数个数是可变多个
2.声明方式:方法名(参数的类型名.....参数名)
3.可变参数方法的使用与方法参数部分使用数组是一致的
4.方法的参数部分有可变形参,需要放在形参声明的最后
可变参数的使用
package com.huake.java;
/*可变形参个数的方法
* 1.格式:对于方法的形参:数据类型 ...形参名
* 2.可变个数的形参的方法与同名的方法之间构成重载
* 3.可变个数的形参在调用时,个数从0个开始,到无穷多个都可以。
* 4.使用可变多个形参的方法与方法的形参使用数组是一致的
* 5.若方法中存在可变个数的形参,那么一定要声明在方法形参的最后
* 6.在一个方法中,最多声明一个可变个数的形参
*/public class TestArgs {
public static void main(String[] args) {
TestArgs t=new TestArgs();
t.sayHello();
t.sayHello(new String []{"hello china ","hello beijing"});
}
//以下四个方法构成重载
//在类中 一旦定义了重载的可变个数的形参的方法以后,以下两个方法可以省略,因为都可以包含了
// public void sayHello(){
// System.out.println("Hello World!");
// }
// public void sayHello(String str1){
// System.out.println("hello"+str1);
// }
//可变个数的形参的方法
public void sayHello(String ... args){
for(int i=0;i<args.length;i++){
System.out.println(args[i]+"$");
}
}
public void sayHello(int i,String ... args){
//public void sayHello(String ... args,int i){ 错误
System.out.println(i);
for(int i=0;i<args.length;i++){
System.out.println(args[i]+"$");
}
}
public void sayHello1(String [] args){
for(int i=0;i<args.length;i++){
System.out.println(args[i]);
}
}
//可变个数形参的使用
// public int getSum(int i,int j){
// return i+j;
// }
// public int getSum(int i,int j,int k){
// return i+j+k;
// }
public int getSum(int ... args){
int sum=0;
for(int i=0;i<args.length;i++){
sum+=args[i];
}
return sum;
}
}
方法的参数传递
方法:必须有其所在类或对象调用才有意义
方法含有参数:
形参:方法声明时的参数
实参:方法调用时实际传给形参的参数值
java的实参值如何传入方法呢?
java里方法的参数传递方式只有一种:值传递。 即将实际参数值的副本(复制品)传入方法内,而参数本身不受影响。
封装的基本概念
package com.huake.java;
/*
* 面向对象的特征一:封装与隐藏
* 1.当创建了类的对象以后,如果直接通过“对象.属性”的方式对相应的对象的属性赋值的话,可能会出现不满足实际情况的意外
* 我们考虑不让对象直接来最用属性,而是通过“对象 .方法”的形式来控制对象对属性的访问,
* 实际情况中,对属性的要求可以通过方法来体现
*
* 解决的方法:(封装性的思想)将类的属性私有化,提供公共的方法来调用*/
public class TestAnimal {
public static void main(String[] args) {
Animal a=new Animal();
// a.name="花花";
// a.legs=4;
a.setLegs(4);
a.setName("小花");
a.info();
a.eat();
}
}
class Animal{
//private修饰的属性,只能在本类中被调用,出了此类,就不能被调用了
private String name;
private int legs;
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
public void info(){
System.out.println("name:"+name+"legs:"+legs);
}
//设置类的属性
public void setLegs(int l){
if(l>0&&l%2==0){
legs=l;
}else
System.out.println("您输入的数据有误");
}
//获取类的属性
public int getLegs(){
return legs;
}
public void setName(String n){
//...条件
name=n;
}
public String getName(){
return name;
}
}
封装性案例一
package com.huake.java1;
public class Animal{
//private修饰的属性,只能在本类中被调用,出了此类,就不能被调用了
private String name;
private int legs;
String color ;
public double weight;
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
public void info(){
System.out.println("name:"+name+"legs:"+legs);
}
//设置类的属性
public void setLegs(int l){
if(l>0&&l%2==0){
legs=l;
}else
System.out.println("您输入的数据有误");
}
//获取类的属性
public int getLegs(){
return legs;
}
public void setName(String n){
//...条件
name=n;
}
public String getName(){
return name;
}
}
package com.huake.java1;
/*
* 一、面向对象的特征一:封装与隐藏
* 1.当创建了类的对象以后,如果直接通过“对象.属性”的方式对相应的对象的属性赋值的话,可能会出现不满足实际情况的意外
* 我们考虑不让对象直接来最用属性,而是通过“对象 .方法”的形式来控制对象对属性的访问,
* 实际情况中,对属性的要求可以通过方法来体现
*
* 解决的方法:(封装性的思想)将类的属性私有化,提供公共的方法来调用
* 二、权限修饰符 :public private 缺省 protectd 置于类的成员定义前,用来限定对象对该类成员的访问权限
* 可以用来修饰属性,方法
* 注:权限从大到小排列: public protected 缺省 private
* private:只能在类内部被访问
* 缺省:可以在类内部或者同一个包内被访问
* protected:可以在类内部,同一个包,子类被访问
* public:在任何地方都可以被访问
* 对于class的权限修饰只可以用public和default(缺省)
* */
public class TestAnimal {
public static void main(String[] args) {
Animal a=new Animal();
// a.name="花花";
// a.legs=4;
a.setLegs(4);
a.setName("小花");
a.info();
a.eat();
a.color="white";
}
}
package com.huake.java;
import com.huake.java1.Animal;
public class TestAnimal1 {
public static void main(String[] args) {
Animal a=new Animal();
a.eat();
a.weight=5.3;
a.setLegs(4);
}
}
封装性案例二
package com.huake.java;
/*
* 创建程序,在其中定义两个类,Person和TestPerson类,定义如下
* 用setAge()设置人的合法年龄(0-130),用getAge()返回人的年龄
* 在TestPerson中实例化Person类的对象b,调用setAge()和getAge()方法,体会java的封装性
* */
public class TestPerson {
public static void main(String[] args) {
Person p=new Person();
p.setAge(12);
System.out.println(p.getAge());
}
}
class Person{
private int age;
public int getAge(){
return age;
}
public void setAge(int a){
if(a>0&&a<130){
age=a;
}else{
System.out.println("输入有误");
}
}
}
构造器
package com.huake.java;
/*类的第三个成员:构造器(constructor 构造方法)
* 构造器的作用:创建对象,给创建的对象的属性赋值
* 1.设计类时,若不显示的声明类的构造器的话,程序会默认提供一个空参 的构造器
* 2.一旦显示的定义类的构造器,那么默认的构造器不再提供
* 3.如何声明类的构造器, 格式:权限修饰符 类名(形参){}
* 4.类的多个构造器之间构成重载
*
* 二、类对象的属性赋值的先后顺序:
* 1.属性的默认初始化
* 2.属性的显示赋值
* 3.通过构造器给属性初始化
* 4.通过对象.方法的方式给属性赋值
* */
public class TestPerson1 {
public static void main(String[] args) {
Person p=new Person(); //new了一个构造器
System.out.println();
String str=new String("com.huake.java");
System.out.println(str);
Person p2=new Person("高鹏");
System.out.println(p2.getName());
System.out.println(p2.getAge());
Person p3=new Person("张三",12);
System.out.println("name:"+p3.getName()+"age:"+p3.getAge());
//体会属性赋值的过程
Person p4=new Person();
System.out.println("name:"+p4.getName()+"age:"+p4.getAge());
Person p5=new Person(12);
System.out.println("name:"+p5.getName()+"age:"+p5.getAge());
}
}
class Person{
//属性
private String name;
private int age;
//构造器
public Person(String n ){
name=n;
}
public Person(){
age=10;
name="李四";
}
public Person(int a){
age=a;
}
public Person(String n,int a){
name=n;
age=a;
}
//方法
public void setName(String n){
name=n;
}
public String getName(){
return name;
}
public void setAge(int a){
age=a;
}
public int getAge(){
return age;
}
}