1.面向对象编程和面向过程编程
java:面向对象编程的语言 C:面向过程的语言
面向对象编程:注重的是问题的拆解 面向过程编程:注重于解决问题的过程
2.生活中的面向对象
对象:现实生活中客观存在的实体都是对象。(世界万物皆对象)
生活中的对象都有属性(静态)+行为(动态)
3 编程中的对象
编程:变成就是为了使得人类的生活变得更加快捷(造福人类),其实编程就是解决人在生活中遇到的各种问题。所以说
生活中的对象就是编程中的对象。
对象:其实对象就是拥有属性和行为的一个具体的实例。
对象:其实对象就是拥有属性和行为的一个具体的实例。
类:对象的一个抽象的“集合”,类就是对象的模板
1.类的定义
对象有属性和行为(函数(function)|方法(method))
属性=>成员变量
方法=>成员方法
属性+方法 => 成员
//类名必须符合大驼峰命名法
class 类名{
类体
}
class Person{
//定义对象的属性
String name; //姓名
String sex; //性别
int age; //年龄
//定义类的行为(方法 函数)
void main(){
System.out.println("say hello");
}
}
2.对象的实例化
类:其实好像就是对象的模板;
对象:其实就是根据模板来进行对象的实例化;
实例化对象:根据类中定义的属性和行为实例化出来一个具体的对象,实例化的对象就拥有这些属性和行为。
public class Demo01{
piblic static void main(String[] args){
Person p = new Person(); //实例化对象
//使用对象来访问对象的属性
System.out.println(p.name);
//对象的属性赋值
P.name = ""小花;
p.age = 20;
System.out.println(p.name);
}
}
对象的创建过程
创建一个子类对象时,首先会创建父类的对象,然后再创建子类的对象,然后再把父类的对象和子类的对象绑定在一起,返回一个新的子类的对象;
-创建对象的细节
new
关键字来创建类的对象//使用类来创建对象
Person p1 = new Person();//创建了一个Person类(型)的对象
Person p2 = new Person();//创建了一个Person类(型)的对象
Person p3 = new Person();//创建了一个Person类(型)的对象
3.对象属性的访问
public class Demo01{
piblic static void main(String[] args){
Person p = new Person(); //实例化对象
//使用对象来访问对象的属性
System.out.println(p.name);
//对象的属性赋值
P.name = ""小花;
p.age = 20;
System.out.println(p.name);
//调用对象的方法
p.say();
}
}
/**
*类的定义
*/
class Person{
//定义对象的属性(成员变量)
String name; //姓名
String sex; //性别
int age; //年龄
//定义类的行为(方法 函数)
void main(){
System.out.println("say.....");
}
}
4.类的成员
类的成员 = 成员变量(属性)+成员方法(方法) 属性:固定不变的东西(年龄 身高 性别)
方法:实现功能的(吃 喝 玩 跑)
package com.uplooking.demo01;
public class Person{
String name; //成员变量可以不给定初始值,成员变量是有默认值的
int age;
}
成员变量的默认值
-基本类型:对应基本类型的默认值
-引用类型::默认值为null。
5.成员方法
什么是方法:将代码提取出来放在一个{}中,给这段代码起名,在需要时,通过名字调用即可-------即程序中定义的方法。
就是将完成特定功能的代码块进行的封装,类似于C语言中的函数。 在面向对象编程中把函数是称为方法
方法的定义格式
[访问修饰符] 返回值类型 方法名称(参数类型 参数名1,参数类型 参数名2,。。。){
方法体
return 返回值;
}
ps:返回值类型如果为void则代表没有返回值;方法名称使用小驼峰命名法;参数列表,可以是任意
参数,多个参数之间使用逗号分隔;方法体:执行的代码,如果有返回值,则必须使用return关键字。
package com.uplooking.demo01;
int say(){
//修饰符可有可没有
System.out.println("hello uplooking...");
return 10; //返回到调用方法say
}
void sum(String a, int b){
//a,b为形参
//String类型与基本类型的数据进行拼接时,会先把基本类型的变量转换为String类型的变量,再进行计算
System.out.println(a + b);
}
修饰符:现在使用固定的 public static
返回值类型:就是方法执行完成后的结果的数据类型
方法名:就是一个名字,要求符合命名规则。
参数:
a.形式参数:就是方法中()里面写的,用来接收实参。
b.实际参数:就是实际参与运算的。
参数类型:数据类型
参数名:就是变量名
函数体:就是完成特定功能的代码
return:结束方法
返回值:就是方法的最后结果,由return待会给调用者。
方法的定义
方法的定义是由返回值类型 方法名称 参数列表三部分组成
返回值类型 方法名称(参数列表){
方法体
}
/****** 要定义一个方法前,先必须明确2个东西: 返回值类型,参数列表 (要几个类型,每个参数的数据类型是什么) ******/
//没有返回值 没有参数列表的方法
void say() {
System.out.println("say hello");
}
//有返回值,没有参数列表的方法
int say1() {
return 1;
}
//有返回值,有参数列表的方法
int sum(int a, int b) {
int s = a + b;
return s;
}
方法的特点:不调用不执行;通过方法名在main方法中调用
-成员变量
成员变量就是属性
成员变量可以是基本类型,也可以是引用类型
成员变量可以不用初始化,不初始化其实是有默认值的,基本类型的默认值对应基本类型的默认值,引用类型的默认值是null
成员变量一般不用手动初始化
每个对象都拥有自己的成员变量和成员方法
6.方法的重载(OverLoad)
----方法的功能相同,参数列表不同。为了让见名知意,java允许他们的名字一样。这种情况有一个专业的叫法:方法重载
在同一个类中的两个方法满足以下条件,则构成的关系成为重载关系:方法名称相同、参数列表不同(个数不同、类型不同)
在调用的时候,虚拟机会通过参数的不同来自动区分同名的方法
特点:******和返回值类型无关,只看方法名和参数列表
7.方法的调用
对象.方法名称(实参列表);
package com.uplooking.demo01; public class Main{
public static void main(String[] args){
Person p = new Person(); //实例化对象
int result = p.say(); //方法的调用
System.out.println(result);
p.sum("10",20); //传递的10,20为实参
p.sum("10"); //参数个数不匹配错误
p.sum("10","20"); //参数类型不匹配错误
p.sum(10,"20"); //参数类型不匹配
}
}
public class Main{
public static void main(String[] args){
//程序的入口
Person p = new Person();
p.name = "小明";
p.age = 20;
System.out.println("name:" + p.name); //小明
Person p2 = new Person();
p2.name = "小胖";
//static修饰的成员不建议使用对象来直接调用,可以使用类来进行调用
System.out.println("p2的name:" + p.name); //小胖
System.out.println("p2的name:" + p2.name); //小胖
}
}
package com.uplooking.demo02;
public class Person{
//成员变量
static String name;
int age;
//成员方法
void say(){
System.out.println("hello uplooking...say");
}
static void say1(){
System.out.println("hello uplooking...say1");
}
}
方法区中的数据是所有对象共享的,普通对象的属性是在堆里面,而static修饰的成员都在方法区中存储。
单独调用(使用方法名直接调用),没意义。 直接输出语句调用,但是不好。 赋值调用,推荐使用。
练习:
//定义一个求两个整数之和的方法
class Demo{
public static void main(String[] args){
// 1.程序从main进来
int a = 4;
int b = 8; // 2.定义2个int类型变量
int i = sum(a,b); // 3.通过方法名调用方法并传入参数
System.out.println(i); //6.输出结果
}
/*
确定2个东西:
返回值类型:整数 int
参数列表:2个,int a int b
*/
public static int sum(int a,int b){
// 4.把main中的a, b传过来传给了sum方法 4,5
return a+b; // 5.先计算a+b的值 = 12,然后通过return把12返回给了调用者。
}
}
练习:
定义一个方法,使用键盘输入2个值,比较返回最大值(至少写出两种写法)
定义一个方法,使用键盘输入2个值,比较返回是否相等(至少写出两种写法),参数分别使用2个byte,两个short,2个int,2个long,在main方法中测试。
定义一个方法,使用键盘输入3个值,比较返回最大值(至少写出两种写法)
方法的注意事项:
方法无调用不执行、方法和方法是平级关系,不能嵌套、方法定义时,参数之间用逗号隔开、方法在调用时不需要在传递数据类型、如果方法有明确返回值必须要有return带会一个值。
//在控制台输出n行n列* 需求不断改变,代码相同,只需改变i和j的值就可以了
//所以我觉得使用方法改进
class Demo{
public static void main(String[] args){
/*
返回值类型:没有具体的返回值,但是我们定义方法的格式中必须有东西,所以这里使用void。
参数列表:int a, int b
*/
public void printStar(int a,int b){
for(int i=0;i<a;i++){
for(int j=0;j<b;j++){
System.out.print("*");
}
System.out.println();
}
}
}
//求n个数求和
public class Demo{
public static void main(String[] args){
}
public static int sum(int a,int b)
return a+b;
}
6.Java中的static关键字
static可以修饰静态方法(成员方法)、静态属性(成员变量),static修饰的成员属于所有对象共享的。
static修饰的成员,sun公司不建议使用对象来进行调用。因为static修饰的成员是类级别的,所以直接使用类来进行调用。
package com.uplooking.demo03;
public class Person{
//成员变量
static String name;
int age;
//成员方法
void say(){
System.out.println("hello uplooking...say");
}
static void say1(){
System.out.println("hello uplooking...say1");
}
}
public clss Main{
public static void main(String[] args){
Person.name = "小胖";
Person.p1 = new Person();
Person.p2 = new Person();
System.out.println("p1的name:" + p1.name); //小胖
p1.name = ""小花;
Person.name = "小胖";
System.out.println("p2的name:" + p2.name); //小胖
}
}
this指调用当前方法的对象
7.Java中的构造方法
构造方法不需要我们自己调用
构造方法,当我们new
对象的时候,底层帮我们调用
构造方法没有返回值,没有返回值和返回值为空(void
)是两个概念;
构造方法的名称(也是返回值类型)和类名相同
如果我们不写任何的构造方法,系统会帮我们生成无参数的构造方法
如果我们编写了构造方法(不管有参无参),系统都不会帮我们生成了
构造方法一般是用来初始化成员变量
构造方法是创建对象时调用的方法,是用来进行对象初始化操作,他就是我们一个对象产生的时候的一个方法,通过这个方法就可以产生一个对象
构造方法的定义
[访问修饰符]类名(形参列表){
构造体()
}
package com.uplooking.demo06;
public class Main{
public static void main(String[] args){
//实例化对象
Person p1 = new Person("小花",20);
System.out.println(p1.name);
System.out.println(p1.age);
Person p2 = new Person(); //无参
}
}
package com.uplooking.demo06;
public class Person{
String name;
int age;
//java中如果不手动的声明构造方法,系统会帮我们创建一个无参数的构造方法
Person(){
System.out.println("构造方法。。。。");
}
//有参
Person(String name, int age){
this name = name;
this age = age;
}
}
eg:
//Java中如果我们不显示的声明构造方法,系统会帮我们生成一个无参数的默认的构造方法
Person(){
Dog dog = new Dog();
}
如果我们声明的构造方法,系统则不会帮我们生成了
有参数的构造方法
Person(String name, int age){
this name = name;
this age = age;
Dog dog = new Dog("二哈",2,"公");
}
}
在商业项目中一般会利用有参数的构造方法给成员变量赋值。
如果我们写了有参数的构造方法,一般我们也会写一个无参数的构造方法,方便使用。
8.利用idea来生成构造方法
public class Person{
String name;
int age;
String sex;
String phone;
String addr;
String number;
Person(String name,String sex){
this.name = name;
this.sex = sex;
}
Person(String name,int age,String sex){
this.name = name;
this.age = age;
this.sex = sex;
}
}