面向对象：
一、人把大象装进冰箱的
面向过程(pop):强调的是功能行为，以函数为最小单位，考虑怎么做。
1.把冰箱门打开
2.抬起大象，塞进冰箱
3.把冰箱门关闭
面向对象（oop）:扯调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
人{
打开（冰箱）{}
抬起（大象）{}
关闭（冰箱）{}
}
冰箱{
开门（）{}
关门（）{}
}
大象{
能够进入（冰箱）{}
}
面向对象的两个要素:
类:对一类事物的描述，是抽象的、概念上的定义
对象:是实际存在的该类事物的每个个体，因而也称为实例(instance)
面向对象程序设计的重点是类的设计
设计类，就是设计类的成员。
属性=成员变量= field =域、字段
方法=成员方法=函数=method
创建类的对象=类的实例化=实例化类|
二、类和对象的使用（面向对象思想落地的实现）:
1.创建类，设计类的成员
2.创建类的对象
3.通过"对象.属性或对象.方法"调用对象的结构
//测试类
public class demo {
//main方法提供测试入口
public static void main(String[] args) {
//创建Person类的对象
Person p1=new Person();
//调用对象的属性(对象.属性)
p1.name="Tom";
p1.isMale=true;
System.out.println(p1.name);
System.out.println(p1.isMale);
System.out.println(p1.age);
//调用对象的方法(对象.方法)
p1.eat();
p1.sleep();
p1.talk("中文");
}
}
class Person{
//属性：
String name;
int age=1;
boolean isMale;
//行为，方法
public void eat() {
System.out.println("人可以吃东西");
}
public void sleep() {
System.out.println("人可以睡觉");
}
public void talk(String langu) {
System.out.println("人可以交流:"+langu);
}
}
运行结果：
三、如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。(非static的)
意味着:如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。
四：类中属性的应用
/*
* 类中属性的使用
*
*属性(成员变量)vs局部变量
*1.相同点:
* 1.1定义变量的格式:数据类型变量名=变量值
* 1.2先声明，后使用
* 1.3变量都有其对应的作用域
*
*2.不同点:
* 2.1在类中声明的位置的不同
* 属性:直接定义在类的一对{0}内
* 局部变量:声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
*
* 2.2关于权限修饰符的不同
* 属性:可以在声明属性时，指明其权限,使用权限修饰符。
* 常用的权限修饰符:private. public、缺省、protected
* 局部变量：不可以使用权限修饰符
*
* 2.3默认初始化值的情况:
* 属性:类的属性，根据其类型，都有默认初始化值。
* 整型（byte. short. int、long) : 0
* 浮点型（float. double) : 0.0
* 字符型（char) : (0或'\lue000 ')
* 布尔型（boolean): false
* 引用数据类型（类、数组、接口): null
*
* 局部变量:没有默认初始化值。
* 意味着，我们在调用局部变量之前，一定要显式赋值。
* 特别地:形参在调用时，我们赋值即可。
*
* 2.4在内存中加载的位置:
* 属性:加载到堆空间中(非static)
* 局部变量:加载到栈空间
*/
public class UserTest {
public static void main(String[] args) {
User u1=new User();
System.out.println(u1.age); //结果是：0
System.out.println(u1.name); //结果是：null
System.out.println(u1.isMale); //结果是：false
u1.talk("中文"); //打印结果：我们使用中文进行交流
u1.eat(); //打印结果：北方人爱吃烙饼
}
}
//属性(成员变量)
class User{
String name;
int age;
boolean isMale;
public void talk(String language) {
//language:形参，也是局部变量
System.out.println("我们使用"+language+"进行交流");
}
public void eat() {
String food="烙饼";
System.out.println("北方人爱吃"+food);
}
}
类中方法的声明和使用
*
* 方法:描述类应该具有的功能。
* 比如:Math类:sqrt() \random() \...
* scanner类:nextXxx() ...
* Arrays类: sort() \ binarySearch() \ toString() \ equals()
*
* 1.举例：
* public void eat(){
} //void无返回值的意思
* public void sleep(int hour){
}
* public String getName(){
}
* public String getNation (String nation){
}
*
* 2.方法的声明:权限修饰符 返回值类型 方法名(形参列表){
* 方法体
* }
* 3．说明:
* 3.1关于权限修饰符:默认方法的权限修饰符先都使用public
* Java规定的4种权限修饰符:private.public、缺省、protected-->封装性再绍细讲
*
* 3.2返回值类型:有返回值vs没有返回值
* 3.2.1如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用
* return关键字来返回指定类型的变量或常量。"return 数据"
* 如果方法没有返回值，则方法声明时，使用void来表示。
* 通常，没有返回值的方法中，就使用return.但是，如果使用的话，
* 只能"return;"表示结束此方法的意思。
* 3.2.2我们定义方法该不该有返回值?
* 题目要求
* 凭经验:具体问题具体分析
* 3.3 方法名:属于标识符,遵循标识符的规则和规范，"见名知意"
* 3.4 形参列表:方法可以声明0个，1个，或多个形参。
* 3.4.1格式:数据类型1形参1,数据类型2形参2,...
* 3.4.2是否需要形参
* ①题目要求
* ②凭经验:具体问题具体分析
* 3.5方法体：方法功能的实现
*/
类的设计课后练习题：
/*
* 要求:
* (1)创建Person类的对象，设置该对象的name、age和sex属性，
* 调用study方法，输出字符串“studying”，
* 调用showAge()方法显示age值，
* 调用addAge()方法给对象的age属性值增加2岁。
* (2)创建第二个对象，执行上述操作，体会同一个类的不同对象之间的关系。
*
*/
public class PersonTest {
public static void main(String[] args) {
Person p1=new Person();
p1.name="Tom";
p1.age=18;
p1.sex=1;
p1.study();
p1.showaAge();
int newage=p1.addAge(2);
System.out.println(p1.name+"的新年龄为"+newage);
System.out.println(p1.age);
System.out.println("***********************");
Person p2=new Person();
p2.showaAge(); //打印结果是0
p2.addAge(10);//给加上10岁
p2.showaAge();//打印结果为10岁
}
}
class Person{
String name;
int age;
/**
* sex:1是男性，0是女性
*/
int sex;
public void study() {
System.out.println("studying");
}
public void showaAge() {
System.out.println("age:"+age);
}
public int addAge(int i) {
age+=i;
return age;
}
}
运行结果：
/*
* 2.利用面向对象的编程方法，设计类Circle计算圆的面积。
*/
public class CircleTest {
public static void main(String[] args) {
Circle cl=new Circle();
//方式1
// double mj=cl.js(2);
// System.out.println("面积为："+mj);
//方式2
cl.radius=2;
cl.js();
}
}
class Circle{
//属性：半径
double radius;
//方法：求圆的面积
//方式1：有返回值
// public double js(double r) {
// double mj = 3.14*r*r;//3.14可以写成Math.PI
// return mj;
// }
//方式2：无返回值
public void js() {
double mj1 = 3.14*radius*radius;//3.14可以写成Math.PI
System.out.println("圆的面积为："+mj1);
}
}
/*
* 3.1编写程序，声明一个method方法，在方法中打印一个10*8的*型矩形，在main方法中调用该方法()
* 3.2修改上一个程序，在method方法中，除打印一个10*8的*型矩形外，再计算该矩形的面积，
* 并将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。
*
* 3.3修改上一个程序，在method方法提供m和n两个参数，方法中打印一个m*n的*型矩形,
* 并计算该矩形的面积，将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。
*
*/
public class Exer3Test {
public static void main(String[] args) {
Exer3Test test=new Exer3Test();
//3.1的测试
//test.method();
//3.2的测试
// int mj=test.method();
// System.out.println("面积为："+mj);
//3.3测试
int mj1=test.method(5, 4);
System.out.println("面积为:"+mj1);
}
/*3.1
public void method() {
for(int i=0;i<10;i++) {
for(int j=0;j<8;j++) {
System.out.print("* ");
}
System.out.println();
}
}
*/
/*3.2
public int method() {
for(int i=0;i<10;i++) {
for(int j=0;j<8;j++) {
System.out.print("*");
}
System.out.println();
}
return 10*8;
}
*/
/*3.3
public int method(int m,int n) {
for(int i=0;i<m;i++) {
for(int j=0;j<n;j++) {
System.out.print("*");
}
System.out.println();
}
return m * n;
}
*/
}
3.1的测试结果：
3.2的测试结果：
3.3的测试结果：
方法的重载：
/*
* 方法的重载（overload） loading...
* 1.定义:在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
* "两同一不同":同一个类、相同方法名
* 参数列表不同:参数个数不同，参数类型不同
*
*
* 2.举例:Arrays类中重载的sort() / binarySearch()
*
* 3.判断是否是重载：
* 跟方法的权限修饰符，形参变量名，方法体没有关系
*
* 4.在通过对象调用方法时，如何确定一个指定方法
* 方法名----->参数列表
*
*/
public class OverLoadingTest {
//以下四种方法构成重载
public void getsum(int i,int j) {
}
public void getsum(double i,double j) {
}
public void getsum(String i,int j) {
}
public void getsum(int i,String j) {
}
/*未构成重载，参数名不影响
public void getsum(int a,int b) {
}
*/
}
重载的练习：
/*
* 1.编写程序，定义三个重载方法并调用。方法名为mOL。
三个方法分别接收一个int参数、两个int参数、一个字符串参数。
分别执行平方运算并输出结果，相乘并输出结果,输出字符串信息。
在主类的main ()方法中分别用参数区别调用三个方法。
2.定义三个重载方法max()，
第一个方法求两个int值中的最大值，
第二个方法求两个double值中的最大值，
第三个方法求三个double值中的最大值，并分别调用三个方法。
*
*/
public class OverLoadingTest {
public static void main(String[] args) {
OverLoading ol=new OverLoading();
ol.mOL(5);
ol.mOL(5, 10);
ol.mOL("我是第三个方法");
ol.max(5, 9);
double max1=ol.max(10.0, 15.0);
System.out.println(max1);
double max2=ol.max(7, 50, 40);
System.out.println(max2);
}
}
class OverLoading{
//1.以下三种方法构成重载
public void mOL(int i) {
System.out.println(i*i);
}
public void mOL(int i,int j) {
System.out.println(i*j);
}
public void mOL(String i) {
System.out.println(i);
}
//2.以下三种方法构成重载
public void max(int i,int j) {
int max1;
if(i>j) {
max1=i;
}else {
max1=j;
}
System.out.println(i+"和"+j+"中较大的是"+max1);
}
public double max(double i,double j) {
return (i>j?i:j);
}
public double max(double i,double j,double k) {
double ma = (i>j)?i:j;
return (ma>k)?ma:k;
}
}
运行结果：
递归的简单使用
/*
* 递归方法的使用（了解)
* 1.递归方法:一个方法体内调用它自身。
* 2．方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
* 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
*/
public class RecursionTest {
//例1：计算1到100的和
public static void main(String[] args) {
//方式一
int sum=0;
for(int i=1;i<=100;i++) {
sum+=i;
}
System.out.println(sum);
//方式二
RecursionTest test=new RecursionTest();
int sum1=test.sum(100);
System.out.println(sum1);
}
public int sum(int n) {
if(n==1) {
return 1;
}else {
return n+sum(n
最低0.47元/天 解锁文章
697
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
