Java面向对象(2)
来源:互联网 发布:欧姆龙传感器淘宝 编辑:程序博客网 时间:2024/06/18 04:06
昨天复习了之前学的面向对象的一些知识点。今天继续来温故一下知识。
static关键字
要是有多个人是同一个国籍,那么让很多个变量都共享一个区域的,都去访问他,是很方便的。那么如何操作呢?就是用static
static使用
1:主要用于修饰类的成员
1:成员变量
1:非静态成员变量:需要创建对象来访问
2:静态成员变量:使用类名直接调用,也可以通过对象访问
public static void main(String[] args) { //访问静态成员 //直接通过类名来调用 String country=Person.country; System.out.println(country); //通过对象.成员的形式访问 Person p1 = new Person("jack", 20, "男"); p1.country="US"; p1.speak();}class Person { String name; int age; String gender; //static 修饰成员变量 static String country = "CN"; Person() { } Person(String name, int age, String gender) { this.name = name; this.age = age; this.gender = gender; } void speak() { System.out.println("国籍:" + country + " 姓名:" + name + " 性别:" + gender + " 年龄:" + age + " 哈哈!!!"); }}
成员方法
可以使用类名直接调用
1:静态函数:
1:静态函数中不能访问非静态成员变量,只能访问静态变量。
2:静态方法不可以定义this,super关键字.
3:因为静态优先于对象存在.静态方法中更不可以出现this
2:非静态函数:非静态函数中可以访问静态成员变量
class Person { String name; int age; String gender; //static 修饰成员变量 static String country = "CN"; Person() { } Person(String name, int age, String gender) { this.name = name; this.age = age; this.gender = gender; } //非静态方法 void speak() { //非静态方法可以访问静态成员 System.out.println("国籍:" + country ); System.out.println("国籍:" + country + " 姓名:" + name + " 性别:" + gender + " 年龄:" + age + " 哈哈!!!"); } //静态方法 static void run(){ //静态方法只能访问静态成员变量。 System.out.println("国籍:"+country); //静态方法访问非静态成员变量,编译报错。 System.out.println(" 姓名:" + name); //静态方法中不可以出现this,编译报错 this.speak(); }}
细节:
1:静态函数中不能使用非静态变量
2:非静态函数可以访问静态变量
3:为什么静态函数中不能访问非静态成员
1:static修饰的成员在共享区中。优先于对象存在
2:验证
1:使用静态代码块验证
1:静态代码块
static{
静态代码块执行语句;
}
1:静态代码块特点
随着类的加载而加载。只执行一次,优先于主函数。用于给类进行初始化。
static特点
1 随着类的加载而加载,静态会随着类的加载而加载,随着类的消失而消失。说明它的生命周期很长。
2 优先于对象存在。–>静态是先存在,对象是后存在。
3 被所有实例(对象)所共享。
4 可以直接被类名调用
5:静态变量(类变量)和实例变量的区别:
1存放位置
1:类变量随着类的加载而加载存在于方法区中.
2:实例变量随着对象的建立而存在于堆内存中.
2生命周期
1:类变量生命周期最长,随着类的消失而消失.
2:实例变量生命周期随着对象的消失而消失.
6:静态优缺点
1: 优点:对对象的共享数据进行单独空间的存储,节省空间 例如Person 都有
国籍。该数据可以共享可以被类名调
2:缺点:生命周期过长
访问出现局限性。(静态只能访问静态)
7: 什么时候定义静态变量
1:静态变量(类变量)当对象中出现共享数据
例如:学生的学校名称。学校名称可以共享
对象的数据要定义为非静态的存放在对内存中(学生的姓名,学生的年龄)
8:什么时候定义静态函数
如果功能内部没有访问到非静态数据(对象的特有数据。那么该功能就可以定义为静态)
9:静态的应用
自定义数组工具类
Main方法详解
主函数是静态的
public static void main(String[] args){
}
主函数是什么:主函数是一个特殊的函数,作为程序的入口,可以被jvm识别。
主函数的定义:
public :代表该函数的访问权限是最大的。
static :代表主函数随着类的加载,就已经存在了。
void: 主函数没有具体的返回值
main : 不是关键字,是一个特殊的单词可以被jvm识别。
(String[] args) 函数的参数,参数类型是一个数组,该数组中的元素是字符串。字符串类型的数组。
主函数的格式是固定的:jvm能够识别
jvm在调用函数是,传入的是new String[0];
可以在dos窗口中执行 java Demo5 hello world 给类Demo5的main方法传递2个参数,参数与参数之间通过空格隔开。
单例设计模式
一些人总结出来用来解决特定问题的固定的解决方案。
解决一个类在内存中只存在一个对象,想要保证对象的唯一。
1 为了避免其他程序过多的建立该类对象。禁止其他程序建立该类对象。
2 为了其他程序可以访问该类对象,在本类中自定义一个对象。
3 方便其他程序对自定义类的对象的访问,对外提供一些访问方式。
代码:
1将构造函数私有化
2在类中创建一个私有的本类对象
3提供一个用类名调用的公有方法获取该对象。
class Single { private static Single s = new Single(); // 饿汉式 private Single() { } public static Single getInstance() { return s; }}class Single2 { private static Single2 s = null; // 懒汉 private Single2() { } public static Single2 getInstance() { if (s == null) { s = new Single2(); } return s; }}
继承
1:描述一个学生类
1:姓名年龄学号属性,学习的方法
2:描述一个工人类
1:姓名年龄工号属性,工作的方法
3:描述一个人类
1:姓名年龄属性,说话的方法。
4:发现学生类和人类天生有着联系,学生和工人都是人。所以人有的属性和行为学生和工人都会有。出现类代码重复
n(name + ":好好工作,好好挣钱。"); }}class Demo1 { public static void main(String[] args) { Student s = new Student(); s.name = "jack"; s.age = 20; s.study(); Worker w = new Worker(); w.name = "rose"; w.work(); }}
继承特点
1:描述类和类之间的关系2:降低类和类之间的重复代码
1:降低对象和对象之间的代码重复使用静态变量
2:降低类和类之间的代码重复使用就继承
extends关键字
继承使用extends关键字实现
1:发现学生是人,工人是人。显然属于is a 的关系,is a就是继承。
2:谁继承谁?
学生继承人,发现学生里的成员变量,姓名和年龄,人里边也都进行了定义。有重 复代码将学生类的重复代码注释掉,创建学生类对象,仍然可以获取到注释的成员。这就是因为继承的关系,学生类(子类)继承了人类(父类)的部分
class Person { String name; int age; // 静态变量(类变量)对象和对象之间的代码重复使用静态变量 static String country = "CN"; Person() { } void speak() { System.out.println(name + ":哈哈,我是人!!!"); }}// 让学生类和人类产生关系,发现学生is a 人,就可以使用继承class Student extends Person { Student() { } void study() { System.out.println("姓名:" + name + "年纪:" + age + ":好好学习"); }}class Worker extends Person { void work() { System.out.println(name + ":好好工作,好好挣钱。"); }}class Demo1 { public static void main(String[] args) { Student stu = new Student(); stu.name = "jack"; stu.age = 20; stu.study(); stu.speak(); System.out.println(stu.country); System.out.println(Student.country); Worker worker = new Worker(); worker.name = "rose"; System.out.println(worker.country); worker.work(); worker.speak(); System.out.println(); }}
继承细节;
1:类名的设定,被继承的类称之为父类(基类),继承的类称之为子类
2:子类并不能继承父类中所有的成员
1:父类定义完整的成员 静态成员,非静态,构造方法。静态变量和静态方
法都可以通过子类名.父类静态成员的形式调用成功。
2:所有的私有成员不能继承,private修饰的成员。
3:构造函数不能被继承
3:如何使用继承
1:不要为了使用继承而继承。工人和学生都有共性的成员,不要为了节省代码,让工人继承学生。
Super关键字
class Father { int x = 1; Father() { System.out.println("这是父类无参构造"); } Father(int x) { this.x = x; System.out.println("这是父类有参构造"); } void speak() { System.out.println("我是父亲"); } }class Son extends Father { int y = 1; Son() { System.out.println("这是子类的无参构造"); } Son(int y) { this.y = y + x; System.out.println("这是子类的有参构造"); } void run() { super.speak(); // 访问父类的函数 System.out.println("我是儿子"); }}class Demo6 { public static void main(String[] args) { Son s = new Son(3); System.out.println(s.y);// 4 }}
子类对象为什么可以访问父类的成员。
1:this.y=y+x;有一个隐式的super super.x
5:super关键字作用 1:主要存在于子类方法中,用于指向子类对象中父类对象。 2:访问父类的属性 3:访问父类的函数 4:访问父类的构造函数
6:super注意
this和super很像,this指向的是当前对象的调用,super指向的是当前调用对象的父类。Demo类被加载,执行main方法,Son.class加载,发现有父类Father类,于是Father类也加载进内存。类加载完毕,创建对象,父类的构造方法会被调用(默认自动无参),然后执行子类相应构造创建了一个子类对象,该子类对象还包含了一个父类对象。该父类对象在子类对象内部。this super只能在有对象的前提下使用,不能在静态上下文使用。
2.子类的构造函数默认第一行会默认调用父类无参的构造函数,隐式语句super();
Son(int y) { //super();隐式语句 this.y = y + x; System.out.println("这是子类的有参构造"); }
3:子类显式调用父类构造函数
在子类构造函数第一行通过super关键字调用父类任何构造函数。如果显式调用父类构造函数,编译器自动添加的调用父类无参数的构造就消失。构造函数间的调用只能放在第一行,只能调用一次。super() 和this()不能同时存在构造函数第一行。
Son(int y) { super(y);// 子类显式调用父类构造函数 this.y = y + x; System.out.println("这是子类的有参构造"); }
4:super思考
如果开发者自定义了一个类,没有显示的进行类的继承,那么该类中成员函数是否可以使用super关健健字?
答:可以使用,继承了Object类,Object类是所有类的父类。
重写(override)
定义Father类
1:姓名,吃饭方法,吃窝窝头。
2:定义Son类,继承Father
1:Son类中不定义任何成员,子类创建对象,仍然可以调用吃饭的方法。
2:父类的吃饭的方法,Son不愿吃。Son自己定义了吃饭的方法。
1:此时父类中有一个吃饭的方法,子类中有2个吃饭的方法,一模一样,只是方法体不一样。
2:一个类中两个函数一模一样,是不允许的。
1:编译运行,执行了子类的方法。
2:使用父类的方法,在子类方法中,使用super.父类方法名。
class Father { String name; void eat() { System.out.println("吃窝窝"); }}class Son extends Father { public void eat() { // 继承可以使得子类增强父类的方法 System.out.println("来俩小菜"); System.out.println("来两杯"); System.out.println("吃香喝辣"); System.out.println("来一根"); }}class Demo8 { public static void main(String[] args) { Son s = new Son(); //执行子类的方法 s.eat(); }}
3:该现象就叫做重写(覆盖 override)
1: 在继承中,子类可以定义和父类相同的名称且参数列表一致的函数,将这种函数
称之为函数的重写.
4:前提
1:必须要有继承关系
5:特点
1:当子类重写了父类的函数,那么子类的对象如果调用该函数,一定调用的是重写过后的函数。
可以通过super关键字进行父类的重写函数的调用。
2: 继承可以使得子类增强父类的方法
6:细节
1: 函数名必须相同
2:参数列表必须相同
3: 子类重写父类的函数的时候,函数的访问权限必须大于等于父类的函数的访
问权限否则编译报错
4:子类重写父类的函数的时候,返回值类型必须是父类函数的返回值类型或该返回值类型的子类。不能返回比父类更大的数据类型: 如子类函数返回值类型是Object
本次复习了static关键字,main方法,单例设计模式(有点问题),继承的概念以及使用,super关键字和重写~我们下回再谈
- java面向对象2
- java面向对象2
- java--面向对象2
- java面向对象2
- 2、Java面向对象
- java 面向对象2
- JAVA面向对象2
- JAVA面向对象2
- Java面向对象2
- Java面向对象(2)
- Java面向对象基础2
- java 复习 面向对象2
- java--面向对象(2)
- java面向对象 练习题2
- java学习-面向对象2
- Java基础知识2:面向对象
- Java面向对象编程2
- Java-----2、理解面向对象
- 深度优先搜索 Tarjan算法 两条不相交的路径
- JVM系列知识汇总
- 欢迎使用CSDN-markdown编辑器
- ue4 碰撞检测测试
- vue-resource上传文件(POST multipart/form-data到koa-multer)
- Java面向对象(2)
- poj 1961 Period
- python实现单例模式
- 如何转载别人的博客
- S5PV210开发 -- 通信
- php微信公众号开发,入门篇(实现了关注公众号发送欢迎信息,发关键词自回复)
- 最小生成树-prim算法
- 【java基础:IO】Java的IO知识整理!
- azkaban 编译使用方法