今日内容
1.构造方法(★)
构造方法
1)方法名和类名完全一致,大小写符号全部一致
2)没有具体的返回值
3)甚至连void没有返回值都没有
4)创建面向对象的过程,就是系统同时默认提供了无参的构造方法
---类名 对象名 = new "类名()" ;
格式
class 类名{
//无参的构造方法
public 方法名---与类名一致(){
...
}
//有参的构造方法
public 方法名---与类名一致(参数类型1 参数名1 , 参数类型2 参数名2 ,...){
...
}
}
构造方法是支持方法重载的
---方法名相同,参数列表不同,与返回值无关
注意事项
1)如果一个类中没有自行定义任何构造方法--有参/无参构造方法
--->系统会默认提供一个无参的构造方法!
2)如果一个类中自行定义了有参的构造方法,那么系统将不会默认定义无参的构造方法
--->此时如果想通过对象调用无参的构造方法---会报错!
3)给成员变量赋值两种方法
---利用setXXX(xx)赋值
---利用有参的构造方法进行赋值
public class phone {
//通过set/get方法赋值和调用
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
private String name ;
private int price ;
//通过构造方法来进行赋值
//无参的构造方法
public phone(){ //没有返回值,也没有void
name = "华为" ;
price = 6999 ;
}
//有参的构造方法
public phone(String name , int price){ //没有返回值,也没有void
this.name = name ;
this.price = price ;
}
//行为方法
public void show1(){
System.out.println("牌子:"+name+"价格:"+price);
}
}
public class phoneTest {
public static void main(String[] args) {
phone p = new phone() ;//无参的构造方法调用,系统默认时值为空或者0
//无参构造方法已经赋过值
p.show1();//直接输出:牌子:华为价格:6999
phone p1 = new phone("锤子手机",7777) ;//有参构造方法,创建对象时就赋值
p1.show1();//直接输出:牌子:锤子手机价格:7777
}
}2.成员变量
什么时候将变量定义为成员变量?
如果被定义的变量是描述现实世界具体东西的属性的
---就被定义为成员变量,其他全部定义为局部变量
---局部变量随着方法结束而立即释放,不会造成数据冗余
举例
长方形中
长和宽就是它的属性
3.static关键字(★)
static关键字
1)随着类的加载而加载
---在类加载时,静态相关的成员(被static修饰的变量和方法),先被加载加入内存区--静态区
2)优先于对象存在,不能和this共存
3)static本身的含义--静止的,不动的
---在类中作为关键字,体现"共享,公用"的意思
---如果需求的表达中有出现表示共享,公用的变量,直接用static修饰
4)被static修饰变量和方法,推荐使用--必须使用这种!
类名.静态变量名 ;
类名.静态方法名() ;
static关键字注意事项
1)非静态的方法,既可以访问静态的方法或变量,也可以访问非静态的方法和变量
2)静态的方法,只能访问静态的变量和静态的方法
static关键字拓展
被static修饰静态变量和静态方法---必须用类名来调用
---对象当然可以调用,但是当无参构造方法被private修饰时,无法调用,只能用类名调用
无法通过类名调用非静态方法(跨类)
一个类要调用另一个类里的东西
1)面向对象,通过对象名(内存地址)调用
2)被static修饰后用类名直接调用
...待补充
public class staticDemo { //方便观察,直接赋值
//定义一个静态的成员变量name
static String name = "钟离" ;
//定义一个非静态的成员变量age
int age = 500 ;
//定义一个静态的方法
public static void show1(){
//静态方法访问静态变量
System.out.println(name);
//静态成员访问非静态变量
//System.out.println(age);//报错,不能访问!
}
//定义一个非静态方法
public void show2(){
//非静态方法访问静态变量
System.out.println(name);
System.out.println(age);
}
}
public class staticDemo1 {
//定义一个私有的无参构造方法,阻止通过对象名访问
private staticDemo1(){}
static String name = "zhongli" ;
static int age = 500 ;
//定义一个静态方法
public static void show3(){
System.out.println(name);
System.out.println(age);
}
//定义一个非静态方法
public void show4(){
System.out.println(name);
System.out.println(age);
}
}
public class staticTest {
public static void main(String[] args) {
//创建面向对象
staticDemo sd = new staticDemo() ;
//静态成员用类名调用!
String name = staticDemo.name ;
System.out.println(name);
//静态方法用类名调用!
staticDemo.show1();
//实验是否可以创建面向对象
//staticDemo1 sd1 = new staticDemo1() ;//报错!成功被阻止
//通过类名调用
staticDemo1.show3(); //成功调用
//非静态方法无法通过类名调用
//staticDemo1.show4();//失败
}
}
4.代码块
代码块---{}
局部代码块
位置--
在局部位置(方法定义)定义的 {}
作用--
限定某个变量的生命周期
构造代码块
位置--
在类的成员(class中方法外)位置定义的 {}
作用--
如果构造代码块和构造方法同时存在,优先执行构造代码块里的内容
---优先级
构造代码块>构造方法
静态代码块
位置--
在类的成员(class中方法外)位置定义的 static{}
作用--
随着类的加载,优先于所有代码块或者方法,优先执行
---一个类就加载一次,所以静态代码块也只加载一次!
静态代码块,构造代码块,构造方法优先级
静态代码块 > 构造代码块 > 构造方法
public class codeDemo {
//静态代码块
static {
System.out.println(1);
}
//构造代码块
{
System.out.println(2);
}
//构造方法
public codeDemo(){
System.out.println(3);
}
}
public class codeTest {
public static void main(String[] args) {
//局部代码块根据位置不同,执行顺序不一样
{
System.out.println(5);
}
codeDemo cd = new codeDemo() ;
//局部代码块
{
System.out.println(4);
}
}
}
/*
输出结果:
5
1
2
3
4
*/5.继承
继承extends
将多个类的共性抽取放到一个独立的类中,这个独立的类就和多个类产生了一种关系
---继承
---关键字extends
格式
class 父类名(超类名){
私有属性
公共方法
其他成员方法
}
class 子类名(派生类名) extends 父类名{
}
特点
1)提高了代码的复用性
2)提高了代码的可维护性
3)类与类产生了继承关系,是多态的前提条件
优势
1)类与类之间的关系只支持单继承
不能---class 子类名 extends 父类名 , 爷类名{}---大错特错!
2)可以多层继承
class 父类名 extends 爷类名{}
class 子类名 extends 父类名{}
---可以!
劣势
存在局限性,不能为了某一方法不断的使用继承
---当出现子类是父类的一种时,可以用继承!
开发原则
低耦合,高内聚!
---耦合
类与类的关系越少越好--耦合度越低越好!
---内聚
一个类完成某个事情的能力--越高越好!
public class YeLeiMing {
String name = "爷类" ;
int age = 800 ;
public void show1(){
System.out.println(name+", "+age);
}
}
public class FuLeiMing extends YeLeiMing {
//定义一个公共属性
String name = "父类" ;
//定义一个公共属性
int age = 500 ;
//定义一个公共方法
public void show(){
System.out.println(name+", "+age);
}
}
public class ZiLeiMing extends FuLeiMing {
String name = "子类" ;
int age = 200 ;
public void show2(){
System.out.println(name+", "+age);
}
}
public class extendsTest {
public static void main(String[] args) {
//创建子类的面向对象
ZiLeiMing zlm = new ZiLeiMing() ;
zlm.show2();
zlm.show();
zlm.show1();
}
}
/*
输出结果
子类, 200
父类, 500
爷类, 800
*/
本文含有隐藏内容，请 开通VIP 后查看