黑马程序员——Java基础——构造方法,static关键字,以及继承的详解
来源:互联网 发布:美工与设计师的区别 编辑:程序博客网 时间:2024/05/17 02:09
------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流! -------
构造方法
构造方法作用概述给对象的数据进行初始化
构造方法格式
方法名与类名相同
没有返回值类型,连void都没有
没有具体的返回值
举例演示:
class Student{
String name;
//构造方法
public Student(){
System.out.println("我是构造方法");
name = "小明";
}
}
class OOPDemo {
public static void main(String[] args) {
//创建对象
Student s = new Student();
System.out.println( s.name );
}
}
构造方法注意事项
如果你不提供构造方法,系统会给出空参数的构造方法如果你提供了构造方法,系统将不再提供空参数的构造方法
构造方法也是可以重载的
举例演示:
class Student {
String name;
//空参数构造方法
public Student(){
System.out.println("我是空参数构造方法");
}
//有参数构造方法重载
public Student(String name){
System.out.println("我是有参数构造方法");
//为了给对象中的name成员赋值
this.name = name;
}
}
class OOPDemo2 {
public static void main(String[] args) {
Student s = new Student();
Student s2 = new Student("小明");
System.out.println(s2.name);
}
}
构造方法注意事项
如果你不提供构造方法,系统会给出空参数的构造方法如果你提供了构造方法,系统将不再提供空参数的构造方法
构造方法也是可以重载的
举例演示:
class Student {
String name;
//空参数构造方法
public Student(){
System.out.println("我是空参数构造方法");
}
//有参数构造方法重载
public Student(String name){
System.out.println("我是有参数构造方法");
//为了给对象中的name成员赋值
this.name = name;
}
}
class OOPDemo2 {
public static void main(String[] args) {
Student s = new Student();
Student s2 = new Student("小明");
System.out.println(s2.name);
}
}
成员方法的分类:
返回值:
有返回值的方法
没有返回值的void方法
参数列表:
空参数方法
有参数方法
创建一个对象的步骤:
Student s = new Student();
加载Student.class文件进内存
在栈内存为s开辟空间
在堆内存为学生对象开辟空间
对学生对象的成员变量进行默认初始化
对学生对象的成员变量进行显示初始化
通过构造方法对学生对象的成员变量赋值
学生对象初始化完毕,把对象地址赋值给s变量
变量的定义
成员变量: 这个变量是否属于事物中的属性
特点:变量的使用范问越小越好
static关键字
可以修饰成员变量和成员方法
static关键字特点
静态所修饰的成员,随着类的加载而加载,优先于对象存在
静态所修饰的成员,会被所有对象共享
可以通过类名调用
类名.静态成员
举例演示:
class Person{
String name;
int age;
//String country;//国家
static String country;//国家
//构造方法
//空参数构造方法
public Person(){}
//有参数构造方法
public Person(String name, int age, String country){
this.name = name;
this.age = age;
this.country = country;
}
public void show(){
System.out.println(name + ".." + age + ".." + country);
}
}
class StaticDemo {
public static void main(String[] args) {
//创建第一个对象
Person p1 = new Person("刘德华", 45, "中国");
p1.country = "美国";
//创建第二个对象
Person p2 = new Person();p2.name = "张学友";
//创建三个对象
//Person p3 = new Person("张柏芝" , 40, "中国");
Person p3 = new Person();p3.name = "张柏芝";
p1.show();
p2.show();
p3.show();
//可以通过类名调用
//类名.静态成员名
Person.countrySystem.out.println(Person.country);}}
static关键字注意事项
在静态方法中是没有this关键字的
静态方法只能访问静态的成员变量和静态的成员方法
静态只能访问静态
举例演示:
class Demo{
//普通的成员变量
int num = 10;
//静态的成员变量
static int num2 = 20;
//普通的成员方法
public void method(){
System.out.println( num );
System.out.println( num2);
function();function2();
}
//普通方法
public void function(){
System.out.println("我是普通方法");
}
//静态方法
public static void method2(){
//System.out.println( num );// 错误: 无法从静态上下文中引用非静态 变量 num
//System.out.println( this.num2);//错误: 无法从静态上下文中引用非静态 变量 thisSystem.out.println(num2);
//function();//错误: 无法从静态上下文中引用非静态 方法 function()function2();
}
//静态方法
public static void function2(){
System.out.println("我是静态方法");
}
}
class StaticDemo2 {
public static void main(String[] args) {
//创建对象
Demo d = new Demo()
;//d.method();
d.method2();
}
}
继承:
概念:继承是从已有的类中派生出新的类,
新的类能吸收已有类的数据属性和行为,并能扩展新的能力。
(了解)继承的好处和弊端
提高了代码的复用性
多个类相同的成员可以放到同一个类中
提高了代码的维护性
如果功能的代码需要修改,修改一处即可
让类与类之间产生了关系,是多态的前提
其实这也是继承的一个弊端:类的耦合性很强
举例演示:
class Person{
//成员变量
private String name;
private int age;
//构造方法
public Person(){}
public Person(String name, int age){
this.name = name;
this.age = age;
}
//提供公共访问方法,setXxx() getXxx()
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
//学习方法
public void study(){
System.out.println("学习Java");
}
}
//class 老师类 extends 人类
class Teacher extends Person {
}
//class 学生类 extends 人类
class Student extends Person {
}
class ExtendsDemo2 {
public static void main(String[] args) {
//创建老师类对象
Teacher t1 = new Teacher();
t1.setName("周瑜");
t1.setAge(27);
System.out.println( t1.getName() + "..." + t1.getAge());
}
}
继承特点
Java只支持单继承,不支持多继承
Java支持多层继承(继承体系)
举例演示:
class Yy{
int num2 = 11;
}
class Fu extends Yy {
int num = 10;
}
class Fu2{
}
//class Zi extends Fu,Fu2{//报错,java中的类只支持单继承,不支持多继承
class Zi extends Fu { }
class ExtendsDemo3 {
public static void main(String[] args) {
//创建子类对象
Zi z = new Zi();
System.out.println( z.num );
System.out.println( z.num2 );
}
}
继承的注意事项:
子类只能继承父类所有非私有的成员(成员方法和成员变量)
其实这也体现了继承的另一个弊端:打破了封装性
子类不能继承父类的构造方法,
但是可以通过super(后面讲)关键字去访问父类构造方法
不要为了部分功能而去继承
class Fu{
//成员变量
String name = "张";
private int money = 5000;//私有
//构造方法
public Fu(){}
public Fu(String name){
this.name = name;
}
//成员方法
public void method(){
System.out.println("我是public 公共方法");
}
//私有的成员方法
private void method2(){
System.out.println("我是私有方法");
}
}
class Zi extends Fu{
//构造方法
public Zi(){
}
}
class ExtendsDemo4 {
public static void main(String[] args) {
Zi z = new Zi();
System.out.println( z.name );
//System.out.println( z.money );// 错误: money可以在Fu中访问private
//调用方法
z.method();
//z.method2();// 错误: 找不到符号 , 符号: 方法 method2()
//----------------------------------
//创建对象
Zi z = new Zi("张三");//错误: 无法将类 Zi中的构造器 Zi应用到给定类型;
//原因: 实际参数列表和形式参数列表长度不同
}
}
继承中构造方法的注意事项:
子类通过super去显示调用父类其他的带参的构造方法
super(参数列表)
子类通过this去调用本类的其他构造方法
this(参数列表)
一定要注意
super(…)或者this(….)必须出现在第一条语句上
否则,就会有父类数据的多次初始化
方法重写
子类中出现了和父类中一模一样的方法声明,也被称为方法覆盖,方法复写。
使用特点
如果方法名不同,就调用对应的方法
如果方法名相同,最终使用的是子类自己的
方法重写的应用:
当子类需要父类的功能,而功能主体子类有自己特有内容时,
可以重写父类中的方法,
这样,即沿袭了父类的功能,又定义了子类特有的内容
举例演示:
class Fu{
public void method(){
System.out.println("我是父类方法");
}
}
class Zi extends Fu{
//方法重写,方法覆盖
public void method(){
super.method();
System.out.println("我是子类方法");
}
}
class ExtendsDemo9 {
public static void main(String[] args) {
//创建对象
Zi z = new Zi();
z.method();
//super.method();
}
}
方法重写的注意事项:
1:父类中私有方法不能被重写
2:子类重写父类方法时,访问权限不能更低
3:父类静态方法,子类也必须通过静态方法进行重写。
其实这个算不上方法重写,但是现象确实如此,
至于为什么算不上方法重写,多态中我会讲解
举例演示:
class Fu{
//私有方法
private void method(){
System.out.println("我是父类私有方法");
}
void function(){
System.out.println("我是父类function方法");
}
//静态方法
public static void show(){
System.out.println("我是父类静态方法");
}
}
class Zi extends Fu{
//重写父类的私有方法
public void method(){
//super.method();//访问父类方法 错误: method()可以在Fu中访问privateSystem.out.println("我是子类私有方法");
}
//重写父类的方法//private void function(){// 错误: Zi中的function()无法覆盖Fu中的function()
//void function(){
//protected void function() {
public void function() {
System.out.println("我是子类function方法");}
//重写父类的静态方法//public void show(){//错误: Zi中的show()无法覆盖Fu中的show() ,被覆盖的方法为staticpublic static void show(){System.out.println("我是子类的静态方法");
}
}
class ExtendsDemo10 {
public static void main(String[] args) {
Zi z = new Zi();
//z.method();
//z.function();z.show();
}
}
final关键字
final关键字是最终的意思
修饰类,类不能被继承
修饰变量,变量就变成了常量,只能被赋值一次
修饰方法,方法不能被重写
举例演示:
/final class Fu {//错误: 无法从最终Fu进行继承
class Fu {
//nt num = 10;
final int num = 10;
//public void method(){
public final void method(){
System.out.println("我是Fu类方法");
}
}
class Zi extends Fu{
//子类重写父类方法
/*
public void method(){//错误: Zi中的method()无法覆盖Fu中的method()
System.out.println("我是Zi类方法");
}
*/
}
class FinalDemo {
public static void main(String[] args) {
Zi z = new Zi();
//z.num = 20;//错误: 无法为最终变量num分配值
//System.out.println(z.num);
z.method();
}
}
- 黑马程序员——Java基础——构造方法,static关键字,以及继承的详解
- 黑马程序员——高新技术---Java基础语法—面向对象_构造方法,static 关键字
- 黑马程序员——Java基础---面向对象(构造方法和static关键字)
- 黑马程序员—Java面向对象(类和对象、封装、构造方法、this关键字、static关键字)
- 黑马程序员——Java基础---static关键字
- 黑马程序员——static关键字详解
- 黑马程序员---java基础---面向对象中的构造方法及static关键字,变量的问题
- 黑马程序员——【java】static关键字
- 黑马程序员---基础-概述、封装、构造方法、this和static关键字、继承
- 黑马程序员——JAVA继承中的构造方法
- 黑马程序员—static关键字
- 黑马程序员——java中static关键字的应用
- 黑马程序员——面向对象——构造方法与static关键字
- 黑马程序员——static关键字丶main方法丶继承...
- 黑马程序员——OC语言基础---Static关键字使用
- 黑马程序员——Java基础---继承
- 黑马程序员——Java基础---继承
- 黑马程序员——Java基础--继承
- jQuery.Autocomplete 自动完成
- Scrapy 学习笔记(一)
- CodeForces 115E Linear Kingdom Races(线段树 + DP)
- linux内核内存分配(二、struct slab和struct kmem_cache)
- Android内核学习之二------JNI的使用
- 黑马程序员——Java基础——构造方法,static关键字,以及继承的详解
- (一〇九)UIButton的使用技巧 -imageView、titleLabel、圆角等
- Valid Anagram
- nginx的学习笔记
- linux 进程间通信 使用信号量
- 树莓派实战4:配置一小时发送一次邮件
- YUV格式学习:NV12和YUV420P格式互换
- 89. Gray Code
- Python 之 LIBSVM 使用小结(一)