block 块 { }
-
{ } 定义在方法中–>局部代码块或者普通语句块 执行时机: 方法调用时
-
{ } 定义在类中方法外–>构造块 执行时机: 创建对象的时候
-
static{ } 定义在类中方法外–>静态块 **执行时机:**类第一次加载时
-
{ }就是一个作用域
-
构造块中代码先于构造器代码执行,如果有多个构造块,从上到下依次执行
-
static只执行一次,在类第一次加载后执行,如果存在多个静态块,从上到下依次执行
执行顺序: static->main方法–>构造块–>构造器
=======================================================================================
导包
-
导包需要关键字 import 标识当前所使用的这个类的位置
- 模糊匹配(会将该包下所有用到的类引入进来),
会降低编译速度,但是不会影响运行速度
- 模糊匹配(会将该包下所有用到的类引入进来),
import java.util.Scanner;//导包
import java.util.*;//模糊匹配(会将该包下所有用到的类引入进来),
会降低编译速度,但是不会影响运行速度
不需要使用 import 的类有
1、 语言包 (java.lang)下的类
2、 同包下的类
JDK 中常用的包简单介绍:
①java.lang –语言包:语言中常用的功能,如 String、Math、
System、Integer、Thread… ②java.util – 工具包:提供一些实用的工具类,如 容器(List、
Set、Map…),日期类
③java.io – 输入输出包:提供操作读取文件的相关类,如 File、
InputStream、OutputStrem… ④ java.net – 网络包 : 操 作 远 程 资 源 的 类 , 如
InetSocketAddress、 DatagramPacket 、ServerSocket… ⑤java.sql – 数据库包:操作 JDBC 的类,Connection、Statement、
ResultSet….
=======================================================================================
封装javaBean
public class Person01 {
public String name;
private//int age; //只能在当前类Person01类中使用
public Person01() {
// TODO Auto-generated constructor stub
}
public Person01(String name, int age) {
this.name = name;
this.age = age;
}
//设置器 setter
//返回值:不需要 参数:要 int
//成员方法
public void setAge(int age){
if(age>=0 && age<=150){
this.age=age;
}else{
System.out.println("年龄不合法...");
}
}
//获取器
public int getAge(){
return this.age;
}
}
public static void main(String[] args) {
Person01 p = new Person01("小花,17);
p.name="小明";
//p.age=-5;
p.setAge(18);年龄是私有的,需要调用公共的方法来实现
System.out.println(p.getAge();
}
- 封装(Encapsulation)是面向对象方法的重要原则,就是把对象的属性和行为(或方法)结合为一个独立的整体,并尽可能隐藏对象的内部实现细节。
- 这里介绍一个关键字 private 私有的
关键字private的特性:
1.private 修饰的内容,只能在当前类或者本类中使用
- 需要为私有的字段提供一对公共的访问方式 设置setter 获取器 getter
- 私有的属性需要配合公共的访问方式–>方法
私有的属性并且提供公共的访问方式是面向对象中封装特性的体现,
私有是封装,不能说封装是私有,因为封装不仅仅表示为私有
=======================================================================================
封装
隐藏内部的实现细节,并对外提供公共的访问方式
封装的优点:
- 隐藏实现细节,提供公共的访问方式
- 提高代码的复用性
- 提高代码的安全性
模板类|javaBean|bean...规范
1. 修饰类的public
2. 至少提供一个空构造
3. 属性私有化
4. 对外提供公共的访问方式
=======================================================================================
继承extends
-
继承的目的: 为了简化代码
-
继承的特点:
1.子类一旦继承父类,就可以使用父类的内容 2.单继承继承:一个子类只能继承一个父类,一个父类可以被多个子类继承,多实现
子类|派生类: 继承别的类
父类|基类|超类: 被继承的类
类就是对对象的抽象
父类就是子类的抽象
单继承的优缺点:
优点:简单
缺点:不便于后期维护
- 子类是父类的延续+ 扩展 extends
- 子类可以使用父类中的内容,可以定义子类独有的内容
public static void main(String[] args) {
Teacher th=new Teacher();
th.subject="数学";
th.teach();
th.name="吕进;
th.age=17;
Student s=new Student();
s.hometown="日本;
s.study();
s.name="小兰";
s.age=50;
s.sleep();
}
}
//父类
class Person{
String name;
int age;
public void sleep(){
System.out.println("休息");
}
}
//子类 教师类
class Teacher extends Person{
String subject;
public Teacher() {
// TODO Auto-generated constructor stub
}
public void teach(){
System.out.println("每天上课都讲数学");
}
}
//学生类
class Student extends Person{
String hometown;
public Student() {
// TODO Auto-generated constructor stub
}
public void study(){
System.out.println("学习数学,做数学题,学习使我快乐");
}
/*
使用继承的格式:
子类 extends 父类
上面的代码中,子类是 Student 和Teacher 只需要在子类的类名后加上extends 父类的类名即可完成类的继承
*/
权限修饰符:
权限修饰符的作用: 定义对象中内容的可访问范围
可以用一个表格来表示谢谢权限修饰符的范围
修饰符名称 | 本类 | 同包类 | 不同包的子类 | 不同包的其他类 |
---|---|---|---|---|
public | Y | Y | Y | Y |
protected | Y | Y | Y | |
default(默认的) | Y | Y | ||
private | Y |
特点:
- 都是成员修饰符,不能修饰局部;
- default关键字默认的,省略不写;
- 能够修饰类的只能为public | default;
能够使用被protected修饰的内容的方式:
- 不同包下的
- 不同包下的子类中才能够使用,并且必须通过子父类继承的关系使用才可以
=======================================================================================
Override 重写
* 重写和重载之间区间:
* 无论是重写还是重载都是只的方法而言
*
* 方法的重载:
* 同一个类中的多个方法
* 方法名相同
* 参数列表不同
*
* 方法的重写:
* 1.不同的类
* 2.继承|实现
* 3.方法签名相同
*
* 如果子父类中构成方法的重写,子类对象调用时候会调用子类中重写的那个方法,对父类的方法进行屏蔽
*
* 检测方法重写的方式:
* 1.左侧会出现向上的三角形
* 2.@Override 注解强制检查重写方法
*
* == 方法签名完全相同
* <= 返回值类型: 返回值类型为基本数据类型要求必须相同, 如果引用数据类型,子类<=父类
* >= 子类权限修饰符>=父类权限修饰符
*
* 注意:
* 被private修饰的方法不能被重写
* 被final关键字修饰的方法不能被重写
* 被static修饰的方法不能被重写
* 但是注意:如果子类中有与父类中的某个静态方法同名的时候,那这个方法也要为static修饰的
public class Override {
public static void main(String[] args) {
JianLin j=new JianLin();
j.name="王健林";
j.works();
SiCong Si =new SiCong();
Si.name="王思聪";
Si.works();
}
}
class JianLin{
public String name;
public void works(){
System.out.println(name+"说:先定一个小目标,挣它一个亿!!!");
}
}
class SiCong extends JianLin{
public void works(){
//super.works();
System.out.println(name+"说:我不在乎我的朋友们有没有钱,反正都没有我有钱!!!");
}
}
/*
以上代码中,SiCong继承了JianLin类,他就拥有了JianLin类中的works()方法,但是,SiCong里方法我不满意,那么可以重写.重写的条件是:
1.是不同的类之间,
2.类与类之间必须要有继承关系
3.方法签名相同
如果子父类中构成方法的重写,子类对象调用时候会调用子类中重写的那个方法,对父类的方法进行屏蔽
以上代码运行的结果为:
王健林说:先定一个小目标,挣它一个亿!!!
王思聪说:我不在乎我的朋友们有没有钱,反正都没有我有钱!!!(输出的是重写后的方法)
*/
super关键字
super:指代父类对象
* 1.调用父类的构造器
* super()
* 如果没有显示定义,调用父类的哪一个构造器,默认首行调用super()父类空构造
***因为一般子类构造器的首行会默认调用父类空构造的问题,所以建议模板类都至少存在一个空构造
* super()必须在首行调用使用才行
*
* 2.区分子父类同名问题
* 如果当子父类中存在同名成员的时候,子类中使用同名内容默认就近原则指代父类,如果先要使用父类的通 过super使用
* super指代父类对象
* 如果不存在同名问题,调用父类中的成员,super.可以省略
*
* 先父类后子类
* 先静态后成员
创建子类对象之前,要先创建父类对象-->先子类后父类(父类对象在子类对象内存空间中的,外部无法直接操作,只能 在子类中通过super使用这个内部的父类对象)
初始顺序:先静态后成员
*
* final 关键字
* 被final修饰的变量为常量
* 被final修饰的方法不能被重写
* 被final修饰的类不能被继承 (太监类)
// 测试 Super 默认调用父类构造器
public class SuperTest {
public static void main(String[] args) {
//创建子类对象
//默认先创建父类,然后在创建子类
Son s=new Son();
}
}
class Father{
public Father() {
System.out.println("我是父类空构造");
}
}
class Son extends Father{
public Son() {
super();//可以省略,如果不写,默认调用父类的构造器
System.out.println("我是子类空构造");
}
}
/*
以上代码输出结果为:
我是父类空构造
我是子类空构造
因为如果没有显示定义,调用父类的哪一个构造器,默认首行调用super()父类空构造,
*/
//依然还是用 王建林 和王思聪来举例
public class Override {
public static void main(String[] args) {
JianLin j=new JianLin();
j.name="王健林";
j.works();
SiCong Si =new SiCong();
Si.name="王思聪";
Si.works();
}
}
class JianLin{
public String name;
public void works(){
System.out.println(name+"说:先定一个小目标,挣它一个亿!!!");
}
}
class SiCong extends JianLin{
public void works(){
super.works();
System.out.println(name+"说:我不在乎我的朋友们有没有钱,反正都没有我有钱!!!");
}
}
/*
以上代码输出结果为:
王健林说:先定一个小目标,挣它一个亿!!!
王思聪说:先定一个小目标,挣它一个亿!!!
王思聪说:我不在乎我的朋友们有没有钱,反正都没有我有钱!!!
因为子父类中构成方法的重写,子类对象调用时候会调用子类中重写的那个方法,对父类的方法进行屏蔽,但是如果想要在子类中,调用父类中的方法,那么只需要super. 就可以了.如上面的代码中子类SiCong中的用super.works()来调用父类中的方法.
*/