1.
创建对象并不可以直接使用,需要借助 new 语句,还有类后面没有分号。一般类放在一个java源文件中;
class Student
{
int result;
}
student a;
此时的a 是个空对象,
a=new Student();
//或 定义和初始化一起做
Student a=new Student();
其实就是系统给变量result分配内存,然后返回引用,赋值给对象a,也就是交给a 控制;
2.
标识符,除了字母,下划线,和数字组成外,还有美元符号,长度不受限,java对字母分大小写(字母包含中文等各种字符,因为用的是Unicode标准字符集)
3.
输入:Scanner类, 创建该类的对象,用该对象调用其函数来进行操作,下面是操作语句:
Scanner reader = new Scanner(system.in);
例:
class People
{
int age;
}
import java.util.Scanner;
public class Example
{
public static void main(String args())
{
People a=new People();
Scanner reader= new Scanner(System.in);
zhang.age=reader.nextInt();
}
}
有以下函数:
nextBoolean()、nextByte()、nextInt()、nextFloat()、nextShort()、nextLong()、nextDouble()
输出:System.out.println 或 System.out.println(),可以输出串值,表达式的值,前者输出且换行,后者则不会换行;
System.out.println(m+"个数的和为"+sum);
//m 和sum 为变量
注意:两个语句都不能出现回车内容,但可以用+把他们串起来
同时java继承了c语言的格式输出;
4.数组
数组声明:
类型 数组名【】;
或
类型【 】数组名;(二维也一样)
(1) java 不允许声明数组的时候给出长度;需要用过new 来分配空间
例:
int a[];
a=new int[12];
声明时候同时初始化:
int a[]=new int[12];
(2)构成二维数组的一维数组不一定要有同样的长度,可以指定多长;
int a[][]=new int[3][];
a[0]=new int [6];
a[1]=new int [7];
a[2]=new int [8];
(3)java允许使用int型变量的值指定数组的元素的个数,例:
int size =10;
int a[]=new int [size];
(4)length的使用
float a[]=new float[7];
int b[][]=new int [3][6];
a.length则会是 7;
b.length则会是3;注意显示一维的
(5)java允许数组引用传递,如果是c++/c是不允许的;
int a[]={4,5};
int b[]={6,7};
a=b;
(6)如果字符数组a,在System.out.println(a)语句中,输出的是整个素组元素
(7)for(接收变量:数组)
int temp;
int a[]={4,5,6,7};
for(temp:a)
System.out.print(temp);
这样就可以循环输出了
(8)使用toString,以字符串输出格式;
import java.util.Arrays
int a[]={4,5,6,7};
System.out.print(Arrays.toString(a));
结果会是:【4,5,6,7】
5.
java 的成员变量声明时可以同时初始化,但其他操作只能是在类的方法中进行
class A
{
int a=5;
char b='o';
int c;
c=7;//非法语句,出错
}
6.创建对象
class People
{
int age;
float height;
double weight;
}
class Example
{
public static void main(String args[])
{
People s;
s=new People();
}
}
需要用 new 动态的分配实体,没有使用new的,将会视为空对象,编译器不对空对象进行检查,所以值得注意;
7.垃圾收集
java不像c++有析构函数,而是有自己的“垃圾收集”机制,这种机制周期性地检查某个实体是否已不再被任何对象拥有(引用),如果发现这样的存在,就释放实体占用的 内存空间;
注:如果希望java虚拟机立刻进行垃圾收集,则可以用System类调用gc()方法;
8.关联关系与依赖关系
关联关系:如果A类中成员变量是用B类声明的对象,那么A和B是关联关系;
依赖关系:如果A类中某个方法的参数是B类对象
或某个方法的返回数据类型是B对象,则是依赖关系;
9.这点跟c++基本一致
使用static 的是类变量,或类方法;反之是实例变量,或实例方法
二者区别:
- 多变量時,实例变量空间单独,静态的是一个类一个内存空间
- 类名直接访问类变量,类变量在在该类被加载到内存的时候就分配内存,而实例变量在没有创建对象的时候是没有分配内存的,类变量的内存空间知道程序退出运行,才释放占有的内存
- 类变量似乎破坏了封装性,当对象调用实例方法時,该方法中出现的类变量也是该对象的变量,只不过这个变量和其他对象共享而已
10.实例方法和类方法的区别
- 类的实例方法不会直接分配入口地址,只有创建对象后才有;且当创建第一个对象时,类中的实例方法分配了入口地址,当再创建对象时,不再分配入口地址,也就是,方法的入口地址被所有的对象共享,当所有对象不存在時,方法的入口地址才被取消。实例方法可以用实例变量和类变量
- 类方法,在类被加载内存时,就分配了了入口地址,所以所有对象可以调用执行,同时可以通过类名直接调用;实例方法只能通过对象调用;类方法不可以操作实例变量;
- 如果一个方法不需要操作实例成员变量就可以实现某种功能,就可以考虑将这样的方法声明为类方法;好处是,避免创建对象浪费空间;
11.this关键字
class B
{
void f()
{
int x;
static int y;
this.g();
B.h();
}
void g(int x,int y)
{
this.x=x;//冲突时,this不省略
B.y=y;//冲突时,类名不省略
System.out.println("ok");
}
static void h(){System.out.println("hello");}
}
this不能出现类方法中,这是因为,类方法可以通过类名直接调用。这时,可能还没有任何的对象产生迹象;
12.包
包可以区分,当在不同的java源文件中,有相同名字的类,相当于地址吧;当没有声明哪个包時,则认为時无名包;
package 包名;
必须将源文件编译的字节码文件放在包名的目录中
例1:
package tom.k;
则该源文件存放目录应该是:
···\tom\k
例2:
将源文件放在C:\1000\tom\k中
然后在目录1000下编译源文件:
C:\1000>java.tom.k.主类名(即包名.主类名)
那么字节码文件会默认保存在C:\1000\tom\k中
13.import解决不同包问题
import java.util.*;
表示引入包中所有的类
例:引入包的Date类
import java.util.Date;
class Example
{
public static void main(String arg[])
{
Date date=new Date();
System.out.printlin(date);
}
}
14.访问权限
java分为四类:public,protected,友好,private
这四种权限,以上权限由大到小
友好:即不写任何权限,就为友好权限;
- 类变量或类方法在某个类中定义为私有的private,那么在另外的类中是不可以直接用类名调用点的;
- 当一个类与另外一个类属于同个包时,后者可以通过对象或者类名直接调用友好变量,友好方法,类友好变量和类友好方法;(这一点个protected一样的)
- 不能用protected 和 private修饰类
15.可变参数
可以解决函数传递参数时反复声明参数的冗余工作;
public class Computer
{
public int getSum(int...x)
{
int sum=0;
for(int i=0;i<x.length;i++)
sum=sum+x[i];
}
/*这里也可以*/
/*
for(int temp:x)
sum=sum+temp;
*/
return sum;
}
public class Example
{
public static void main(String arg[])
{
Computer c =new Computer();
int result=c.getSum(1,2,3,4);
System.out.println("和为:"+result);
}
}
15.继承
子类继承父类后,继承的成员或方法的访问权限不变
例:当父类和子类属于同个包的情况下
class A
{
public int a;
int i;
}
class B extends A
{
int b;
}
class Example
{
void main()
{
B c=new B();
c.a=1;
c.b=4;
c.i=2;
}
当属于不同包的情况下,子类不能继承父类中的private 和友好 这两种类型的变量或者方法;
如上例:在该情况下,c.i 是错误的调用
16.隐藏与重写
- 当父类和子类的成员变量或方法相同名字时,子类会将父类继承过来的隐藏掉,然后用自己的变量或者方法;
- 如果父类方法的类型是“类”,那么允许子类的重写方法的类型是父类返回值类型的“子类”
class People
{
People haha(int a)
{People a=new People()
return a;
}
}
class Student extends People
{
Student haha (int a)//重写
{ Student b=new Student();
return b;
}
}
- 重写时可以修改访问权限修饰符和返回值,但方法名和参数类型及个数都不可以修改;
- 子类继承父类后,重写父类 f()方法,那么子类对象调用 f()则一定是子类重写的方法;
- 重写的方法可以操作继承的成员变量、调用继承的方法,也可以操作新增的成员变量。调用新定义的其他方法,但无法操作被子类隐藏的成员变量和方法。
- 重写的两个注意的点:(1)子类重写父类方法時要保持类型一致;(2)子类重写父类的方法后,该方法的权限必须大于或等于父类方法的权限;
class A
{
protected float f(float x,float y)
{
return x-y;
}
}
class B extends A
{
float f(float x, float y)//非法,降低了访问权限
{return x+y;}
}
class C extends A
{
public f(float x, float y)//合法,提高了访问权限
{return x*y;}
}
16.super关键字
被隐藏的变量或者方法由 super负责,当子类中想使用被隐藏了的成员变量或方法就需要使用关键字super。
class People
{
int x=100;
}
class Student extends People
{
int x=18;
void getAge()
{
super.x=x;
System.out.println("年级是:"+super.x);
}
}
class Example
{
void main()
{
Student a=new Student();
a.getAge();
}
}
17.final关键字
- 如果final 关键字修饰父类中的一个方法,那么这个方法不允许子类重写
- 如果成员变量或局部变量被修饰为final , 就是常量,且必须在声明时,就初始化,否则之后是没法改动的;但可以作为参数;
class A
{
final double IP=3.1415;
public double getArea(final double r)
{
returnn IP*r*r;
}
public final void speak()
{System.out.println("您好");}
}
class Example
{
public static void main(String arg[])
{
A a= new A();
System.out.println("面积"+a.getArea(100);)
}
}
18.对象的上转型对象
这点很想像c++的子类对象引用赋值给父类指针,只能通过指针调用父类的的变量或者方法;
还可以实现多态
- 上转型对象:可以调用从父类继承的变量,或者被子类隐藏的变量,同时可以调用继承过来的方法和子类重写的方法
- 可以将对象的上转型强制转换到一个子类的对象
- 不可以将父类对象赋值给子类对象
class A
{
void get_t()
{
System.out.printlin("hello");
}
}
class B extends A
{
void get_t()
{ System.out.printlin("ok");
}
void second()
{ System.out.printlin("thanks");}
}
class Example
{
void main(String arg[])
{
A a=new B();
a.get_t();//这里输出的结果是:ok 为什么呢?因为这里调用的子类重写的方法,所以显而易见,在重写>隐藏
B b=(B)a;//强制将父类对象转换为子类对象
//这一句奇怪的一点是,不同通过new B()为 b创建对象
}
}
19.abstract关键字
与c++ 的虚函数和纯虚函数相似
abstract int min (int x , int y);
抽象类只许声明不许实现,不允许abstract 和 final 同时出现
- 抽象类可以有抽象的方法和非抽象的方法(与接口区别开来)
- 不能创建抽象类的对象,
- 一个非抽象类继承抽象类,则它必须重写父类的抽象方法,给出实体
- 如果是抽象类继承抽象类,则它可以继承抽象方法,或者重写这个抽闲方法
abstract class A
{
abstract int sum(int x,int y);
int sub(int x,int y)
{
return x-y;
}
}
class B extends A
{
int sum(int x,int y)//重写了父类的抽象方法
{
return x+y
}
}
20.接口
- 接口体中含有常量(没有变量)和抽象方法两部分,所以常量的访问权限一定是public,方法以一定是abstract, java允许接口中可以省略public和abstract修饰
- 用关键字interface声明接口,用implement声明自己实现类,如果要实现多个接口则用逗号隔开;
- 非抽象类实现了了接口,则该类必须重写接口中的所有方法,需要注意的是,我们省略的public 此时必须写出来,不然变成友好型降低了访问权限,而abstract要去掉;
- 接口中的常量可以用接口名直接调用
- 当不希望某些类通过继承拥有一些相同的方法的时候,可以考虑接口
Computable.java
public interface Computable{
int MAX=100;
int f(int x);
China.java
public class China implements Computable{
int nember;
public int f(int x){
int num=0;
for(int i=1;i<=x;i++)
{sum =sum+i;}
return sum;
}
Japan.java
public class Japan implements Computable{
int number;
public int f(int x)
{return 46+x;}
}
main.java
public clas Example{
public static void main(string arg[])
{China zhang;
Japan henlu;
zhang=new China();
henlu=new Japan();
zhang.number=28+Computable.MAX;
henlu.number=14+Computable.Max;
System.out.println("zhang的学号"+zhang.number+"zhang 求和结果"+zhang.f(100));
System.out.println("henlu的学号"+henlu.number+"zhang 求和结果"+henlu.f(100));
}
}
21.接口回调
- 类型为接口的变量叫做:接口变量
- 接口回调:指将实现某一接口的类的对象的引用赋值给接口变量,让接口变量调用该类实现接口的方法叫接口回调,很像前面的上转型
该例也是接口多态的体现
interface ShowMessage
{ void show(string s);
}
class TV implements ShowMessage
{
public void show(string s)
{ System.out.println(s);}
}
class PC implements ShowMessage{
public void show(string s)
{ System.out.println(s);}
}
public class Example{
public static main(String arg[])
{ShowMessage sm;//接口变量
sm=new TV();//接口中放对象的引用
sm.show("我家的电视");//接口回调
sm=new TV();//接口中放对象的引用
sm.show("我家的PC");//接口回调
}
从上面的例子我们可以看出需要反复对 sm 接口变量重新赋值新对象的引用,再多次调用sm.show() 方法,那么接下的内容是解决这些重复的操作;
接口参数
上例:可以改成
interface ShowMessage
{ void show();
}
class TV implements ShowMessage
{
public void show()
{ System.out.println("我家的TV");}
}
class PC implements ShowMessage{
public void show()
{ System.out.println("我家的PC");}
}
class haha{
void totall(ShowMessage sm)
{sm.show()}
}
public class Example{
public static main(String arg[])
{
haha a=new haha();
a.totall(new TV());
a.totall(new PC());
}
某些问题需要继承才能解决,像:子类除了需要重写父类的abstract方法,还需要从父类继承一些变量或一些重要的非abstract方法,就可以考虑用abstract
某个问题不需要继承来解决,只需要若干类给出某些重要的abstract的实现细节,就可以考虑使用接口