------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------
第一讲 面向对象构造方法
一,构造方法特点:
A: 方法名与类名相同
B: 没有返回值类型,连void也没有
C: 没有返回值
构造方法的作用:
是给成员变量进行初始化
二,构造方法格式: public 类名(){} 这是一个无参的构造方法
注意:如果我们没有给出构造方法,系统会给我们提供一个无参的构造方法,
而成员变量,系统会给其赋与默认值,基本数据类型 int为 0 ,引用数据类型为null
而如果我们定义了一个带参的构造方法,也是有默认值的,它会被你定义的成员覆盖
二,创建对象并赋值:
两种方式,看下面代码:
class Phone {
// 成员变量
private String brand ; // 品牌
private String color ; // 颜色
private int price ; // 价格
// 构造方法
public Phone(){}
public Phone(String brand , String color , int price){
this.brand = brand ;
this.color = color ;
this.price = price ;
}
// 提供get和set方法
public String getBrand(){
return brand ;
}
public void setBrand(String brand){
this.brand = brand ;
}
public String getColor(){
return color ;
}
public void setColor(String color){
this.color = color ;
}
public int getPrice(){
return price ;
}
public void setPrice(int price){
this.price = price ;
}
}
// 测试类
class PhoneDemo {
public static void main(String[] args){
// 创建手机对象方式1
Phone p = new Phone();
// 给成员变量赋值
p.setBrand("苹果");
p.setColor("白色");
p.setPrice(100);
// 获取成员变量
System.out.println(p.getBrand() + "---" + p.getColor() + "---" + p.getPrice());
System.out.println("----------------------------------");
// 创建手机对象方式2
Phone p2 = new Phone("三星" , "黑色" , 50);
// 获取成员变量
System.out.println(p2.getBrand() + "---" + p2.getColor() + "---" + p2.getPrice());
}
}一,static的特点:
A: 随着类的加载而加载
B: 优先于对象存在
C: 被所有对象共享
D: 可以通过类名来调用
也可以通过对象名调用
建议使用类名对其调用
static是可以修饰成员变量各成员方法的,被static修饰的成员变量能被整个类访问.
二,static的注意事项:
静态方法中是没有this关键字的,静态是随着类的加载而加载,this是随着对象存在而在
三,静态方法调用总结:
静态只能访问静态,非静态则可以访问静态跟非静态
看下面代码
class Person {
// 成员变量
String name ; // 姓名
// String country ; // 国籍
static String country ;
public void show(){
System.out.println(name + "---" + country);
}
}
// 测试类
class PersonDemo {
public static void main(String[] args){
// 创建一个对象
Person p = new Person();
// 给成员变量赋值
p.name = "凤姐";
p.country = "中国";
// 调用show方法
p.show();
// 创建第二个对象
Person p2 = new Person();
//给成员变量赋值
p2.name = "刘亦菲";
// p2.country = "中国";
// 调用show方法
p2.show();
System.out.println("-----------------------");
p.country = "美国";//从这里可以看出,被static修饰的country被共享了
p.show();
p2.show();
}
}一,main方法的格式解释:
public static void main(String[] args){}
public(公共的): 由于main方法是被JVM调用的,所以要求访问权限最大
static(静态的): 由于main方法是被JVM调用的,所有可以不用创建对象,直接使用类名调用
void(空): 由于main方法是被JVM调用的,所以不需要返回值
main(主要的): main是一个特殊的单词,可以被JVM识别
String[] args: 用来接收键盘录入数据
二,静态变量与成员变量的区别
A:所属不同
静态变量属于类，所以也称为类变量
成员变量属于对象，所以也称为实例变量(对象变量)
B:内存中位置不同
静态变量存储于方法区的静态区(共享区)
成员变量存储于堆内存
C:内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失
D:调用不同
静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对象名调用
第四讲 继承
一,继承的定义
当我们定义学员类：
学员：
学员编号,姓名,年龄,性别
教师：
教师编号,姓名,年龄, 性别
我们发现：
1.学员和教师都属于咱们学校的"一个人员"；
2.学员和教师中都定义一些"相同的成员"： 姓名,年龄,性别
这时，我们可以将这些具有"相同类型"的成员，进一步抽取到一个新类中；
将这个新类作为"父类"，我们的"学员"和"教师"类可以"继承自"这个"父类"，达到
一个"代码重用的目的"
1.语法：子类继承时使用关键字：extends(重点)
2.继承其它类的类叫"子类"，被继承的类叫"父类"、"超类"、"基类"
3.当子类继承了父类后，就自动拥有了父类中允许被继承的成员；大家可以近似的认为：子类就是拥有了父类中的可以被继承的成员
4.作用：代码重用
class Person
{
String name;//姓名
int age;//年龄
char sex;//性别
void show(){
System.out.println("我是黑马的一员，我骄傲！！");
}
}
//Person的"子类"
class Student extends Person
{
String stuNo;//学员编号
int score;//分数；
}
//Person的"子类"
class Teacher extends Person
{
String teaNo;//教师编号
}
//当再需要"员工类"时，也需要这些成员时，可以直接继承自"Person"
class Employee extends Person
{
//自动拥有了Person的三个属性和一个方法；
}
class Demo
{
public static void main(String[] args)
{
Student stu = new Student();
System.out.println(stu.name);//继承的
System.out.println(stu.age);//继承的
System.out.println(stu.sex);//继承的
System.out.println(stu.stuNo);//自己的
stu.show();
Teacher tea = new Teacher();
System.out.println(tea.name);//继承的
System.out.println(tea.age);//继承的
System.out.println(tea.sex);//继承的
System.out.println(tea.teaNo);//自己的
tea.show();
}
}1.Java中只允许单继承：一个类同时只能继承自一个类；
2.Java中允许多级继承：
代码如下:
class A{
}
class B extends A{
}
class C extends B{
}
//错误的，Java中不能多继承
class D extends A,B{
}1.子类不能继承父类中私有成员：
2.构造方法是不能被继承的；
3.当实例化一个子类对象时，会调用父类的构造方法，实例化一个父类对象；这个父类对象，是存储在子类对象空间内的。
4.不要为了部分功能而去继承：
5.当类和类之间是：是一个(is a)的关系时，使用继承：学员是黑马的一员,教师是黑马的一员,所以，Student与Teacher都可以继承自Person
四,继承中成员变量的关系
1.首先在子类局部范围找
2.然后在子类成员范围找
3.最后在父类成员范围找(肯定不能访问到父类局部范围)
4.如果还是没有就报错。(不考虑父亲的父亲…)
class A
{
int num = 10;
}
class B extends A
{
int a = 20;
int num = 30;//子类成员变量，覆盖父类的成员变量；
void show(){
//就近原则；
int num = 40;//局部变量，覆盖成员变量
System.out.println("num = " + num);//40 注意：先找局部，再找成员，再找父类；
System.out.println("this.num = " + this.num);//30，注意：如果本类没有，会向父类去找；
System.out.println("super.num = " + super.num);//访问父类的num : 10
}
}
class Demo
{
public static void main(String[] args)
{
B b = new B();
//在外部访问B中的成员变量
/*
System.out.println(b.num);
System.out.println(b.a);
*/
b.show();
}
}this：1.永远指向本类对象的空间，它由JVM自动赋值，
2.它可以调用本类对象的成员属性、成员方法、构造方法
3.可以在本类的一个构造方法中调用另一个构造方法；
注意：当在一个构造方法中使用this调用另一个构造方法时，this语句必须写在这个构造方法的第一句有效语句。
super:
1.一般用于"子类中"；
2.它永远指向本类的父类，它由JVM自动赋值；
3.它可以调用父类的成员变量、成员方法、构造方法；
4.当我们实例化一个子类对象时，JVM会先实例化此类的父类，并调用父类的"无参的构造方法";
注意：
1.当父类没有提供"无参构造方法"时而提供了其它带参的构造方法，那么JVM就不会为父类添加一个无参的构造方法，
当我们实例化子类对象时，JVM会自动去实例化它的父类，如果父类中没有无参构造方法，JVM就不知道怎么调用带参
的构造方法，所以我们在子类中，必须显示的使用super() 去调用父类中带参构造方法；
2.当在子类的构造方法中，使用super去调用父类的构造方法时，super语句必须方法第一句有效语句。
注意：在一个构造方法中，不能同时this()和super()。因为都需要在第一句话；
六,继承中成员方法的关系
1.子类中可以定义跟父类一模一样的方法；
这时子类的方法会覆盖父类同名的方法，这种方式叫：方法重写；
2.一模一样的方法：
方法定义的语法：
访问修饰符 返回值类型 方法名 (形参列表)
在子类中定义如下方法：
返回值类型 方法名 相同 ，形参列表不相同；编译可以通过，它类似于方法的重载。
返回值类型不同，方法名和形参列表都相同；编译错误。必须指定相同的返回值类型；
指：子类中的方法要与父类的方法具有相同的：返回值类型、方法名、形参列表。
子类方法的"访问修饰符"可以和父类相同，也可以更宽；
private,(默认),protected,public:从窄到宽
七,方法重写
1.有些时候，父类中定义了一些方法的实现；
2.子类需要保留方法的名称，但希望做一些子类特有的事情，这个时候就可以重写父类中的方法
注意:1.子类不能重写父类中的私有的方法；
class A
{
private void show(){
System.out.println("A --> show()");
}
static void method(){
System.out.println("A --> static method()");
}
}
class B extends A
{
//子类中可以定义show()方法，但绝对不是覆盖父类中private的show()方法，各自是各自的，这不是重写；
public void show(){
System.out.println("B --> show()");
}
static void method(){
System.out.println("B --> static method()");
}
}
class Demo
{
public static void main(String[] args)
{
B b = new B();
b.show();
B.method();//没有重写时，访问的是父类的；当子类重写父类方法后，访问的是子类的。
}
}final关键字
1.它表示最终的。
2.它可以修饰类、成员变量、局部变量、成员方法；
3.修饰类：此类代表"最终类"，不能被继承；
修饰成员变量、局部变量：代表这个变量拥有最终的值，其值只能被赋值一次，一旦赋值后，其值不能更改；这叫：常量；
修饰成员方法：表示"最终方法"，不能被重写；
以后我们在Java类库中，会看到类库中的一些类，会使用final关键字，我们要根据定义，去决定是否去继承，重写等操作；
final在定义全局常量时，会经常用到：它经常会和static关键字一起使用
super关键字
1.经常用于子类中；
2.它用来访问父类中的成员：成员变量，成员方法，构造方法
3.一般时候，我们不需要显示的使用。
4.有些情况，在子类中，要访问父类的成员时，必须要显示的使用super:
1).当子类的成员，覆盖父类成员时，并且需要访问父类成员时；
2).父类没有提供"无参的构造方法"
扫一扫
620
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
