一、什么是类

具有相同方法和属性的一组对象的集合

二、什么是对象

用来描述客观事物的一个实体，由一组属性和方法构成

三、方法和属性是什么

属性：对象具有的特征

方法：对象执行的操作

四、什么是方法重载（附码）

重载，简单说，就是函数或者方法有相同的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。在java中同一个类中的2个或2个以上的方法可以有同一个名字，只要它们的参数声明不同即可。这种情况下，该方法就被称为重载，这个过程称为方法重载，通俗的讲就是省了给method命名了.差不多的都用一个.

 public class OverloadDemo {
       void test(){                                   //test()方法第一次重载，没有参数
              System.out.println("No parameters");
       }
       void test(int a){                             //test()方法第二次重载，一个整型参数
              System.out.println("a: "+a);
       }
       void test(int a,int b){                        //test()方法第三次重载，两个整型参数
              System.out.println("a and b: "+a+" "+b);
       }
       double test(double a){                     //test()方法第四次重载，一个双精度型参数
              System.out.println("double a: "+a);
              return a*a;                        //返回a*a的值
       }
}

结果：

public class Overload {
       public static void main(String args[]){
              OverloadDemo ob=new OverloadDemo();
              double result;
              ob.test();            //定义的是test()方法
              ob.test(10);             //定义的是test(int a)方法
              ob.test(10,20);            //定义的是test(int a,int b)方法
              result=ob.test(123.23);       //定义的是test(double a)方法
              System.out.println("result of ob.test(123.23): "+result);   //输出result的值
       }
}
运行结果：    No parameters
a: 10
a and b: 10 20
double a: 123.23
result of ob.test(123.23): 15185.6329

五、Eclipes常用快捷键

Alt + / 内容提示：
Ctrl + 1 提示
Ctrl + shift + O 导包
Ctrl + Shift + F 格式化代码块
Alt+上下键代码位置调换
Ctrl+/ 添加/除去单行注释
Ctrl+Shift+/ 添加多行注释
Ctrl+Shift+\ 删除多行注释
window->reset perspective 重置透视图
Ctrl+Shift+X 更改为大写
Ctrl+Shift+Y 更改为小写
Ctrl+Alt+向下键复制行
Ctrl+单击需要查看源码的类
Ctrl+Shift+T 需要查看源码的类

注意: 快捷键的冲突:

例如: 输入法的简繁体切换就是ctrl +shift+f .

六、其他

实参和形参

1。函数的形参列于函数声明中，在函数定义的函数体内使用。当函数调用时，形参（任何种类的）是一类将被填充的空白或是占位符。
用来填充形参
2。实参是用来填充形参的。当函数被调用时，实参列在函数名后面的括号里。执行函数调用时，实参被传递给形参

float单精度

double多精度

方法构造(附代码)

1、构造方法的特点：

package com.lenovo.www.day10;

/**
 * 测试类
 * 
 * @author lenovo64
 *这只小狗是小白，白色正在和那只小猫叫做小黑，黑色在打架
 *获胜的动物是黑色
 */
public class Test {
	public static void main(String[] args) {

		Animal dog = new Animal("小黑", "小猫", "黑色");
		Animal cat = new Animal("小白", "小狗", "白色");
		String s = dog.play(cat, dog);
		System.out.println("获胜的动物是" + s);
	}
}

class Animal {
	String name;
	String kind;
	int age;
	String color;
	long animalID;
	String date;

	public Animal(String name, String kind) {
		this.name = name;
		this.kind = kind;
	}

	public Animal(String name, String color, String kind) {
		this.name = name;
		this.color = color;
		this.kind = kind;
	}

	public Animal(String name, int age, long animalID) {
		this.age = age;
		this.animalID = animalID;
	}

	public String play(Animal dog, Animal cat) {
		System.out.println("这只" + dog.color + "是" + dog.name + "，" + dog.kind + "，正在和那只" + cat.color + "叫做" + cat.name
				+ "，" + cat.kind + "，在打架");
		return cat.kind;
	}
}

package com.zjm.www.day10;
/**+
 * 
 * 动物练习
 * @author Zjm
 *
 */
public class Ex_animal {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Animal an1 = new Animal("兔子","草",5);
		Animal an2 = new Animal();
		Animal an3 = new Animal(an1,an2);
		an2.all(an3);
	}
}
class Animal{
	String name;
	String eat;
	int weight;
	public Animal() {
		this.name = name;
		this.eat = "猪蹄";
		this.weight = 12;
	}
	public Animal(Animal a,Animal b) {
		this.name = b.name;
		this.eat = a.eat;
		this.weight = b.weight;
		
	}
	public Animal(String name,String eat,int weight) {
		this.name = name;
		this.eat = eat;
		this.weight = weight;
	}
	public Animal(String name,int weight) {
		this.name = name;
		this.weight = weight;
	}
	public void eat1() {
		System.out.println("这个动物喜欢吃" + this.eat);
	}
	public void run() {
		System.out.println("这个动物会跑");
	}
	public void all(Animal an) {
		System.out.println("这是一只 " + this.name + "，它喜欢吃 " + an.eat + ",它重 " + an.weight +" 斤");
	}
}

构造方法的方法名称与类名一致
构造方法的没有返回值

2、构造方法的功能：主要是对类中的实例变量进行初始化
3、构造方法的调用：在主函数新建一个类相应的引用变量时，会调用相应的构造方法对变量进行初始化（注意这里是相应的构造方法，一定不要误解为所有的构造方法都会被调用），当一个类中没有声明构造方法时，编译器会自动生成一个无参的构造方法，但是如果你声明了一个有参的构造方法，那么编译器不会再生成一个无参的构造方法，此时如果你在主函数中声明一个类的引用变量且无参时就会出现编译出错的情况。

4、构造方法的重载

在上面的例子中，没有定义构造方法，如果我们定义构造方法时，可以定义一个无参的构造方法和一个有参的构造方法，这样一来，无参的构造方法和有参的构造方法就是方法的重载，定义一个无参的构造方法的好处就在于当主函数忘记给对象中的实例变量赋值时，无参的构造函数可以给变量进行初始化

5、同类构造方法之间的实现
对与在同一个类中的构造方法之间的调用主要是构造方法中参数列表较多的调用参数列表较少的

七、

封装

①　把对象的状态和行为看成一个统一的整体，将二者存放在一个独立的模块中(类);
②　"信息隐藏", 把不需要让外界知道的信息隐藏起来,尽可能隐藏对象功能实现细节，向外暴露方法，保证外界安全访问功能;  把所有的字段使用private私有化,不准外界访问,把方法使用public修饰,允许外界访问.
       把所有数据信息隐藏起来,尽可能隐藏多的功能,只向外暴露便捷的方法,以供调用.

封装的好处

◆1):使调用者正确,方便地使用系统功能,防止调用者随意修改系统属性.
◆2):提高组件的重用性.
◆3):达到组件之间的低耦合性(当某一个模块实现发生变化时,只要对外暴露的接口不变,就不会影响到其他模块).

通过什么来实现隐藏和暴露功能呢？
高内聚：把该模块的内部数据，功能细节隐藏在模块内部，不允许外界直接干预。
低耦合：该模块只需要给外界暴露少量功能方法

访问权限修饰符

private:         表示私有的, 表示类访问权限. 只能在本类中访问,离开本类之后,就不能直接访问.
不写(缺省): 表示包私有,表示包访问权限. 访问者的包必须和当前定义类的包相同才能访问.
protected:    表示子类访问权限,同包中的可以访问,即使不同包,但是有继承关系,也可以访问.
public:           表示全局的,可以公共访问权限,如某个字段/方法,使用了public修饰,则可以在当前项目中任何地方访问.

。

访问权限修饰符的使用

一般的，字段都使用private修饰,表达隐藏,为了安全性.
方法我们使用public修饰,供外界直接调用.拥有实现细节的方法,一般使用private修饰,不希望外界(调用者)看到该方法的实现细节.
我们不用缺省,即使要使用,也仅仅是暴露给同包中的其他类.
protected:一般,在继承关系中,父类需要把一个方法只暴露给子类.

面向对象一

封装

猜你喜欢