1、final修饰成员变量的初始化时机 : 只要是在构造方法弹栈之前进行初始化即可
public static void main(String[] args) {
final int num = 10;
System.out.println(num);
}
}
class Student {
// 1. final修饰成员变量, 不能修饰默认初始化值.
// 默认值属于无效值
final int age;
// 2. final修饰成员变量的初始化时机 : 只要是在构造方法弹栈之前进行初始化即可
public Student(){
age = 19;
}
}
总结:
1. 变量 方法 类
2.
方法 : 不能被重写, 但是子类可以继承下来去使用
类 : 不能被继承, 不能有子类, 但是可以有父类
变量 : 只能被赋值一次, 不能被更改 (自定义常量)
3.
成员变量 :
初始化时机:1. 在定义的时候直接给值(推荐)
2. 在构造方法结束之前完成赋值(不建议)
注意事项:
final修饰成员变量的时候, 不能修饰默认初始化值
默认初始化值是一个无效值.
对于这种不能被更改的变量, 我们也称之为常量(自定义常量)
字面值常量: 整数, 小数, 字符, 字符串, 空
自定义常量: 被final修饰的变量
建议命名规范 : 如果是一个单词, 所有字母大写 PI
如果是多个单词, 所有字母大写, 中间需要以_进行分割 MAX_VALUE
2、static静态关键字，有时用于工具类
总结:
1. 静态指的就是Java中的关键字, static, static是一个修饰符.
问题: static可以修饰什么?
成员:
1. 成员变量
2. 成员方法
2.
1. 被类的所有对象所共享
2. 优先于对象存在, 随着类的加载而加载
3. 多了一种调用方式, 可以根据类名.进行调用
4. 静态的存在于方法区中，并不进入堆内存
package com.heima.mstatic;
public class TestStatic {
public static void main(String[] args) {
// 1. 静态修饰的成员, 优先于对象存在, 随着类的加载而加载
// 2. 多了一种调用方式, 可以通过类名.进行调用
// 3. 被类的所有对象所共享
// Student.school = "aaa";
Student s1 = new Student();
s1.name = "张三";
s1.age = 23;
Student s2 = new Student();
s2.name = "李四";
s2.age = 24;
s1.show();
s2.show();
}
}
class Student {
String name;
int age;
final static String school = "A学院";
public void show() {
System.out.println(name + "," + age + "," + school);
}
}
静态方法：
可以调用静态的成员变量
可以调用静态的成员方法
不可以调用非静态的成员变量
不可以调用非静态的成员方法
只能在静态的方法中调用静态的成员
总结: 静态中只能访问静态.
静态中没有this和super关键字：因为this和super只有在创建对象之后才存在, 静态则是随着类的加载而加载.在使用静态的时候, 有可能对象还没有被创建.
什么时候该用静态修饰成员方法呢?
工具类 : 定义了一个类, 类中存在一些提供服务的方法.
为了让这些方法调用的更加简便, 一般会将方法都定义为静态的.
如果一个类中所有的方法都是静态的, 往往会多做一步操作, 私有构造方法。目地就是为了不让其他类访问构造方法创建对象, 要想使用工具类的方法, 直接类名.即可。
成员变量: 编译看左边(父类), 运行看左边(父类)
成员方法: 编译看左边(父类), 运行看右边(子类)，子类父类共有的方法
静态成员: 编译看左边(父类), 运行看左边(父类)！！！！！！！！
3、主方法main是静态的，所以再主方法中的方法都需要static来进行修饰。_
4、抽象方法，我们将共性的行为抽取到父类中，但是在父类中描述不清，但是这个行为还是子类必不可少的，就用抽象的方法。抽象方法去掉了{}大括号这个方法体
抽象方法必须存活在抽象类或者是接口中；抽象类不能实例化（也就是不能创建对象）
不能实例化 : 不能创建对象
为什么？
答：如果允许创建对象, 就可以调用内部没有方法体的抽象方法了, 这样做没有意义.
那么抽象类如何实例化呢?
可以使用多态的形式, 父类引用指向子类对象
f.eat(); 编译看左边(父类), 运行看右边(子类)
编译看父类 : 检查父类中是否有此方法的[声明].
如果有, 编译通过, 但是运行的时候, 执行子类的方法.
抽象类的子类：要么是抽象的子类，要么子类重写了所有的抽象方法（是所有的）
5、抽象类的成员特点
总结:
1. 成员变量 :
A. 可以是一般变量
B. 也可以是常量
2. 成员方法 ：
可以是一般方法, 也可以是抽象方法
3. 构造方法 ：
有, 目的是为了方便子类进行初始化的.
结论: 抽象类中除了可以定义抽象方法以外, 其余的定义, 和普通的类是一致的.
6、接口：对外暴漏规则的都是接口，接口更加强调的是一种扩展功能，接口是对功能的一种扩展，也是生命规则的一种方式。（规则、扩展）；接口和类之间的关系，可以单实现，也可以多实现。
7、接口不能实例化，可以直接创建实现类来使用，或者使用多态的方法。
8、方法中的所有方法都是抽象的，就算不写abstract也是默认有的，只能定义抽象方法。使用接口的话，必须重写抽象方法。
package com.heima.minterface;
public class TestInterface {
public static void main(String[] args) {
SomkeStudent ss = new SomkeStudent();
ss.eat();
ss.study();
ss.smokeing();
}
}
// 1. 定义一个接口 [抽烟]
// 思想: 扩展, 规则
interface Smoke {
// 特点: 接口中定义的方法, 默认都会带有abstract
// 注意: 接口中只能定义抽象方法
public void smokeing();
}
class Student {
public void study(){
System.out.println("学生学习");
}
public void eat(){
System.out.println("学生吃饭");
}
}
// 2. 让抽烟的学生, 继承学生类, 再去实现抽烟的接口
class SomkeStudent extends Student implements Smoke {
@Override
public void smokeing() {
System.out.println("抽烟的学生有故事");
}
}
9、多态的使用
抽象类多态：
abstract class Animal{}
class Dog extends Animal{}
Animal a = new Dog();
接口多态：(最常用)
interface Inter{}
class InterImp implements Inter{}
Inter i = new InterImp();
10、接口成员特点，接口中没有构造方法，继承了Object类
1.成员变量 ： 只能是常量
因为即使写成了int num = 10; 系统也会默认加上3个关键字，不论写没写都加！
public static final（默认不可更改，可以类.调用方法）
三个关键字没有顺序关系.
2. 成员方法 : 只能是抽象方法
因为即使写成了 void show();系统也会默认加上public abstract
注意: 只能是抽象方法, 只限于jdk7之前, 包括7
jdk8版本开始, 接口中允许定义带有方法体的方法了.用于在接口版本更新的时候，不会让整个项目报错。但是方法必须要加入default关键字进行修饰.
解决 : 接口接口的迭代更新问题, 防止项目出现不必要的错误.
public default void show(){}
JDK7 : 内置了一些接口 -> 抽象方法3个.
JDK8 : 增强某个接口中的功能, 增强一般方法
3. 构造方法 : 没有
继承实现关系:
1. 继承关系, 只支持单继承, 不支持多继承, 但是可以多层继承
2. 实现关系, 可以单实现, 也可以多实现, 并且可以在继承一个类的同时, 实现多个接口
3. 继承关系, 可以单继承, 也可以多继承.
11、抽象类和接口的区别
- 抽象类：
- 成员变量： 可以是变量, 也可以是常量
- 构造方法： 有构造方法, 为了给子类进行初始化的
- 成员方法： 可以是一般方法, 也可以是抽象方法
- 结论： 除了可以定义抽象方法以外, 其余的定义, 跟普通的类没什么区别.
- 接口：
- 成员变量： 只能是常量
- 成员方法： 只能是抽象方法, 但是在jdk8之后, 可以定义带有方法体的方法了
- 构造方法： 没有
12、导包的格式和使用
格式： import 包名.类名; // import java.util.Scanner;
// import java.util.*; --> 导入util包下所有的类(不建议)
问题： 自己定义的类可以和Java写好的类，重名吗？---可以, 但是不建议, 使用起来比较麻烦
public class Scanner {
/*
* 原因: 自己写的类和Java写好的Scanner重名了
* 使用的时候, 优先使用我们自己写的类.
*/
public static void main(String[] args) {
// 使用全类名创建对象，这样使用的就是java的类，而不是我们自己创建的了
java.util.Scanner sc = new java.util.Scanner(System.in);
}
}
13、四种权限修饰符的概述和访问特点
本类 同一个包下(子类和无关类) 不同包下的(子类) 不同包下(无关类)
private Y
默认 Y Y
protected Y Y Y
public Y Y Y Y
在不同包下的子父类环境当中，才可以进行使用
demo1包：
class Person{
protected void show(){
}
}
demo2包：
class Student extends Person {
// 只能在这里进行访问，出了Student类就无法访问
}
demo3包：
class Test{
main(){
Student s = new Student();
s.show(); // 不能访问，因为当前的条件属于不同包下的无关类
}
}
14、总结
1. final
问题: final可以用来修饰什么?
变量, 方法, 类
变量 : 被其修饰的变量只能被赋值一次, 不能被更改 -> 自定义常量
方法: 被其修饰的方法不能被重写, 但是子类可以继承到进行使用.
类: 被其修饰的不能有子类, 但是可以有父类
问题: final修饰成员变量的初始化时机为?
1. 在创建的时候直接赋值(推荐)
class Person{
final int num = 10;
// final修饰成员变量,不能修饰默认初始化值, 默认值是一个无效值
}
2. 在构造方法弹栈之前完成初始化(不推荐)
class Person{
final int num;
public Person(){
num = 10;
}
}
2. static
问题: static可以修饰什么?
成员:
成员变量
成员方法
问题: 被static修饰的成员有哪三个特点?
1. 被类的所有对象所共享
2. 优先于对象存在, 随着类的加载而加载
3. 多了一种调用方式, 可以通过类名.进行调用
问题: 什么时候使用static修饰成员变量, 什么时候使用static修饰成员方法呢?
成员变量 : 共性的[属性]使用静态, 特性的属性使用非静态
成员方法 : 如果希望自己方法被调用者调用的更加方便, 就可以使用static修饰.
工具类: 内部的方法都是给其他类提供服务的
如果一个类中所有的方法都是static的, 往往会多做一个操作, 私有构造方法
目的: 为了不能让其他类创建本类对象
问题: static的访问特点?
静态中, 只能访问静态成员
非静态中, 可以访问静态的, 也可以访问非静态的.
注意: 静态中没有this和super关键字.
3. 抽象类
问题: 抽象类是什么?
把像的部分和相似的部分抽取到一个父类当中 (共性内容向上抽取)
大白话: 抽象类就是一个特殊的父类
这个特殊的父类和普通的父类有什么区别呢?
区别在于, 抽象类中可以定义抽象方法
问题: 抽象方法又是怎样来的?
当我们将事物的共性行为[方法], 向上抽取, 抽取到父类之后, 发现该行为描述不清了, 但还是子类必须要做的事情(强制重写)
这就是抽象方法.
问题: 怎样定义抽象类和抽象方法呢?
使用关键字abstract关键字
方法:
去掉方法体的大括号, 然后分号结束, 并在返回值类型前面加入abstract关键字
public abstract void method();
类:
在class的前面加入abstract关键字
abstract class Animal{}
问题: 抽象类的成员特点是什么?
抽象类中除了可以定义抽象方法以外, 其余的定义和普通的类一致.
问题: 抽象类是否可以实例化?
抽象类不能实例化(不能创建对象), 如果允许创建对象, 就可以使用内部没有方法体的抽象方法了, 这样做没有意义.
问题: 非要实例化怎么办?
可以使用多态的写法
Animal a = new Dog();
问题: 抽象类的子类有哪些选择?
1. 要么重写所有的抽象方法
2. 要么将自己本身也变成抽象类(不推荐)
注意: abstract关键字不能和哪些关键字共存?
final: 因为被 abstract关键字修饰的方法, 要求子类必须重写, 而被final修饰的方法, 子类不能重写, 二者冲突
private: 因为被 abstract关键字修饰的方法, 要求子类必须重写, 而被private修饰的方法, 子类不能重写, 二者冲突
static: 如果云溪static修饰, 就可以类名.调用没有方法体的抽象方法了, 这样做没有意义
4. 接口
问题: 什么是接口?
[规则][扩展]
广义上来说对外暴露规则的都是接口, 狭义的角度来看, 接口指的就是Java中的关键字 interface.
问题: 如何定义接口, 接口和类的关系又是什么?
定义接口:
interface 接口名{}
使用接口:
class 实现类类名 implements 接口名{
}
问题: 接口中的成员特点?
成员变量: 只能是常量, 因为默认会加入三个关键字 public static final
三者没有顺序关系
成员方法: 只能是抽象方法, 因为默认会加入2个关键字 public abstarct
但是, 只能是抽象方法的结论, 只在jdk7和7之前有效
jdk8版本之后, 接口内部可以定义带有方法体的抽象方法
但是该方法需要加入default关键字进行修饰
构造方法: 没有
问题: 接口是否能被实例化?
不能被实例化
非要实例化??
可以使用多态的形式创建对象
Inter i = new InterImpl();
问题: 类与类, 类与接口, 接口与接口之间的关系?
类与类: 继承关系, 只支持单继承, 不支持多继承, 但是可以多层继承
类与接口: 实现关系, 可以单实现, 也可以多实现, 甚至可以在继承一个类的同时, 去时间多个接口
接口与接口: 继承关系, 可以单继承, 也可以多继承.
问题: 接口和抽象类的思想区别?
抽象类中定义的都是继承体系中, [共性]的功能
接口中定义的都是体系中[扩展]的功能
5. 包
问题: package import class有没有顺序关系?
pakcage import class
问题: 如果自己的类名和Java一样了, 还想使用java的类, 该如何创建对象?
使用全类名创建对象
java.util.Scaner sc = new java.util.Scanner(System.in);
6. 权限修饰符
private 本类
默认 本类 同一个包下
protected 本类 同一个包下 不同包下的子类
public 本类 同一个包下 不同包下的子类 不同包下的无关类
Hbase：是一个nosql的列式存储数据库。hbase的数据存储的最终位置在hdfs上。实时读写数据。
PB级别的，列式存储，主节点
Java中的String类提供了支持正则表达式操作的方法；正则表达式是记录文本文件规则的代码。
解释和编译：Java的源代码在执行之前，必须经过编译。JavaScript是一种解释性编程语言，其源代码不需经过编译，由浏览器解释执行。（目前的浏览器几乎都使用了JIT（即时编译）技术来提升JavaScript的运行效率）
强类型变量和类型弱变量：Java采用强类型变量检查，即所有变量在编译之前必须作声明；JavaScript中变量是弱类型的，甚至在使用变量前可以不作声明，JavaScript的解释器在运行时检查推断其数据类型。
扫一扫
41
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
