JAVA笔记（划重点）
JAVA语言面向对象的三大特征
- 封装
- 继承
- 多态
public类
1.如果一个Java源文件中定义了多个类, 则至多有一个类是public类型的
2.如果有一个类是public类型的，则该类名要与文件名保持一致。
3.一个单独的变量不能作为一条语句。
修饰符权限
| 类修饰符 | private | protected | public |
|---|---|---|---|
| 本类 | 可见 | 可见 | 可见 |
| 同包其他类或子类 | 不可见 | 可见 | 可见 |
| 其他包的其它类或子类 | 不可见 | 不可见 | 可见 |
注意：若是未加修饰符修饰符，则默认为它的权限是友好型权限，即和protected的权限等同。
标识符
- 采用Unicode字符集：英文字母、汉字、日文……
- 由字母、数字、下划线或$符号组成
- 以字母、下划线或$符开头
- 区分大小写
- 不能使用关键字
对象的引用
语法:类名 对象引用名称
引用只是存放一个对象的内存地址，并非存放一个对象。
譬如：Book book;
其中book只是Book对象的一个引用
对象的比较("==“和"equals()”)
public class a41 {
public static void main(String[] args) {
// TODO Auto-generated method stub
String s1=new String("abc");
String s2=new String("abc");
String s3=s1;
System.out.println("s2==s3的运算结果为:"+(s2==s1)); //s2==s3的运算结果为: false
System.out.println("s2.eauals(s1)的运算结果为:"+(s2.equals(s1))); //s2.eauals(s1)的运算结果为: true
System.out.println("s1==s3的运算结果为:"+(s1==s3)); //s1==s3的运算结果为: true
}
}
说明:
equals()方法是String类中的方法，它用于比较两个对象所指的内容是否相等;
"=="运算符比较的是两个对象引用的地址是否相等。
对象的销毁(两种情况)
- 对象引用超过其作用范围，这个对象被视为垃圾。
- 将对象赋值为null。
注意:垃圾回收器只能回收那些由new操作符创建的对象。
构造方法
- 构造方法名字必须同类名一样，且构造方法没有返回值类型
- 如果类中没有定义构造方法，那么JDK会自动添加一个不带参数的构造方法，这个方法被称为默认的构造方法。如果类中定义了构造方法，那么JDK就不再添加默认的构造方法。
- 构造方法可以重载。
- 构造方法在创建对象时调用
- 构造方法一般用来初始化
class People{
public People() {
//1
}
public People(int x,int y) {
//2
}
public void People() {
//3
}
}
譬如，这个部分代码中1和2是构造方法，但是3不是，因为构造方法没有返回类型。而且，1和2也说明了构造方法可以重载！！
类的主方法
public static void main(String[] args){ }
- 主方法是静态的，若要直接在主方法中调用其他方法，则该方法必须也是静态的
- 主方法无返回值
- 主方法的形参为数组。其中args[0]~args[n]分别代表程序的第一个参数到第n个参数，可以使用args.length 获取参数个数
类的重用与继承
注：如果一个类没用使用”extends“关键字继承其他类，则默认是"Object"类的子类。
继承原则
- 只支持单继承，不支持多继承,即一个类只能有一个父类，不可以有多个父类。但是多层继承被支持：即c类继承b类，b类继承a类，此时c类可以称作为a类的子类。
例如：
class a{}
class b extends a{}
class c extends b{}- 如果子类和父类在同一个包中，子类可以继承父类中不是private的成员，并且继承成员的访问权限不变。
- 如果子类和父类不在同一个包中，子类只能继承父类中protected和public类型的成员，并且继承成员的访问权限不变。
- 如果子类中定义了和父类同名的成员变量，子类就隐藏了继承的成员变量。
继承样例
package java精通之路; //在同一个包中
class Father{
private int money;
int weight;
protected void setweight(int w){
weight=w;
}
}
class Son extends Father{
String hand;
public void setHand(String hand) {
this.hand=hand;
}
}
class Grandson extends Son{
String foot;
public void setFoot(String foot) {
this.foot=foot;
}
}
public class a43 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Son son=new Son();
Grandson grandson=new Grandson();
son.money="sd"; //（False）子类不能继承父类中的private权限修饰的变量
son.setHand("一双大手"); //(True)
son.setweight(67); //(True)继承了父类Father中的protected权限方法
grandson.setHand("一双小手"); //(True)继承了父类Son中友好型权限方法
grandson.setweight(25); //(True)继承了父类Son中的protecded权限方法,该方法是Son类继承它的父类Father的。
}
}
继承静态成员样例
package java精通之路;
class A
{ int f(int x,int y)
{ return x+y;
}
int x;
public void g()
{ System.out.println("I am a student");
}
}
class B extends A
{
int f(int x,int y)
{
return x*y;
}
double x;
}
public class a45
{
public static void main(String args[]){
B b=new B();
int result=b.f(3,5);
System.out.println(result); //输出15 (子类中的方法覆盖了父类中的该方法)
b.g(); //输出 I am a student
}
}
开闭原则与多态
抽象类与抽象方法
用关键字abstract修饰的类称为abstract类。用关键字abstract修饰的成员方法称为abstract方法。抽象方法只有声明，没有实现。
抽象方法只能存在抽象类和接口中，且抽象类不能使用new关键字创建对象，也不允许使用final和abstract同时修饰一个方法。
如果某个非抽象类继承了抽象类，则必须重写父类的所有抽象方法（去掉abstract关键字），并给出方法体。
在程序设计时，抽象类用于定义类的共同功能，非抽象类则关注动作的具体实现
package java精通之路;
abstract class 机动车{
abstract void 启动();
abstract void 加速();
abstract void 刹车();
}
class 手动挡轿车 extends 机动车{
void 启动() {
{ System.out.println("踏下离合器,换到一挡");
System.out.println("然后慢慢抬起离合器");
}
}
void 加速()
{ System.out.println("踩油门");
}
void 刹车()
{ System.out.println("踏下离合器,踏下刹车板");
System.out.println("然后将挡位换到一挡");
}
}
class 自动挡轿车 extends 机动车
{ void 启动()
{ System.out.println("使用前进挡");
System.out.println("然后轻踩油门");
}
void 加速()
{ System.out.println("踩油门");
}
void 刹车()
{ System.out.println("踏下刹车板");
}
}
public class a48 {
public static void main(String args[])
{ 手动挡轿车 car1=new 手动挡轿车();
自动挡轿车 car2=new 自动挡轿车();
car1.启动(); //踏下离合器,换到一挡 然后慢慢抬起离合器
car1.加速(); //踩油门
car1.刹车(); //踏下离合器,踏下刹车板 然后将挡位换到一挡
car2.启动(); //使用前进挡 然后轻踩油门
car2.加速(); //踩油门
car2.刹车(); //踏下刹车板
}
}
对象的上转型对象
当用子类创建一个对象，并将这个对象（的引用）赋值给一个父类对象的引用时，称这个父类对象的引用是子类对象的上转型对象(引用)。
B extends A … A a=new B();该例子中即a是子类B的上转型对象
上转型对象不能操作子类新增(自有)的成员，但可以操作父类中被子类继承下来的成员，可以操作被子类隐藏的成员变量，也可以使用子类重写后的方法。
可以将对象的上转型对象再强制转换为一个子类对象，这时，该子类对象又具备了子类所有的属性和功能。
package java精通之路;
class LEi{
double m=12.58;
void crySpeak(String s) {
System.out.println(s);
}
}
class people extends LEi{
char m='A'; //隐藏
int n;
void computer(int a,int b) {
int c=a+b;
System.out.println(a+"加"+b+"等于"+c);
}
void crySpeak(String s) {
System.out.println(m+"**"+s+"**"+m);
}
}
public class a49 {
public static void main(String[] args) {
// TODO Auto-generated method stub
people wang=new people();
LEi monkey=wang;
monkey.crySpeak("I love this game"); //输出 A**I love this game**A
// monkey.n=100; 变量n和方法computer都是子类新增（自右）的成员
// monkey.computer(12,19); 不能被上转型对象操纵
System.out.println(monkey.m); //输出 12.58
wang.m='T';
System.out.println(wang.m); //输出 T
wang.computer(55,33); //输出 55加33等于88
wang .m='T';
System.out.println(wang.m); //输出 T
}
}
多态
定义：如果一个类有很多子类，并且这些子类都重写了父类的某个方法，那么当子类对象的上转型对象在调用这个方法时就可能具有多种形态，称为多态。
package java精通之路;
class dongwu{
void cry() {
}
}
class gou extends dongwu{
void cry() {
System.out.println("狗叫声：汪汪汪");
}
}
class mao extends dongwu{
void cry() {
System.out.println("猫叫声：喵喵喵");
}
}
public class a50 {
public static void main(String[] args) {
// TODO Auto-generated method stub
dongwu dw=new gou(); // dw是gou的上转型对象
dw.cry(); //输出 狗叫声：汪汪汪
dw=new mao(); //dw是mao的上转型对象
dw.cry(); //输出 猫叫声：喵喵喵
}
}
静态方法的注意点
- 静态方法中不可以用this关键字
- 静态方法中不可以直接调用非静态方法
- java方法体内的局部变量不能声明为static的
扫一扫
476
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
