目录
一、包
1、包的作用:
(1)避免类的重名问题
有了包后,类的名称就比较长了,类的全名称就变为了:包。类名
例如:
java.util.Scanner ——Scanner类的全名称
java.lang.String ——String类的全名称
java.lang.System——System类的全名称
java.lang.Math——Math类的全名称
(2)分类组织管理众多的类
java.io——和IO(输入输出)有关
java.util——和各种常用工具类有关
java.lang——核心系统类
java.net——和网络编程有关
java.sql——和数据库编程有关
(3)用于访问权限控制
如果某个类或某个方法的权限修饰符省略,那么就仅限于本包使用
2、如何声明包?
语法格式:
package 包名;
这句话有要求:
(1)一个.java源文件只能有一句
(2)必须在源文件的代码首行
包的命名规范:
(1)所有单词都小写,每个单词之间用 . 分割
(2)习惯上用公司的域名倒置+模块名
例如:
com.atguigu.xx
com.mysql.xxx
com.alibaba.xxx
org.aphache.xxx
一级域名:
com:商业
org:非营利性组织
gov:政府
edu:教育
……
3、如何编译带包的类
例如:
编译:javac -d . 源文件名.java
4、如何运行带包的类
java 包.类名
5、如何用另一个包的类?
另一个包的类:
package com.moumou.bean;
class Circle{
private double radius;
Circle(){
}
Circle(double r){
radius=r;
}
void printInfo(){
System.out.println("半径"+radius);
}
}
编译一下:只能编译一下,不能运行,因为里面没有main方法,没有入口
编译之后所在的文件夹:
第一种:
编译:报找不到符号的错误,因为我们没有加上包名
第二种:加上包名
编译:访问不到另外一个包
在另一个包的类前面加public修饰符
编译:所以构造器和方法前面都要加public修饰符
在构造器和方法前面加上public修饰符后:
经过上面发现,用另一个包的类,如果总是包.类名的写法就会比较繁琐,所以可以用import语句+简名称:
总结:
前提:被使用的类或成员的权限修饰符得允许跨包使用
方式:
(1)使用全名称:包.类名
(2)使用import语句+简名称
说明:
(1)import语句是写在package语句与class声明之间
(2)导包语句可以很多句,导不同包的类
(3)java.lang包中类可以不使用import语句,就直接使用简名称
例如:System,String,Math……
(4)可以同时导入同一个包中的很多类
improt 包.*
例如:
(5)如果出现了不同包,但是类名相同
例如:
java.util.Date
java.sql.Date
编译:
解决方法:所以只能一个选择使用全名称,一个使用简名称,不能同时使用简名称。
二、eclipse概述与基本界面
下载的网址:https://www.eclipse.org/downloads/
1、安装步骤
workspace:
我在D盘新建一个文件夹:
进入之后的界面:
原本我们notpad++写java代码,那命令行工具编译运行代码,现在用eclipse开发工具可以:
目前我们的界面是以下样子:
如果想下次一进来就是这样的样子:
然后在new Window的时候就会打开上次的布局:
2、新建项目
1、新建java项目
2、新建一个包
3、在包下面建class文件
这样就能将包和类同时建立:
三、eclipse的使用:颜色与字体
1、 调整界面的字体大小:
效果:
2、改变编辑区域的代码
效果:
像以下这种颜色也是可以设置的:
上图中圈圈和圈圈的内容对应设置,长方形和箭头对应设置。
除此之外也可以选择主题:
效果图:
四、eclipse的使用:运行与字符编码
1、运行项目
用这个eclipse工具编写代码不需要编译,代码写完保存就会自动编译。
如何运行?
除此之外:
2、统一编码格式
五、eclipse的使用:快捷键
第一个提示:新的局部变量
第二个提示:生成一个属性
假设想改类名,也可以用Ctrl+1
快速导包操作:
将以上代码复制到Eclipse中:
然后包就被导入进来了:
查看某个类的源代码文件:
六、eclipse的使用:快速开发
效果:
效果图:
选择Generate Getters and Setters的效果图:
七、关键字this
1、意思:当前对象
(1)构造器:正在被创建的对象
(2)方法:正在调用该方法的对象
2、用法
(1)this.属性
当局部变量与成员同名时,可以在成员变量的前面加this
(2)this.方法:没用非用不可的时候
(3)this()或this(实参列表)
this()表示调用本类的无参构造
this(实参列表)表示调用本类的有参构造
this()或this(实参列表)必须在构造器的首行
八、eclipse的使用:导入项目和删除
九、面向对象的基本特征之二:继承(1)
继承的两层意思:
(1)延续
(2)扩展
1、为什么要有继承?
(1)当某个类,需要派生出很多子类别
Person类:需要派生出Teacher,Student等等子类别
那么此时Person中的共有的部分,就不需要在子类别中再次去声明
(2)当多个类,出现了共同的特征时,可以把共同的部分抽取到父类中
2、目的
代码的复用与扩展
3、如何实现继承?
【修饰符】 class 子类 extends 父类{
}
子类:subclass,也称为派生类
父类:superclass,也称为超类,基类
4、继承的特点:
(1)子类继承了父类,
从事物的特征来说,子类会继承父类所有的特征(属性和方法)
但是从代码操作角度来说,父类中私有的属性、方法在子类中是不能直接使用的
举例代码:
package com.moumou.test;
public class TestThis{
public static void main(String[] args) {
Teacher t=new Teacher();
t.setName("小可爱");
t.setAge(18);
System.out.println("姓名:"+t.getName());
System.out.println("年龄:"+t.getAge());
}
}
class Person{
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
class Teacher extends Person{
private double salary;
public void test(){
System.out.println("name = " + name);//报错:父类私有的属性在子类中不能直接使用
}
}
上诉代码中,Person是父类,Teacher是子类,继承父类,父类中有name属性,但是由于name属性是私有的,所以子类是不能直接使用的!
(2)子类继承父类时,构造器是不能被继承的
举例代码:
package com.moumou.test;
public class TestThis{
public static void main(String[] args) {
Teacher t=new Teacher();
t.setName("小可爱");
t.setAge(18);
System.out.println("姓名:"+t.getName());
System.out.println("年龄:"+t.getAge());
Teacher t1=new Teacher("小笨蛋",19);//报错
}
}
class Person{
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
class Teacher extends Person{
private double salary;
public void test(){
//System.out.println("name = " + name);//报错:父类私有的属性在子类中不能直接使用
}
}
说明,上诉中父类有无参的构造器和有参的构造器,但是子类继承父类时,构造器是不能被继承的,所有上诉代码Teacher t1=new Teacher("小笨蛋",19);会报错
(3)子类继承父类时,在子类的构造器中一定要去调用父类的构造器
默认情况下,调用的是父类的无参构造
如果父类没有无参构造,那么在子类的构造器的首行,必须手动调用父类的有参构造;
代码如下:
package com.moumou.test;
public class TestThis{
public static void main(String[] args) {
Teacher t=new Teacher();
t.setName("小可爱");
t.setAge(18);
System.out.println("姓名:"+t.getName());
System.out.println("年龄:"+t.getAge());
//Teacher t1=new Teacher("小笨蛋",19);//报错
}
}
class Person{
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
class Teacher extends Person{
private double salary;
public void test(){
//System.out.println("name = " + name);//报错:父类私有的属性在子类中不能直接使用
}
}
上诉代码中,Teacher类继承Person类,但是Person类是没有无参构造,所以会报错:
所以解决方案就两种,要么在父类中添加无参构造,要么在子类的构造器的首行,必须手动调用父类的有参构造
举例:
super(name,age):调用了父类的有参构造
package com.atguigu.test02;
/*
* 继承:
* (1)延续
* (2)扩展
*
* 1、为什么要有继承?
* (1)当某个类,需要派生出很多子类别
* Person:
* 需要派生出Teacher,Student等等子类别
* 那么此时Person中的共有的部分,就不需要在子类别中再次去声明
* (2)当多个类,出现了共同的特征时,可以把共同的部分抽取到父类中
*
* 目的:
* 代码的复用和扩展
*
* 2、如何实现继承?
* 【修饰符】 class 子类 extends 父类{
* }
*
* 子类:subclass,也称为派生类
* 父类:superclass,也称为超类,基类
*
* 3、继承的特点:
* (1)子类继承了父类,
* 从事物的特征来说,子类会继承父类所有的特征(属性和方法)。
* 但是从代码操作角度来说,父类中私有的属性、方法在子类中是不能直接使用的
* (2)子类继承父类时,构造器是不能被继承的
* (3)子类继承父类时,在子类的构造器中一定要去调用父类的构造器
* 默认情况下,调用的是父类的无参构造;
* 如果父类没有无参构造,那么在子类的构造器的首行,必须手动调用父类的有参构造;
*
* 未完待续。。。
*/
public class TestInherited {
public static void main(String[] args) {
Teacher t = new Teacher();
t.setName("柴老师");
t.setAge(18);
System.out.println("姓名:" + t.getName());
System.out.println("年龄:" + t.getAge());
// Teacher t2 = new Teacher("宋老师",28);
}
}
class Person{
private String name;
private int age;
//构造器
public Person(String name, int age) {
this.name = name;
this.age = age;
}
//get/set
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
class Teacher extends Person{
private double salary;
public Teacher() {
super(null, 0);
}
public Teacher(String name, int age, double salary) {
super(name, age);//调用父类的有参构造,必须在子类构造器的首行
this.salary = salary;
}
public void test(){
//System.out.println("name = " + name);//父类私有的属性在子类中不能直接使用
}
}
class Student extends Person{
private int score;
public Student(String name, int age, int score) {
super(name, age);//调用父类的有参构造,必须在子类构造器的首行
this.score = score;
}
}
十、面向对象的基本特征之二:继承(2)
* (1)子类继承了父类,
* 从事物的特征来说,子类会继承父类所有的特征(属性和方法)。
* 但是从代码操作角度来说,父类中私有的属性、方法在子类中是不能直接使用的
* (2)子类继承父类时,构造器是不能被继承的
* (3)子类继承父类时,在子类的构造器中一定要去调用父类的构造器
* 默认情况下,调用的是父类的无参构造;
* 如果父类没有无参构造,那么在子类的构造器的首行,必须手动调用父类的有参构造;
* (4)Java只支持单继承,即一个Java类只能有一个直接父类
* 只能有一个亲生父亲
* (5)Java支持多层继承,即父类还可以有父类
* 代代相传
* (6)一个Java类可以同时有很多个子类,而且子类还可以有子类
* 一个父亲可以有多个孩子,子孙满堂
* (7)子类可以扩展父类没有的属性、方法
举例代码:
java的继承只能单继承,不能有两个父类,但是我们这么做,间接继承:
十一、方法的重写
关键字:Override
当子类继承了父类的方法时,但是父类的方法体不适用于子类了,那么子类可以选择进行“重写overwrite”;
方法=方法签名/方法头+方法体
举例:
package com.atguigu.test02;
/*
* 方法的重写:Override
* 当子类继承了父类的方法时,但是父类的方法体不适用于子类了,那么子类可以选择进行“重写overwrite”。
*
* 方法 = 方法签名/方法头 + 方法体
*
* 重写有要求:
* (1)方法名:必须和父类被重写的方法名“相同”
* (2)形参列表:必须和父类被重写的形参列表“相同”
* (3)返回值类型:
* 基本数据类型和void:要求与父类被重写的方法的返回值类型“相同”
* 引用数据类型:要求子类重写的方法的返回值类型 <= 父类被重写的方法的返回值类型
* 例如:
* 子类方法的返回值类型是Student,父类被重写方法的返回值类型是Student
* 子类方法的返回值类型是Student,父类被重写方法的返回值类型是Person
* 子类方法的返回值类型是Person,父类被重写方法的返回值类型是Student(错误的)
* (4)修饰符
* ①权限修饰符:子类重写的方法的权限修饰符的可见性范围 >= 父类被重写方法的权限修饰符的可见性范围
* 例如:
* 子类方法的权限修饰符是public,父类被重写方法的权限修饰符public
* 子类方法的权限修饰符是public,父类被重写方法的权限修饰符protected
* ②其他修饰符(后面讲)
*/
public class TestOverride {
public static void main(String[] args) {
Manager m = new Manager("崔志恒", 20000,1000);
System.out.println(m.getInfo());
}
}
//员工
class Employee{
//属性列表
private String name;
private double salary;
//构造器列表
public Employee(String name, double salary) {
this.name = name;
this.salary = salary;
}
public Employee() {
}
//get/set
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public String getInfo(){
return "姓名:" + name + ",薪资:" + salary;
}
}
//经理
class Manager extends Employee{
//子类的属性列表
private double bonus;//奖金
//子类的构造器列表
public Manager(String name, double salary, double bonus) {
super(name, salary);
this.bonus = bonus;
}
public Manager() {
}
//子类的get/set
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
//重写父类的getInfo()
public String getInfo(){
//父类的name和salary的属性是私有的,不能在子类中直接使用
//return "姓名:" + name + ",薪资:"+salary + ",奖金" + bonus;
return "姓名:" + getName() + ",薪资:"+ getSalary() + ",奖金" + bonus;
}
}
十二、继承的练习题
十三、关键字:super
从父类中去查找,引用父类的xx
用法:
(1)super.属性
当子类声明了和父类同名的属性时,可以使用super.属性来访问父类的属性
(2)super.方法
(3)super()或super(实参列表)
举例:
package com.atguigu.test02;
/*
* super:
* 从父类中取查找,引用父类的xx
* 要求:super只能方法在子类中可见的属性、方法、构造器
*
* 用法:
* 1、super.属性
* 当子类声明了和父类同名的属性时,可以使用super.属性来访问父类的属性
*
* 2、super.方法
* 当在子类中需要调用父类被重写的方法时,可以使用super.方法
*
* 3、super()或super(实参列表)
* super();调用父类的无参构造
* super(实参列表):调用父类的有参构造
*
* 注意:
* (1)super()或super(实参列表)必须在子类构造器的首行
* (2)如果子类的构造器中,没有写super(),它也存在
* 但是如果子类构造器中写super(实参列表),那么super()就不会存在的
*/
public class TestSuper {
public static void main(String[] args) {
// B b = new B();
// b.printNum(3);
// XueSheng x = new XueSheng("张三", 23, 89);
// System.out.println(x.getInfo());
XueSheng x = new XueSheng();
}
}
class A{
int num = 1;
}
class B extends A{
int num = 2;
public void printNum(int num){
System.out.println(num);//局部变量 (int num)
System.out.println(this.num);//成员变量,子类自己的int num
System.out.println(super.num);
}
}
class Human{
private String name;
private int age;
public Human(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Human() {
super();//调用的是公共父类java.lang.Object类的无参构造
System.out.println("父类的无参构造");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getInfo(){
return "姓名:" + name + ",年龄:" + age;
}
}
class XueSheng extends Human{
private int score;
public XueSheng(String name, int age, int score) {
super(name, age);//调用父类Human的有参构造
this.score = score;
}
public XueSheng() {
// super();//调用父类Human的无参构造
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public String getInfo(){
// return "姓名:" + getName() + ",年龄:" + getAge() + ",成绩:" + score;
return super.getInfo() + ",成绩:" + score;
}
}