java面向对象(一)
面向对象#
我们都说java是面向对象的编程语言,那什么是面向对象呢?什么是类呢?什么是方法呢?
类、对象、方法
类是对象的抽象定义,对象是类的具体实例。
类:指的是一类东西,比如汽车,人类,书等这些都指的是一类东西或物品。
对象:指类的具体的实体,比如一辆汽车,一本书等,我们要记住一切皆对象(东西)。
同时对象具有状态(属性)和行为(方法)
我以人为例:
人属性有:脸,手,脚,鼻子,耳朵,身高,性别,鼻子,耳朵等属性
人的行为(方法):吃,喝,跑,睡觉等。
这几个大家都能理解吧,而java中是如何创建类和对象的呢
先创建一个学生类(这些都是学生的属性和方法)
public class Student {
String name; //姓名
int age; //年龄
String classNo; //班级
String hobby; //爱好
public void chi(){
System.out.println(name+"吃饭了")
}
//输出信息方法
public void show(){
System.out.println(name + "\n年龄:" + age + "\n就读于:" +classNo + "\n爱好:" + hobby);
}
}
这样就创建好一个类了,那如何创建一个对象呢。
首先举一个例子:小李设计了一张汽车设计图,然后交给生产车间来生产汽车,有黑色的、红色的、白色的... 这里,汽车设计图就是我们说的类(class),生产车间就是new构造器(大部分对象都是new出来的),生产出来的汽车就是我们要说的对象。可以说java编程实质就是构建类的过程。
public class InitialStudent {
public static void main(String args[]){
Student student = new Student(); //建立对象
student.name = "小明"; //给对象赋值
student.age = 10;
student.classNo = "S1班";
student.hobby = "篮球";
student.chi();
student.show(); //调用方法
}
}
到现在我都是以自己的组织的语言给大家讲解,为的是让大家能够理解,那么java编程的规范有哪些,它的具体的细节又有哪些下面我就具体讲一下
类的定义
类必须先定义才能使用。类是创建对象的模板,创建对象也叫类的实例化。(类是对象的抽象定义,对象是类的具体实例)类实质上是一个数据类型。
例子:
public class Dog
{
String name;
int age;
void bark()//汪汪叫
{
System.out.println("汪汪,不要过来");
}
void hungry()
{
System.out.println("主人,我饿了");
}
}
对示例的说明:
-
public 是类的修饰符,表明该类是公共类,可以被其他类访问。
-
一个类保存到一个文件中,并且文件名要与类名相同。(一个文件中可以运行多个类声明,只能有一个类是public,文件名必须和该类类名一致)
-
class 是定义类的关键字。
-
Dog是类的名称。
-
name,age是类的成员变量,也叫属性;bark(),hungry()是类中的函数,也叫方法。
-
对象实例化: 类名 对象名 = new 类名(); //未实例化的对象不能访问其属性和方法
-
访问属性:对象名.属性名
-
访问方法:对象名.方法名(参数列表)
作用域修饰词
1、public:public表明该数据成员、成员函数是对所有用户开放的,所有用户都可以直接进行调用
2、private:private表示私有,私有的意思就是除了class自己之外,任何人都不可以直接使用,私有财产神圣不可侵犯嘛,即便是子女,朋友,都不可以使用。
3、protected:protected对于子女、朋友来说,就是public的,可以自由使用,没有任何限制,而对于其他的外部class,protected就变成private。
作用域 | 当前类 | 同一package | 子孙类 | 其他package |
---|---|---|---|---|
public | √ | √ | √ | √ |
protected | √ | √ | √ | × |
friendly(默认) | √ | √ | × | × |
private | √ | × | × | × |
一个类可以包含以下类型变量:
-
局部变量:在方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中,方法结束后,变量就会自动销毁。
-
成员变量:成员变量是定义在类中,方法体之外的变量。这种变量在创建对象的时候实例化(分配内存)。成员变量可以被类中的方法和特定类的语句访问。
-
类变量:类变量也声明在类中,方法体之外,但必须声明为static类型。static也是修饰符的一种。
同时类也可以被final修饰,下面将会讲解finnal关键字和static关键字
比较 | 成员变量 | 局部变量 |
---|---|---|
作用域 | 整个类中起作用(包括方法中) | 只在方法中起作用 |
初始值 | byte,short,int,long型是0 float,double型是0.0 char型是’\0’ boolean型是false |
没有初始值,无法使用 |
注:当局部变量与成员变量重名时,在方法中优先使用局部变量,方法中使用成员变量使用this,this代表当前类的当前对象。
static(静态)
类的静态成员不依赖类的某一实例,可使用类名直接访问
1.静态变量(类变量)
当类第一次被加载(任何一个对象的声明,首先要加载类),该类的静态变量就分配独立内存,直到程序结束被回收。静态成员是公共的。(局部变量不能用static修饰)
比较 | 静态变量 | 成员变量 |
---|---|---|
作用域 | 当前类 | 当前类 |
生命周期 | 类加载到程序结束 | 从对象产生到对象回收 |
使用方法 | 类名.静态变量名 | 对象名.成员变量名 |
静态变量即类变量 成员变量即实例变量,对象实例化后才能使用
静态方法
- 访问静态方法:类名.方法名(参数列表)
静态方法在同一个类中被调用时,类名可以省略。普通成员方法必须在对象实例化后才可以调用
比较 | 静态方法 | 成员方法 |
---|---|---|
调用 | 类名.方法名(参数) | 对象名.方法名(参数) |
调用普通方法 | 不能直接调用 | 同一个类中可以调用 |
调用静态方法 | 类名.方法名(参数) | 类名.方法名(参数) |
访问静态变量 | 类名.静态变量名 | 类名.静态变量名 |
访问成员变量 | 不能直接访问 | 同一类中可以直接访问 |
this关键字 | 不能使用 | 可以使用 |
static代码块
static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方,类中可以有多个static块。在类初次被加载的时候,会按照static块的顺序来执行每个static块,并且只会在类加载的时候执行一次。
一般用来加载静态资源比如加载图片,视频,音频等。
final
Java关键字final有“这是无法改变的”或者“终态的”含义,它可以修饰非抽象类、非抽象类成员方法和变量。
1.修饰类
当用final修饰一个类时,表明这个类不能被继承。也就是说,如果一个类你永远不会让他被继承,就可以用final进行修饰。final类中的成员变量可以根据需要设为final,但是要注意final类中的所有成员方法都会被隐式地指定为final方法。
注:在使用final修饰类的时候,要注意谨慎选择,除非这个类真的在以后不会用来继承或者出于安全的考虑,尽量不要将类设计为final类。
修饰方法
使用final方法的原因有两个。
第一个原因是把方法锁定,以防任何继承类修改它的含义;
第二个原因是效率。在早期的Java实现版本中,会将final方法转为内嵌调用。但是如果方法过于庞大,可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中,不需要使用final方法进行这些优化了。
注:类的private方法会隐式地被指定为final方法。
修饰变量
修饰变量是final用得最多的地方,也是重点阐述的内容
对于一个final变量,
如果是基本数据类型的变量,则其数值一旦在初始化之后便不能更改;
如果是引用类型的变量,则在对其初始化之后便不能再让其指向另一个对象。
- 类的final变量和普通变量有什么区别
- 当用final作用于类的成员变量时,成员变量(注意是类的成员变量,局部变量只需要保证在使用之前被初始化赋值即可)必须在定义时或者构造器中进行初始化赋值,而且final变量一旦被初始化赋值之后,就不能再被赋值了。
public class Test {
public static void main(String[] args) {
String a = "hello2";
final String b = "hello";
String d = "hello";
String c = b + 2;
String e = d + 2;
System.out.println((a == c));//true
System.out.println((a == e));//false
}
}
分析
为什么第一个比较结果为true,而第二个比较结果为fasle。这里面就是final变量和普通变量的区别了,当final变量是基本数据类型以及String类型时,如果在编译期间能知道它的确切值,则编译器会把它当做编译期常量使用。也就是说在用到该final变量的地方,相当于直接访问的这个常量,不需要在运行时确定。这种和C语言中的宏替换有点像。因此在上面的一段代码中,由于变量b被final修饰,因此会被当做编译器常量,所以在使用到b的地方会直接将变量b 替换为它的 值。而对于变量d的访问却需要在运行时通过链接来进行。想必其中的区别大家应该明白了,不过要注意,只有在编译期间能确切知道final变量值的情况下,编译器才会进行这样的优化,比如下面的这段代码就不会进行优化:
public class Test {
public static void main(String[] args) {
String a = "hello2";
final String b = getHello();
String c = b + 2;
System.out.println((a == c));//这段代码的输出结果为false。
}
public static String getHello() {
return "hello";
}
}
- 被final修饰的引用变量指向的对象内容可变吗
- 引用变量被final修饰之后,虽然不能再指向其他对象,但是它指向的对象的内容是可变的。
public class Test {
public static void main(String[] args) {
final MyClass myClass = new MyClass();
System.out.println(++myClass.i);//结果为1
}
}
class MyClass {
public int i = 0;
}
- final参数的问题
- 无论参数是基本数据类型的变量还是引用类型的变量,使用final声明都不会防止你无意的修改而影响到调用方法外的变量
public class Test {
public static void main(String[] args) {
MyClass myClass = new MyClass();
StringBuffer buffer = new StringBuffer("hello");
myClass.changeValue(buffer);
System.out.println(buffer.toString());
}
}
class MyClass {
void changeValue(final StringBuffer buffer) {
buffer.append("world");
}
}
运行这段代码就会发现输出结果为 helloworld。很显然,用final进行修饰并没有阻止在changeValue中改变buffer指向的对象的内容。有人说假如把final去掉了,万一在changeValue中让buffer指向了其他对象怎么办。有这种想法的朋友可以自己动手写代码试一下这样的结果是什么,如果把final去掉了,然后在changeValue中让buffer指向了其他对象,也不会影响到main方法中的buffer,原因在于java采用的是值传递,对于引用变量,传递的是引用的值,也就是说让实参和形参同时指向了同一个对象,因此让形参重新指向另一个对象对实参并没有任何影响。
static final
-
static作用于成员变量用来表示只保存一份副本,而final的作用是用来保证变量不可变。
-
static final修饰的属性表示一旦给值,就不可修改,并且可以通过类名访问。
-
static final也可以修饰方法,表示该方法不能重写,可以在不new对象的情况下调用。
方法
- 为什么要有方法
- 提高代码的复用性
- 什么是方法
- 完成特定功能的代码块。
- 方法的格式
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
方法体语句;
return 返回值;
}
- 方法的格式说明
- 修饰符:一般就用 public,static,final。
- 返回值类型:就是功能结果的数据类型。
- 方法名:符合命名规则即可。方便我们的调用。
- 参数:
- 实际参数:就是实际参与运算的。
- 形式参数;就是方法定义上的,用于接收实际参数的。
- 参数类型:就是参数的数据类型
- 参数名:就是变量名
- 方法体语句:就是完成功能的代码。
- return:结束方法的。
- 返回值:就是功能的结果,由return带给调用者。
构造方法(特殊的方法)
在类实例化的过程中自动执行的方法叫做构造方法,它不需要你手动调用。构造方法可以在类实例化的过程中做一些初始化的工作。
构造方法的名称必须与类的名称相同,并且没有返回值。
每个类都有构造方法。如果没有显式地为类定义构造方法,Java编译器将会为该类提供一个默认的构造方法。
public class Dog
{
String name;
int age;
//构造方法,没有返回值
Dog(String name1,int age1)
{
name = name1;
age = age1;
System.out.println("感谢主人领养了我");
}
//普通方法,必须有返回值
void bark()
{
System.out.println("汪汪,不要过来");
}
void hungry()
{
System.out.println("主人,我饿了");
}
public static void main(String[] args)
{
//创建对象时传递的参数要与构造方法参数列表对应
Dog myDog = new Dog("花花",3);
}
}
运行结果:
感谢主人领养了我
package day23;
/*构造方法
- 作用是用于初始化参数
- 所有的数字变量全部设置为0
- 所有的boolean类型全部设置为false
- 所有的对象变量全部设置为null
*/
/*
- 设计自己的构造方法
- 方法名称必须和类的名称相同
- 没有返回值
*/
/*
- 如果自己写了有参的构造方法,那么编译器不会再提供
- 默认的构造方法了
- 如果我们还想用无参的构造方法,
- 那么需要手动实现
*/
public class People
{
String name;
String sex;
int age;
//无参的构造方法(可以不写编译器自动加上,前提是没有任何其他构造方法)
People()//构造方法(可删掉,编译器默认加上)
{
// name = null;
// sex = null;
// age = 0;
}
//有参的构造方法
People(String name,String sex,int age)
{
this.name = name;
this.sex = sex;
this.age = age;
}
//部分初始化
People(String name)
{
this.name = name;
}
People(String name,int age)
{
this.name = name;
this.age = age;
}
public static void main(String[] args)
{
People p = new People();
System.out.println(p.name);
System.out.println(p.sex);
System.out.println(p.age);
People p1 = new People("张三","男",30);
System.out.println(p1.name+","+p1.sex+","+p1.age);
People p2 = new People("老王");
System.out.println(p2.name);
People p3 = new People("小老虎",3);
System.out.println(p3.name+","+p2.age);
}
}
说明:
-
构造方法不能被显式调用。
-
构造方法不能有返回值,因为没有变量来接收返回值
创建对象
对象是类的一个实例,创建对象的过程也叫类的实例化。对象是以类为模板来创建的。
在Java中,使用new关键字来创建对象,一般有以下三个步骤:
-
声明:声明一个对象,包括对象名称和对象类型
-
实例化:使用关键字new来创建一个对象。
-
初始化:使用new创建对象时,会调用构造方法初始化对象。
例如:
Dog myDog;//声明一个对象
myDog = new Dog("花花",3);//实例化
也可以在声明的同时进行初始化:
Dog myDog = new Dog("花花",3);
访问成员变量和方法
通过已创建的对象来访问成员变量和成员方法,例如:
//实例化
Dog myDog = new Dog("花花",3);
//通过点号访问成员变量
myDog.name;
//通过点号访问成员方法
myDog.bark();
下面的例子演示了如何访问成员变量和方法:
public class Dog
{
String name;
int age;
Dog(String name1,int age1)
{
name = name1;
age = age1;
System.out.println("感谢主人领养了我");
}
void bark()
{
System.out.println("汪汪,不要过来");
}
void hungry()
{
System.out.println("主人,我饿了");
}
public static void main(String[] args)
{
Dog myDog = new Dog("花花",3);
//访问成员变量
String name = myDog.name;
int age = myDog.age;
System.out.println("我是一只小狗,我名字叫" + name + ",我" + age + "岁了");
//访问方法
myDog.bark();
myDog.hungry();
}
}
**运行结果: **
感谢主人领养了我
我是一只小狗,我名字叫花花,我3岁了
汪汪,不要过来
主人,我饿了
这些就是面向对象的基础知识,下来难一点的比如抽象类,接口,重载,重写等,我会在下一篇将。