学习心得
一、专业课
1、面向对象
(1)this调用本类中的属性，也就是类中的成员变量；
(2)this调用本类中的其他方法；
(3)this调用本类中的其他构造方法，调用时要放在构造方法的首行。2） static
static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。
被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享.只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象
(1)、静态方法
静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法 (就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法
(2)、static代码块
static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次.
3)类内存图分析
publicclassChinese{
Stringname;
intage;
staticStringcountry;
/*
*构造代码块可以有多个每次生成类时都会执行
*可以访问静态方法变量
*/
{
System.out.println("构造代码块2"+country);
}
voidspeak(){
System.out.println(this.name+ "说：");
}
/*
* static不能访问非静态成员属性，方法
*用于初始化静态变量
* static构造代码快可以有多个
* static构造代码块，先于main方法执行，而且不管类有几个，都执行一次
*/
static{
country= "中国";
System.out.println("静态代码块2");
}
{
System.out.println("构造代码块1");
}
static{
System.out.println("静态代码块1");
}
publicstatic void main(String[] args) {
Chinesechinese =new Chinese();
Chinesechinese2 =new Chinese();
/*
*静态属性可以用类名引用，也可以用引用变量引用
*/
System.out.println(Chinese.country);
}
}
执行结果
静态代码块2
静态代码块1
构造代码块2中国
构造代码块1
构造代码块2中国
构造代码块1
中国
3）package
1、提供多层的命名空间，解决命名冲突；（处于不同package中的类可以拥有相同的名字）
2、对类按功能进行分类，使得项目的组织更加清楚
3、结合访问修饰,有安全机制
4）java访问修饰符
（1）public：用public修饰的类、类属变量及方法，包内及包外的任何类（包括子类和普通类）均可以访问；
（2）protected：用protected修饰的类、类属变量及方法，包内的任何类及包外那些继承了该类的子类才能访问（此处稍后解释），protected重点突出继承；
（3）default：如果一个类、类属变量及方法没有用任何修饰符（即没有 public、protected及private中任何一种修饰），则其访问权限为default（默认访问权限）。默认访问权限的类、类属变量及方法，包内的任何类（包括继承了此类的子类）都可以访问它，而对于包外的任何类都不能访问它（包括包外继承了此类的子类）。default重点突出包；
（4）private：用private修饰的类、类属变量及方法，只有本类可以访问，而包内包外的任何类均不能访问它
访问级别 |
访问控制修饰符 |
同类 |
同包不同类（不含子类） |
同包子类 |
不同包不同类 （不含子类） |
不同包子类 |
公开 |
public |
√ |
√ |
√ |
√ |
√ |
受保护 |
protected |
√ |
√ |
√ |
-- |
√（注意） |
默认 |
没有访问控制修饰符 |
√ |
√ |
√ |
-- |
-- |
私有 |
private |
√ |
--- |
--- |
-- |
-- |
5)面向对象的三大特性
1.封装
封装的定义：
首先是抽象，把事物抽象成一个类，其次才是封装，将事物拥有的属性和动作隐藏起来，只保留特定的方法与外界联系
为什么需要封装：
封装符合面向对象设计原则的第一条：单一性原则，一个类把自己该做的事情封装起来，而不是暴露给其他类去处理，当内部的逻辑发生变化时，外部调用不用因此而修改，他们只调用开放的接口，而不用去关心内部的实现
阻止外部的非法操作
二、小组PK
1、我方题目
1.以下程序能否运行
如果不能请指出错在那里,
如果可以请输出程序结果:
//('A'的acsii码是65)
publicclass Test {
publicstatic void main(String[] args) {
char[]ch = new char[]{65,66,67,68,65,65,68,69,65};
for(inti = 0; i < (ch.length/2);i++){
if(ch[i]!= ch[ch.length-1-i])
System.out.print(ch[i++]);
System.out.print(ch[ch.length-1-i]);
}
}
答案
ABDDA
2.请找出下面程序的错误,可能有几处(请在错误语句后面打星*):
publicclass Question {
staticint i,j,k;
Question(inti, int j,int k){
this.i= i;
this.j= j;
this.k= k;
}
voidtest(int i) {
System.out.println(i);
}
staticvoid test(int i){ *//这个test方法与上一个非静态的test冲突
System.out.println(i);
}
{
i++;
}
static{
j++;
}
publicvoid fun(int k){
Questionq1 = new Question(); *//没有不带参的构造参数
k+=(++i)+(j++);
}
publicstatic void main(String[] args) {
Questionq1 = new Question(1,1,1);
System.out.println(q1.i+","+q1.j+","+q1.k);
System.out.println(fun(2)); *//main不能直接调用非静态方法
}
}
3,请找出下面程序的错误,可能有几处(请在错误语句后面打星*):
publicclass TestC {
inta=b=2; *//b没有定义
publicstatic void fun(float f) {
System.out.println(f);
}
publicstatic void main(String[] args) {
inta=1,b=2,c=3,p=4;
System.out.println(Math.sqrt(p*(p-a)(p-b)(p-c))); *//少*号
fun(2.2); *//2.2默认是double型,不能传给float
System.out.println("2");;
}
}
4.以下程序能否运行
如果不能请指出错在那里,
如果可以请输出程序结果:
publicclass TestD {
inti;
staticint a;
staticint b;
publicTestD(int i) {
this.i= i;
System.out.println(i);
}
static{
a= a^b;
}
{
System.out.println(i);
a= a^b;
}
static{
b= a^b;
}
publicstatic void main(String[] args) {
inti = 2;
TestDtestd = new TestD(i++);
TestD.a= 6;
TestD.b= 8;
System.out.println(TestD.a);
System.out.println(TestD.b);
}
}
答案:
0
2
6
8
5.以下程序能否运行
如果不能请指出错在那里,
如果可以请输出程序结果:
publicclass Test {
intn ;
intarr[][];
publicTest(int n) {
this.n+= n++;
this.arr= new int[n][n];
}
{
n++;
}
public void test(int n){
for(inti = 0;i < n;i++){
for(intj = 0;j <= i;j++){
if(j== 0){
arr[i][j]= 1;
System.out.print(arr[i][j]+"");
}elseif(i == j){
arr[i][j]= 1;
System.out.print(arr[i][j]+"");
}else{
System.out.print(arr[i-1][j-1]+arr[i-1][j]+"");
}
}
System.out.println();
}
}
publicstatic void main(String[] args) {
Testy = new Test (4);
y.test(y.n);
}
}
答案:
1
11
12 1
11 1 1
11 0 1 1
2、对方题目
1.程序是否有错误,有则指出错误,没有则写出程序输出结果
privateclass Test { //类名不可用private修饰
Stringname;
staticint i;
static{
i++;
}
{
System.out.println("我的名字是:"+name);
}
publicTest(String name){
this.name= name;
}
publicstatic void main(String[] args) {
newTest("宁年");
}
}
2.程序是否有错误,有则指出错误,没有则写出程序输出结果
publicclass T1 {
publicstatic void main(String[] args) {
PPp1=new PP();
System.out.println(p1.a); //a为private属性不能直接访问
}
}
classPP{
staticprivate int a=10;
static{
a++;
}
publicPP(){
this.a++;
}
}
有错误//a为private属性不能直接访问
3输出程序运行结果
classPer {
Stringname;
intage;
staticdouble gread;
Per(Stringn,int a){
name= n;
age= a;
}
{
print();
}
static{
gread= 88.5;
inta = 11;
System.out.println(a);
}
voidprint(){
System.out.println("name:"+ name + " age:" + age + " gread:" + gread);
}
}
classDemo1 {
publicstatic void main(String[] args) {
Perp = new Per("mary", 11);
p.print();
}
}
11
name:nullage:0 gread:88.5
name:maryage:11 gread:88.5
4:写出程序运行结果
publicclass Demo1 {
floata = 0.0F;
staticint b=1;
static{
b++;
}
{
if(a == 0) {
a+= 1;
}
if(a > 0.00f) {
a+= 2;
}
System.out.println(a);
}
publicstatic void main(String[] args) {
System.out.println(newDemo1().a);
System.out.println(Demo1.b);
}
}
5.写出程序运行结果
publicclass A {
inta=10;
{
System.out.println(a);
a++;
a();
}
publicA(int a){
a();
System.out.println(a);
}
publicvoid a(){
this.a++;
System.out.println(a);
}
publicstatic void main(String[] args) {
Aa=new A(2);
a.a();
}
}
1:编译出错,private修饰类
2:私有属性不能在其他类中访问
3.11
name:null age:0 gread:88.5
name:mary age:11 gread:88.5
4.3.0
3.0
2
5.10
12
13
2
14
学习心得：
1.细节是魔鬼,经常都不看的代码段,可能就隐藏着错误
2.可变参数允许传递空值