0. 带包编译
使用记事本 编写一个带包的HelloWorld
package com.doit.test;
class HelloWorld{
public static void main(String[]args){
System.out.println("hello world");
}
}
使用命令行如何执行:
package com.doit.test;
手动式:
-
使用javac命令编译 javac 文件名.java javac HelloWorld.java
-
在类所在的文件夹下,按照包的格式把对应的文件夹创建出来,把.class文件拷贝到文件夹中
使用java 包名.类名 运行
自动式:
- javac(空格) -d (空格).(空格) 文件名.java
- java 包名.类名
导包: import 全类名;
顺序: package import class
1.权限修饰符
public: 修饰类, 修饰变量和方法
protected: 修饰变量和方法
(default)/package: 修饰类,变量,方法
private: 修饰方法和变量
protected: 修饰方法和变量
可以在不同包的子类中访问, 可以使用super关键字,创建子类的对象访问(创建父类的对象无法访问)
修饰外部类的修饰符:
public (default) final abstract
2.内部类
定义: 定义在类内部的类
2.1 成员内部类
1. 无限制的访问外部类中的成员,包括静态成员和私有成员
2. 成员内部类中不能定义静态成员
3. 如何创建内部类的对象:
外部类名.内部类名 对象名 = new 外部类名().new 内部类名();
4. 如何在内部类中访问外部类中同名的成员
外部类名.this.成员
/**
* 外部类: public final abstract (default)
* 内部类: 定义在类里面的类
* 成员内部类
* 局部内部类
* 静态内部类
* 匿名内部类***
*
*/
public class InnerClassDemo {
public static void main(String[] args) {
OuterClass.InnerClass inner = new OuterClass().new InnerClass();
inner.show();
}
}
class OuterClass{
private int a = 10;
static String name = "张三";
int b = 300;
/**
* 成员内部类: 没有static修饰,定义在成员变量的位置
* 1. 成员内部类可以无限制的访问外部类中的成员,包括静态成员和私有成员
* 2. 成员内部类中,不能定义静态的成员.
* 3. 如何创建内部类的对象:
* 外部类名.内部类名 对象名 = new 外部类().new 内部类名();
* 4. 如何在内部类中调用外部类中同名的成员:
* 外部类名.this.成员
*/
class InnerClass{
int b = 200;
public void show() {
int b = 100;
System.out.println(a);
System.out.println(name);
System.out.println(b);//100
System.out.println(this.b);//200
System.out.println(OuterClass.this.b);//300
}
}
}
2.2 局部内部类
局部内部类: 定义在方法中或者是代码块中的类
1. 局部内部类只能在方法中被认识
2. 局部内部类不能使用public private protected 修饰符修饰
3.在jdk1.7之前,局部内部类中访问的变量必须用final修饰,1.7之后可以不加
public class InnerClassDemo {
public static void main(String[] args) {
OuterClass.InnerClass inner = new OuterClass().new InnerClass();
inner.show();
new OuterClass().method();
}
}
class OuterClass{
public void method() {
/**
* 局部内部类
* 1. 局部内部类还能在方法中被认识
* 2. 局部内部类不能使用public, private, protected 权限修饰符修饰
* 局部变量是否可以使用public,private,protected修饰? 不能
* 3. 在jdk1.7之前,局部内部类中访问的变量必须用final修饰,1.7之后可以不加
*/
class InnerClass2{
public void test() {
System.out.println("test");
}
}
new InnerClass2().test();
}
}
2.3 静态内部类
静态内部类: 用static修饰的内部类
1. 静态内部类中即可以定义静态成员,也可以定义非静态的成员
2. 有静态成员(变量和方法)的内部类,一定是静态内部类
3. 如何访问静态内部类中的成员
静态成员: 外部类名.内部类名.静态成员
非静态的成员: new 外部类名.内部类名().非静态成员
public class InnerClassDemo2 {
public static void main(String[] args) {
System.out.println(OuterClass2.StaticInnerClass.age);
System.out.println(new OuterClass2.StaticInnerClass().name);
}
}
class OuterClass2{
/**
* 静态内部类: 使用static修饰的内部类
* 1. 静态内部类中既可以定义静态的成员,也可以定义非静态的成员
* 2. 有静态成员的内部类一定是静态内部类
* 3. 如何调用静态内部类中的成员:
* 静态成员: 外部类名.内部类名.静态成员
* 非静态成员: new 外部类名.内部类名().非静态成员
*/
static class StaticInnerClass{
String name = "张三";
static int age = 20;
}
}
2.4 匿名内部类***
匿名对象: new 类名().成员;
匿名内部类:
本质: 实现接口或者继承了(抽象)类的子类 对象
格式:
new 接口/类(){
重写或实现的方法
}
要求: 见到接口或者类就能写出匿名内部类
/**
* 匿名对象: new Teacher().teach();
* 匿名内部类:
* 本质: 是一个实现了接口/继承了类 的 子类的 对象
* 格式:
* new 接口/类(){
* //实现父类中的方法
* }
* 定义一个接口, 抽象类,普通类
* 分别写出匿名内部类,并调用里面的方法
*/
public class NoNameInnerClassDemo {
public static void main(String[] args) {
InterA a = new A();// 非匿名内部类的方式; 实现了InterA 接口 的子类的对象
a.eat();
//使用匿名内部类
InterA b = new InterA() {
@Override
public void eat() {
System.out.println("dddd");
}
};
b.eat();
Fly f = new Fly() {//使用变量接收匿名内部类
@Override
public void fly() {
System.out.println(" i can fly, i am singing in the sky");
}
};
f.fly();
new Climb() {//使用匿名内部类直接调用方法
public void climb() {
System.out.println("没有比人更高的山");
}
}.climb();
}
}
abstract class Fly{
abstract public void fly();
}
class Climb{
public void climb() {
System.out.println("爬");
}
}
interface InterA{
public void eat();
}
class A implements InterA{
@Override
public void eat() {
System.out.println("食之无味,弃之可惜");
}
}
练习:
class {
public static void main(String[] args) {
//如何调用PersonDemo中的method方法呢?
}
}
abstract class Person {
public abstract void show();
}
class PersonDemo {
public void method(Person p) {
p.show();
}
}
3.面向对象总结及练习
- 建立一个名称为StaticDemo的类，并声明一个静态变量和一个普通变量。
对变量分别赋予10和5的初始值。在main()方法中输出变量值。
public class StaticDemo {
int a = 10;//成员变量
static int b = 5;
public static void main(String[] args) {
System.out.println(b);
System.out.println(StaticDemo.b);
System.out.println(new StaticDemo().a);
}
}
- 下要求编写Java程序：
（1）编写一个接口：OneToN，只含有一个方法int dispose(int n)。
（2）编写一个非抽象类Sum来实现接口OneToN，实现int dispose (int n)接口方法时，要求计算1 + 2 + … + n。
（3）编写另一个非抽象类Pro来实现接口OneToN，实现int dispose (int n)接口方法时，要求计算1 * 2 * … * n。
在测试类中, 使用多态,创建对象,调用方法
public class Test2 {
public static void main(String[] args) {
OneToN sum = new Sum();
int a = sum.dispose(100);
System.out.println(a);
OneToN pro = new Pro();
System.out.println(pro.dispose(20));
}
}
interface OneToN{
int dispose(int n);
}
class Sum implements OneToN{
@Override
public int dispose(int n) {
int sum = 0;
for(int i=1;i<=n;i++) {
sum += i;
}
return sum;
}
}
class Pro implements OneToN{
@Override
public int dispose(int n) {
int pro = 1;
for(int i=1;i<=n;i++) {
pro *= i;
}
return pro;
}
}
- 递归
4. JunitTest使用
单元 测试: 不需要启动main方法,就可以执行我们的程序
要想使用JunitTest, 我们需要引入第三方的工具类
方式2: 使用eclispe中集成好的junit工具:
右键-> new -> others-> 搜索 junit
5. Debug用法
/**
* debug: 代码执行的追踪工具
* 1. 打断点: 从什么位置开始追踪代码, 断点一般放到方法体中
* 2. 使用debug模式启动 程序:
* 右键-> debug as-> java application
* 提示,是否切换到debug视图,选择是
* 3.
* 下一步: F6
* 进入方法: F5
* 跳出方法: f7
* 进入下一个断点: F8
*/
public class DebugDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
a+=40;
b+=30;
int sum = sum(a,b);
System.out.println(sum);
}
public static int sum(int a,int b) {
for(int i=0;i<3;i++) {
a = a*a;
b=b*b;
}
return a+b;
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
