java day06 封装及构造器练习

落日映苍穹つ 2022-04-14 06:39 148阅读 0赞

## 对象的创建和使用练习： ##

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;
    	}
    	
    }