类和对象
在面向对象编程中，将“具体的”称为“对象”，将“抽象”称为“类”
类和对象：类是抽象的，(人) 对象是具体的，(张三)
多个对象，可以抽象出类
类可以产生多个对象
类和对象的组成部分： 静态：属性（属性名，属性值） ：身高 体重 年龄 颜色 形状等
动态（功能）：方法：吃饭 睡觉 支撑等
例： 桌子：类 这个桌子：对象
类可以细分，但细分并不一定是对象。
例如 人：男人 女人 如果觉得抽象了那就是一个类，如果觉得是具体了那就是一个对象
类：可以根据范围的不同，在细分：对象：具体，不能再细分
类：由一组抽象的属性和方法构成 对象：由一组特定属性和方法构成
类 zs=new 类()；
例： Person zs=new Person();
Person ls=new Person();
方法是多个对象共享的 属性是各个对象独有的
一般而言，对象 是指堆中的东西.... 栈里面zs的称为引用
引用：相当与c语言的指针。持有对象的内存地址 但是根据Everything is an Object
属性：就是全局变量
全局变量：方法以外，类以内；有初始值（数据类型的默认值 int 0）
局部变量：方法内部：没有初始值，在使用前必须赋初值
局部变量可以和全局变量重名，并且局部变量优先级高
package Demo02;
public class Person
{
//类：由一组抽象的属性和方法构成 抽象 ：没有具体的属性和方法，只看到名字和年龄但不知道值是多少
//静态 属性
String name;
int age;
//动态 方法
//吃饭
public void eat()
{
System.out.println("吃饭");
}
//睡觉
public void sleep()
{
System.out.println("sleep");
}
}
package Demo02;
public class TestPeson
{
public static void main(String[] args)
{
// 对象：由一组特定属性和方法构成
//看到张三这个人了，他叫张三，年龄28
Person zs=new Person(); //产生这个人叫张三
//张三有属性名和年龄
//对象.属性
zs.name="张三";
zs.age=28;
System.out.println(zs.name); //赋完值就可直接用
System.out.println(zs.age);
//对象.方法 叫做对象调用方法 对象的调用
zs.eat();
zs.sleep();
Person ls=new Person();
ls.name="李四";
ls.age=33;
System.out.println(ls.name);
System.out.println(ls.age);
ls.eat();
ls.sleep();
//方法是多个对象共享的
//属性是各个对象独有的
}
}
方法的调用的常见情况：
一个类中:
都有static ，或都没有static：或没的调有的：直接调用有static
有static 不能直接调用 没有static的方法
调用没static：对象名.方法() 调用static：直接调用
不在同一个类：
万能方法：new 对象，通过对象点方法();
类名.方法() 其中的方法必须是static 修饰符的
static方法 是类级别的 ，属于类
非static方法 是对象级别的，属于对象
对象.static方法() 对象.非static方法()
类.static方法()
类包含对象，类产生对象 例：类有的，对象也有，对象有的，类不一定有
静态方法: 有static
非静态方法：没有static修饰符
package Demo02;
public class Person2
{
public static void eatFruit()
//public void eatFruit()
//{ System.out.println("吃水果");}
{
System.out.println("吃水果");
}
public void eatFood() //非静态方法
//public static void eatFood() 静态方法 报错
//{eatFruit();} //不可以调用
{
System.out.println("吃主食");
eatFruit(); //可以调用
}
}
package Demo02;
public class TestPeson
{
public static void main(String[] args)
{
Person2 p2=new Person2();
p2.eatFood();
}
}
多个构造方法之间 不能循环调用
子类继承父类：
private，构造方法 是不能被继承的。但是 子类可以显示的调用父类构造super
private：本类 属性
public：全部 方法
protected：父子关系 子类继承父类
子类引用父类的protected属性：
1. 不要new，子类直接使用父类属性 （子类直接拿父类的东西）
静态代码块：第一次执行，永远执行一次。初始化（人机猜拳：人 计算）
普通代码块：在每次执行无惨构造之前执行。
package Demo02;
public class TestStatic
{
public TestStatic()
{
System.out.println("无参构造");
}
static { //静态代码块
System.out.println("static");
}
{ //普通代码块
System.out.println("普通代码块....");
}
public static void main(String[] args)
{
new TestStatic();
new TestStatic();
new TestStatic();
/*
结果
static
普通代码块....
无参构造
普通代码块....
无参构造
普通代码块....
无参构造
*/
}
}
new Xxx()：经历了以下过程
package Demo02;
public class Father
{
static {
System.out.println("父类static...");
}
{
System.out.println("父类普通代码块");
}
public Father()
{
System.out.println("父类无参...");
}
}
package Demo02;
public class Son extends Father
{
static {
System.out.println("子类static...");
}
{
System.out.println("子类普通代码块");
}
public Son()
{
//无参构造方法会默认执行了super();
// 调用子参构造时会自动执行父类无参
System.out.println("子类无参...");
}
}
package Demo02;
public class TestSon
{
public static void main(String[] args)
{
//在new 产生对象之前，经历了哪些过程(程序的初始化流程)
Son son=new Son(); //调无惨构造
/*
结果：
父类static...
子类static...
父类普通代码块
父类无参...
子类普通代码块
子类无参...
*/
}
}
方法重载：方法名相同，参数列表不同（类型不同 或 个数不同 或 顺序不同）
注意两点：1.与返回值无关 2.与参数名无关
方法重写：父类有一个方法，子类重写了一遍 （父子关系）
要求：1.方法名相同
2.参数列表也相同
浙公网安备 33010602011771号